Retrieve structured metadata for a specific SAP SuccessFactors entity.

Returns the entity's properties (fields), their types, whether they are editable, required, or picklist-based, plus navigation properties (relationships).

Use this to understand what fields are available on an entity before building business rules that reference those fields.

List all available OData entities in the SAP SuccessFactors instance.

Returns entity set names from $metadata. Optionally filter by prefix (e.g., 'Emp' for employment entities, 'FO' for Foundation Objects, 'Per' for person entities).

Note: Fetching full metadata can be slow (5-30 seconds). Use filter_prefix or query a specific entity with get_entity_metadata instead.

Get all options (values) for a specific picklist in SAP SuccessFactors.

Picklists are dropdown/select fields. Returns the external code (API value), label (display text), and status for each option.

Use this to validate that picklist values referenced in business rules actually exist in the target instance.

Execute a flexible OData query against any SAP SuccessFactors entity.

Supports filtering, field selection, navigation expansion, pagination, and sorting.

Examples:

• Active employees: entity='EmpEmployment', filter="endDate eq datetime'9999-12-31T00:00:00'"

• Company details: entity='FOCompany', select='externalCode,name,country'

• Job info with company: entity='EmpJob', expand='companyNav', top=5

Validate that fields, entities, and picklist values referenced in a proposed business rule actually exist in the SAP SuccessFactors instance.

For each field:

1. Verifies the entity exists in $metadata

2. Verifies the field exists on that entity

3. Checks the field type (string, date, picklist, number)

4. If picklist values are provided, verifies they exist

5. Checks if the field is editable (creatable or updatable)

Example fields_to_validate: [ {"field": "payGroup", "entity": "EmpJob", "values": ["PG_PE_FT", "PG_PE_PT"]}, {"field": "employeeClass", "entity": "EmpJob", "values": ["FT", "PT"]}, {"field": "countryOfCompany", "entity": "EmpJob"} ]

Generate a complete Business Rule specification from a natural language requirement.

This tool:

1. Queries the SF instance metadata to identify relevant fields

2. Validates all referenced fields and picklist values exist

3. Builds IF/THEN/ELSE condition logic

4. Generates naming, execution notes, and best practice recommendations

The output can be passed to generate_rule_doc (documentation) and generate_rule_test (test cases).

Example requirement: "When saving Job Information, if the employee's country is Peru and employee class is Full-Time, set pay group to PG_PE_FT. If Part-Time, set to PG_PE_PT."

Generate step-by-step implementation documentation for a business rule.

Produces a consultant-ready guide for creating the rule in the SAP SuccessFactors Rule Editor UI, including:

• Navigation steps in Admin Center

• Rule creation dialog values

• Each IF/THEN condition to configure

• HRIS Element assignment instructions

• Event type configuration

• Post-implementation verification steps

Generate a comprehensive test case matrix for a business rule.

Produces test cases covering:

• Each condition path (positive scenarios)

• Edge cases (empty fields, null values, boundary conditions)

• Negative cases (conditions that should NOT trigger the rule)

• Coverage matrix showing which paths are tested

Each test case includes preconditions, action, and expected results.

Search for employees using natural language queries.

Supports searching by:

• Name: "John", "John Smith", "Smith"

• Department: "department 40000013", "dept HR"

• Country: "country COL", "employees in Colombia"

• Status: "active employees", "terminated employees"

• Location: "location NYC"

• Manager: "reports to admin", "manager 12345"

• Company: "company 1000"

• User ID: "user admin"

Combinations work too: "active employees in department 40000013"

Get a complete employee profile by assembling data from multiple SF entities.

Fetches User, EmpJob, EmpCompensation, EmpEmployment, PerPersonal, PerEmail, and PerPhone in parallel for maximum performance.

Sections can be filtered to reduce API calls. Effective-dated entities (job, compensation, personal) use as_of_date for point-in-time queries.

Get the organizational chart centered on a specific employee.

Navigates upward through managerId to show the management chain, and downward to show direct reports. Uses EmpJob for manager relationships and User for names/titles.

Get the history of changes for an employee.

Retrieves effective-dated records ordered by date descending, showing the timeline of changes. Supports job (EmpJob), compensation (EmpCompensation), and employment (EmpEmployment) history.

Compare multiple employees side by side.

Fetches profiles for all specified employees in parallel and returns a comparison matrix highlighting differences. Useful for auditing or verifying employee data consistency.

Get organizational structure at a specific level.

Queries Foundation Object entities (FOCompany, FODepartment, etc.) to show the organizational hierarchy. Can optionally include headcount per unit by cross-referencing with EmpJob.

Levels: company, division, department, business_unit, cost_center, location, job_code, pay_grade.

Get position details from Position Management.

Retrieve specific positions or filter by department/vacancy status. Returns position code, name, department, job code, incumbent, and vacancy status.

List Foundation Objects of any type.

A flexible tool to query any Foundation Object entity. Use friendly names like 'company', 'department', 'location' or direct entity names like 'FOCompany'.

Foundation Objects are the reference/master data that define the organizational structure in SuccessFactors.

List business rules configured in the SAP SuccessFactors instance.

Queries the RuleHeaderBean entity to show configured rules. Filter by scenario, base object, or search by name. Useful to understand what rules are already in place before creating new ones.

List permission roles configured in the SAP SuccessFactors instance.

Queries RBPRole (Role-Based Permissions) and/or FODynamicRole entities. Useful for understanding the security model and role assignments.

Validate an import template's headers and sample data against SF metadata.

Checks that all column headers correspond to actual fields on the target entity, identifies missing key/required fields, and validates sample data types. Use this before executing an import to catch errors early.

Generate an import template with correct field headers for an SF entity.

Creates a CSV-ready template structure with field names, types, and whether they are key/required fields. Optionally includes valid picklist values to help with data preparation.

Execute an upsert operation against an SF entity.

IMPORTANT: Defaults to dry_run=True. In dry_run mode, validates all records against metadata without making any changes. Set dry_run=False to actually write data.

Records are processed in batches. Each record is sent as an individual OData POST (upsert) to the entity endpoint.

Get headcount grouped by a specific field.

Aggregates employee counts by department, company, location, country, etc. Computed client-side since OData v2 doesn't support $apply/groupby.

Note: For large organizations, results are based on up to 5000 active employee records.

Get compensation statistics (average, min, max, median compa-ratio and range penetration) grouped by a scope field.

Queries EmpCompensation joined with EmpJob for the scope field. Note: Limited to 5000 records for performance.

Simulate the impact of a business rule against real employee data.

Evaluates the rule's conditions against actual employee records and shows which employees would be affected and what changes would be made. This is a read-only simulation — no data is modified.

Useful for impact analysis before deploying a new rule.

Compare entity metadata between two SF instances.

Detects fields that exist in one instance but not the other, type mismatches, and annotation differences (editability, labels). Essential for cutover validation (DEV → QA → PROD).

Compare picklist values between two SF instances.

Detects values that exist in one instance but not the other, and label differences for matching values. Critical for ensuring picklist consistency during migrations.

Compare business rules between two SF instances.

Shows rules that exist in one instance but not the other, and differences in rule properties (scenario, base object, status). Essential for cutover validation.

Compare Foundation Objects between two SF instances.

Detects FO records that exist in one instance but not the other, and field differences for matching records (by externalCode).

Run data integrity checks on a single employee.

Validates: job info exists, employment record exists, personal info complete, effective dates are consistent, manager is valid, compensation exists, email is present. Returns findings with severity levels.

Detect data anomalies in SF entities.

Types:

• 'empty': Find records where the specified field is blank/null

• 'duplicates': Find duplicate values in the specified field

• 'future_dates': Find date fields with values in the future

• 'orphan': Find records referencing non-existent FO/user records

Trace which business rules would apply to an employee for a given event.

Fetches the employee's current data, then checks each configured rule's conditions against that data. Shows which rules match, which don't, and why. Invaluable for debugging "why did this field get this value?"

Look up permission role details.

Queries RBPRole and FODynamicRole to find matching roles. Note: Actual field-level RBP permissions are not exposed via OData v2. This tool helps identify which roles exist and their basic properties.

Validate effective dating for time-sliced entities.

Detects gaps and overlaps in effective-dated records. These are the most silent and destructive data bugs — an employee may appear to have no active record on a specific date due to a gap.

Generate a functional specification document for an SF entity/portlet.

Produces a structured spec with:

• Entity overview and key fields

• Field mapping (name, type, label, editability, picklist info)

• Configured business rules (optional)

• Navigation properties / relationships

• Recommendations

Output is structured for easy conversion to Word/PDF.

Generate a cutover checklist for migrating configuration from DEV to PROD.

Produces an ordered checklist based on entity dependencies, including:

• Foundation Objects in correct load order

• Picklist configurations

• Business rules

• User/employee data in dependency order

Essential for go-live planning.

Generate a complete data dictionary for multiple SF entities.

For each entity, produces a field-by-field reference with: name, type, label, key status, required, creatable, updatable, picklist info.

Output is structured as CSV-exportable rows for easy import into Excel.

Generate an end-to-end test script for a specific HR scenario.

Produces step-by-step test instructions including:

• Preconditions

• Step-by-step actions

• Expected results at each step

• Business rule validations

• Country-specific checks

No SF API calls needed — uses knowledge base.

Deep validation of a migration/import CSV file.

Validates:

• Column headers match entity metadata

• Key fields are present and populated

• Data types are correct (dates, numbers, strings)

• Required fields are populated

• Picklist values exist (strict mode)

• Foreign key references exist (strict mode)

• Date format consistency

Returns detailed error report per row.

Calculate the correct load order for a set of entities based on dependencies.

Uses the predefined dependency graph from knowledge base to ensure Foundation Objects are loaded before employee data, employment before job info, etc.

Returns the ordered sequence with dependency notes.

Reconcile data after migration — compare expected vs actual record counts.

Can reconcile at entity level (total count) or grouped by a field (e.g., count per company, per department). Essential for cutover day validation.

Generate a purge/delete file for SF import.

Fetches records matching the filter and returns them with the correct key fields for deletion via SF import. Output includes CSV content ready for the SF Import tool's purge mode.

IMPORTANT: Review the records carefully before using for deletion.

Get complete metadata for an MDF object.

Returns all fields, types, labels, editability flags, picklist associations, and navigation properties. Works for both custom (cust_*) and standard MDF objects.

Generate an import template for an MDF object.

Creates a CSV-ready template with key fields, required fields, and optionally all editable fields. Includes field type info as comments.

List all MDF objects configured in the SF instance.

Categories:

• 'custom': Only cust_* objects (custom MDF)

• 'standard': Only standard SAP MDF objects

• 'all': Everything

Many instances have 50+ custom MDF objects with unclear purposes. This tool helps inventory them.

Run pre-go-live validation checks on the SF instance.

Validates:

• Critical: Employees without jobs, orphan records, missing key dates

• Important: Vacant positions with incumbents, self-referencing managers, inactive FOs in use

• Recommended: Email/phone completeness, compensation completeness

Returns a pass/fail report for each check with sample affected records.

Generate a reconciliation report comparing expected vs actual record counts.

Queries each entity for its record count and compares against expected values from the source system. Essential for cutover day validation.

Get country-specific fields for a PerGlobalInfo entity.

Returns the required fields, common picklists, compliance notes, and typical business rules for the specified country. Covers: COL (Colombia), MEX (Mexico), PER (Peru), CHL (Chile), ARG (Argentina), BRA (Brazil), USA (United States), ESP (Spain).

Optionally fetches live metadata from the instance to compare against the knowledge base.

Validate that employees in a country have all required country-specific fields.

Checks each employee against the country's required fields (from knowledge base) and reports which fields are missing or empty. Essential for payroll and compliance readiness.

Generate a configuration guide for a specific country.

Includes:

• Required PerGlobalInfo fields and their purpose

• Picklists that need to be configured

• Compliance requirements and notes

• Typical business rules to implement

• Data validation recommendations

No SF API call needed — uses knowledge base.

Generate a populated Object & Picklist Data workbook from the live SF instance.

Reads all Foundation Objects (Legal Entity, Business Unit, Division, Department, Cost Center, Job Family, Job Function, Job Code, Location, Pay Grade, Pay Range, Pay Group, Pay Component, Pay Component Group, Event Reason, Time Type, etc.) and Picklists, then writes them to a dated Excel file in exports/.

The output file format exactly matches the client template column layout. Header rows 1-2 are preserved from the template. Data starts at row 3.

Returns: { file, sheets_populated, sheets_skipped, summary, warnings }

Generate a populated Workflow Notifications & Messages workbook from the live SF instance.

Populates: Workflows Tab, WF Processes, Dynamic Roles, Workflow Groups, Alert Messages, Message Definitions, Email Notification Templates.

Workflow Configuration Settings is preserved unchanged (manual — no OData API).

Returns: { file, sheets_populated, sheets_skipped, summary, warnings }

Populate the Employee Central Rules sheet in the Employee Field Data & RBP workbook.

Reads all Business Rules from RuleHeaderBean and maps them to the 8 columns: HRIS Element / Object | Rule Name | Rule Trigger Type | Field to Trigger onChange Rule | Functional Description | Rule Description | Rule Base Object | Rule ID

All other sheets in the RBP workbook are preserved unchanged (manual).

Returns: { file, rules_count, warnings }