Connect PeopleForce to ChatGPT: Automate HR, Hiring & Performance

If you want to connect PeopleForce to ChatGPT so your AI agents can automate employee onboarding, screen recruitment candidates, process leave requests, and manage performance reviews, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calling capabilities and the PeopleForce REST APIs. You can either spend weeks building and hosting this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on connecting PeopleForce to Claude or explore our broader architectural overview on connecting PeopleForce to AI Agents.

Giving a Large Language Model (LLM) read and write access to a comprehensive HRIS and ATS platform like PeopleForce is a significant engineering challenge. You have to handle complex nested data payloads, map dynamic custom fields for employees and candidates, and navigate an API surface that spans multiple versions simultaneously. Every time PeopleForce adds a new module or updates an endpoint, your custom server code must be updated, redeployed, and tested.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for PeopleForce, connect it natively to ChatGPT, and execute complex HR workflows using natural language.

The Engineering Reality of the PeopleForce API

Building a custom MCP server means owning the entire API lifecycle. While the open MCP standard provides a predictable way for models to discover tools, implementing it against an enterprise HR platform's API is exceptionally painful. Here are the specific integration challenges you face when working with PeopleForce:

API Version Fragmentation

PeopleForce's API is actively evolving, meaning different functional areas live on completely different API versions. Core HR employee data might be served on v3 endpoints, legacy compensation tools on v2, and organizational structures (departments, divisions) on v4. If you build a custom MCP server, you have to hardcode the versioning logic for every distinct resource. Truto abstracts this away, generating tools derived from the precise API versions documented by the vendor, exposing a unified tool surface to the LLM.

The Custom Field Mapping Problem

Unlike SaaS platforms with static endpoints, HR systems heavily rely on custom fields. In PeopleForce, custom fields for employees and candidates are not top-level JSON keys. Instead, they are returned inside a custom_fields object keyed by an internal_name. If an LLM needs to query an employee's custom "Shirt Size" for onboarding, it first needs to query the field definition endpoints (e.g., /employee_fields) to discover the internal_name, then map that key to the employee record. Truto's auto-generated documentation schemas teach the LLM exactly how to traverse these custom field structures without hardcoding.

Soft Deletes vs Hard Deletes

When an LLM agent needs to remove a record, the behavior in PeopleForce changes drastically depending on the entity. Deleting a team_member performs a hard delete, while deleting a team or department performs a soft delete (keeping the record in the database but marking it inactive). If your LLM attempts to fetch a soft-deleted record later, it will still receive a 200 OK response with a deactivated state, rather than the 404 Not Found it might expect. This nuance requires explicit tool descriptions to prevent agent hallucinations.

Strict Rate Limiting (And Why You Must Handle It)

Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream PeopleForce API returns an HTTP 429 (Too Many Requests), Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). This is a critical architectural choice: the caller (your agent framework or ChatGPT client) is entirely responsible for executing retry and exponential backoff logic. Do not expect the MCP server to absorb rate limit errors.

Quickstart: Creating a PeopleForce MCP Server

Truto scopes every MCP server to a single integrated account. This means the authentication and tenant context are baked directly into the connection. You can generate a PeopleForce MCP server using either the Truto UI or the API.

Method 1: Via the Truto UI

If you prefer a visual setup, you can generate the server directly from your dashboard:

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Click on the connected PeopleForce account you want to use.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., naming the server, filtering by allowed methods like read or write, and selecting specific feature tags).
6. Copy the generated MCP server URL. Treat this URL like a secure password.

Method 2: Via the Truto API

For teams building automated agent provisioning, you can generate the MCP server programmatically. You will need your Truto API token and the integrated_account_id for the PeopleForce connection.

curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "PeopleForce HR Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["core-hr", "recruitment", "performance"]
    }
  }'

The API will return a JSON payload containing the secure URL:

{
  "id": "mcp_abc123",
  "name": "PeopleForce HR Agent",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
}

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, connecting it to ChatGPT takes less than a minute. You can configure this through the ChatGPT interface or via a local configuration file if you are running an Enterprise desktop setup.

Method A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON (this is required to expose MCP features).
3. Under the MCP servers / Custom connectors section, click Add new server.
4. Enter a recognizable name (e.g., "PeopleForce (Truto)").
5. Paste the Truto MCP URL you generated earlier into the Server URL field.
6. Click Save. ChatGPT will immediately connect, perform an initialization handshake, and list the available PeopleForce tools.

Method B: Via Local Configuration File

If you are using a local agent framework or an MCP-compliant desktop client that relies on a configuration file, you can connect using the Server-Sent Events (SSE) transport.

Add the following to your mcp.json or equivalent configuration file:

{
  "mcpServers": {
    "peopleforce": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/YOUR_SECURE_TOKEN"
      ]
    }
  }
}

Hero Tools for PeopleForce Automation

Truto exposes the entirety of the PeopleForce API as MCP tools. For this guide, we are highlighting six high-leverage "hero tools" that enable end-to-end HR and recruitment automation.

Note: Do not prompt the LLM to guess endpoints. Provide it with clear instructions on which tools to use.

1. List Employees (v3)

Tool Name: list_all_people_force_employees

This tool retrieves the core employee directory. It supports filtering by status (active/terminated), emails, employee numbers, and managers. It returns comprehensive records including employment_type, department, job_level, and reporting_to.

"Use list_all_people_force_employees to find all active employees in the Engineering department who report to manager_id '12345'. Extract their employee IDs and email addresses."

2. Create a Recruitment Candidate

Tool Name: create_a_people_force_recruitment_candidate

Creates a new candidate in the ATS module. It accepts a name, email, phone numbers, cover letter text, and a resume URL. The API auto-matches duplicates based on email and CV parsing.

"Take the attached resume text and extract the candidate's name and email. Use create_a_people_force_recruitment_candidate to add them to PeopleForce, including a short summary of their skills in the cover_letter field."

3. List Pending Leave Requests

Tool Name: list_all_people_force_leave_requests_pendings_pending

Retrieves all time-off requests currently awaiting approval. This is essential for building an automated manager-approval workflow or a daily HR digest.

"Call list_all_people_force_leave_requests_pendings_pending to get all leave requests awaiting approval. Summarize them in a table showing the employee ID, leave type, hours requested, and dates."

4. Create a Timesheet Entry

Tool Name: create_a_people_force_time_timesheet_entry

Logs tracked time for a specific employee. It requires the employee_id, start time, end time, and an optional comment.

"The user 'John Doe' (employee_id: 887) said he worked from 9 AM to 5 PM today on the Q3 Migration project. Use create_a_people_force_time_timesheet_entry to log these hours, and add his comment about completing the database schema."

5. Update Employee Skills

Tool Name: create_a_people_force_employee_skills_employee

Adds a specific skill and proficiency level to an employee's talent profile. This is highly useful for automated performance review summaries or certification tracking.

"Based on the certification document provided, use create_a_people_force_employee_skills_employee to add the 'AWS Certified Solutions Architect' skill (skill_id: 42) at proficiency level 'Expert' for employee_id 112."

6. Schedule an Employee Termination

Tool Name: create_a_people_force_employee_terminate

Schedules an employee for offboarding. It sets the termination effective date, termination type, and reason. It automatically updates their status on the effective date.

"Use create_a_people_force_employee_terminate to schedule the offboarding for employee_id 305. Set the effective date to next Friday, use termination_reason_id 4 (Voluntary Resignation), and mark them as eligible_for_rehire."

View the complete PeopleForce tool inventory and schema definitions in the Truto Integration Directory.

Workflows in Action

Connecting tools is only half the battle. The real power of an MCP server is orchestrating multi-step workflows. Here are two concrete examples of how ChatGPT can automate complex PeopleForce operations.

Scenario 1: Automated Candidate Pre-Boarding

When a candidate accepts an offer, HR typically spends hours copying data from the ATS module into the Core HR module to create the employee profile. ChatGPT can completely automate this transition.

"A candidate named Jane Smith just accepted our offer. Find her in the recruitment module, extract her details, and create a new active employee profile for her starting next Monday. Assign her to the Sales department."

How the agent executes this:

1. Search Candidates: ChatGPT calls list_all_people_force_recruitment_candidates with email="jane.smith@example.com" to retrieve her candidate ID and custom fields.
2. Get Department ID: It calls list_all_people_force_departments_v_4 and filters the response to find the ID for the "Sales" department.
3. Create Employee: It calls create_a_people_force_public_employees_v_3, passing in Jane's first name, last name, email, department ID, and a hired_on date set to next Monday.
4. Report Back: The agent returns the newly created employee_id and confirms the profile is active.

sequenceDiagram
    participant User
    participant GPT as ChatGPT
    participant Truto as Truto MCP
    participant PF as "PeopleForce API"

    User->>GPT: "Jane Smith accepted the offer. Convert her to an employee in Sales."
    GPT->>Truto: Call list_all_people_force_recruitment_candidates (email: jane...)
    Truto->>PF: GET /v3/recruitment/candidates?email=...
    PF-->>Truto: Candidate Data
    Truto-->>GPT: Candidate Data
    GPT->>Truto: Call list_all_people_force_departments_v_4
    Truto->>PF: GET /v4/departments
    PF-->>Truto: Department Array
    Truto-->>GPT: Department Array
    GPT->>Truto: Call create_a_people_force_public_employees_v_3
    Truto->>PF: POST /v3/employees (Payload)
    PF-->>Truto: New Employee ID
    Truto-->>GPT: Success (ID: 9942)
    GPT-->>User: "Jane Smith is now an active employee starting next Monday."

Scenario 2: Weekly Leave & Timesheet Audit

Managers often struggle to reconcile timesheets with approved leave. An AI agent can audit the week's data and flag discrepancies instantly.

"Audit the timesheets and leave requests for the Engineering team from last week. Tell me if anyone logged hours on a day they had approved time off."

How the agent executes this:

1. Fetch Team Members: ChatGPT calls list_all_people_force_teams_v_3 to find the Engineering team, extracting the user_id array.
2. Fetch Leave: It calls list_all_people_force_leave_requests using the date range filters to pull approved absences for those specific users.
3. Fetch Timesheets: It calls list_all_people_force_time_timesheet_entries for the same date range.
4. Analyze: The LLM cross-references the dates. If it finds a timesheet entry logged on a date marked as state: "approved" in the leave request array, it generates a discrepancy report.

Security and Access Control

When exposing a sensitive HR system to an LLM, security is paramount. Truto's MCP servers provide granular controls to restrict what an agent can see and do.

• Method Filtering (methods): When generating the MCP server, you can restrict the token to specific HTTP verbs. Setting methods: ["read"] ensures the agent can only call GET and LIST tools. It physically cannot execute POST, PATCH, or DELETE tools, eliminating the risk of accidental data modification.
• Tag Filtering (tags): You can limit the server to specific API domains. Passing tags: ["recruitment"] ensures the LLM only sees tools related to the ATS. It won't even know the core HR or payroll endpoints exist.
• Extra Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. By setting require_api_token_auth: true, the connecting client must also pass a valid Truto API token in the headers. This prevents unauthorized access if the MCP URL is leaked in a configuration file.
• Auto-Expiration (expires_at): You can set an exact ISO datetime for the server to self-destruct. This is perfect for giving a contractor or a temporary AI agent short-lived access to PeopleForce data without having to remember to revoke it manually.

Strategic Wrap-up

Connecting PeopleForce to ChatGPT natively via MCP transforms HR from a system of record into an active, conversational participant in your business. By using Truto to generate the server, you skip the grueling process of mapping dynamic custom fields, hardcoding endpoint versions, and maintaining authentication lifecycles.

Instead of writing boilerplate infrastructure, your engineering team can focus immediately on building agentic workflows that save HR and recruitment teams hundreds of hours a month.

Ready to automate your PeopleForce workflows?