Connect Culture Amp to ChatGPT: Analyze Employee & Review Data

If you need to connect Culture Amp to ChatGPT to automate performance review analysis, pull employee demographics, or track organizational feedback, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's JSON-RPC tool calls and Culture Amp's REST APIs. You can either spend weeks building and maintaining 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 Culture Amp to Claude or explore our broader architectural overview on connecting Culture Amp to AI Agents.

Giving a Large Language Model (LLM) access to sensitive HR data requires strict scoping and precise data modeling. Performance review APIs are notoriously complex, featuring deeply nested question schemas, decoupled demographic data, and strict rate limits. Every time an LLM wants to summarize a review cycle, it must navigate a maze of relational IDs.

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

The Engineering Reality of the Culture Amp 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 Culture Amp's specific architecture is challenging.

If you decide to build a custom MCP server for Culture Amp, here are the specific integration realities you must handle:

Decoupled Core Data and Demographics

In Culture Amp, a base employee record contains standard fields like name, email, and start date. However, custom organizational metrics - department, location, role level, and tenure bands - are stored as demographics. An LLM cannot just fetch an employee and see their department. It must query the base employee, extract the ID, and make a subsequent call to the demographics endpoint. Your LLM prompt instructions (and tool descriptions) must explicitly teach the model this relational hop, or it will hallucinate demographic data.

Deeply Nested Review Schemas

Manager reviews in Culture Amp are not flat text fields. They are structured arrays of different question types. A single review payload contains separate arrays for openTextQuestions, multipleChoiceQuestions, and multipleChoiceMultiSelectQuestions. If you hand-roll your MCP tools, you must write highly specific JSON schemas for the LLM so it understands how to parse these arrays when summarizing a manager's feedback. Truto automatically generates these exact schemas from the underlying API documentation.

Standardized Rate Limit Handling

Culture Amp enforces rate limits to protect its infrastructure. A common mistake when connecting AI agents to HR platforms is assuming the middleware will magically absorb rate limit errors. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Culture Amp API returns an HTTP 429, Truto passes that exact error to the caller.

What Truto does do is normalize the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. This allows the calling client - in this case, the script wrapping ChatGPT or your custom agent framework - to read standard headers and implement its own intelligent backoff strategy.

sequenceDiagram
  participant ChatGPT as ChatGPT Client
  participant Truto as Truto MCP Router
  participant Upstream as Culture Amp API
  
  ChatGPT->>Truto: Call list_all_culture_amp_employees (limit 100)
  Truto->>Upstream: GET /v1/employees
  Upstream-->>Truto: HTTP 429 Too Many Requests
  Truto-->>ChatGPT: HTTP 429 with IETF ratelimit headers
  Note over ChatGPT: Client applies exponential backoff

Step 1: Create the Culture Amp MCP Server

To connect Culture Amp to ChatGPT, you first need to generate the MCP server URL. Truto scopes every MCP server to a single integrated account (a specific tenant's connected Culture Amp instance). The resulting URL contains a secure cryptographic token that handles all routing and authentication.

You can generate this URL using either the Truto UI or the API.

Method A: Via the Truto UI

This is the fastest approach for internal tooling and manual ChatGPT setups.

1. Log into your Truto dashboard and navigate to Integrated Accounts.
2. Select your connected Culture Amp account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your configuration. You can name the server, apply method filters (e.g., read-only), and set an expiration date if this is temporary access.
6. Click Create and copy the generated URL (it will look like https://api.truto.one/mcp/<token>).

Method B: Via the Truto API

If you are building a product that programmatically deploys AI agents for your customers, you will generate this URL via the Truto API.

Make an authenticated POST request to the /mcp endpoint for the specific integrated account. This endpoint validates that tools are available, stores the hashed token in managed infrastructure, and returns the ready-to-use URL.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Culture Amp Review Analysis MCP",
    "config": {
      "methods": ["read"],
      "tags": ["employees", "performance_cycles"]
    }
  }'

The response returns the URL that you will pass to your LLM framework or ChatGPT:

{
  "id": "mcp_12345abcde",
  "name": "Culture Amp Review Analysis MCP",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Step 2: Connect the MCP Server to ChatGPT

Once you have the Truto MCP URL, connecting it to ChatGPT requires zero custom code. ChatGPT natively understands the JSON-RPC 2.0 protocol over HTTP.

Method A: Via the ChatGPT UI (Custom Connectors)

If you are an end-user on a compatible ChatGPT plan (Pro, Plus, Business, Enterprise, or Education), you can add the server directly to your workspace.

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON.
3. Under the MCP servers or Custom connectors section, click Add new.
4. Enter a recognizable name (e.g., "Culture Amp (Truto)").
5. Paste the Truto MCP URL into the Server URL field.
6. Click Save.

ChatGPT will immediately ping the endpoint, execute the tools/list initialization handshake, and populate its context window with the available Culture Amp capabilities.

Method B: Via Manual Config File (SSE Transport)

If you are orchestrating agents locally or using alternative desktop clients that require Server-Sent Events (SSE) configuration, you can use the official MCP SSE server wrapper.

Create a mcp.json config file:

{
  "mcpServers": {
    "culture_amp_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<your-token-here>"
      ]
    }
  }
}

Culture Amp Hero Tools

Truto dynamically generates tools by inspecting the underlying API documentation. If an endpoint is documented, it becomes an AI tool. Here are the highest-leverage tools available for Culture Amp data analysis.

list_all_culture_amp_employees

Fetches a paginated list of all employees in the account. This is the primary entry point for agentic workflows to resolve a human name to a system id.

Returns: id, employeeIdentifier, email, name, preferredName, birthDate, startDate, endDate, links, processedAt.

"Find the employee record for Jane Doe and retrieve her internal ID and start date."

list_all_culture_amp_employee_demographics

Retrieves the demographic assignments for a specific employee. Because Culture Amp separates core fields from org data, the LLM must use this tool to determine an employee's department, manager, or location.

Returns: name, value. Required: employee_id.

"Look up the demographics for employee ID 58291 and tell me which department and location they are assigned to."

list_all_culture_amp_performance_cycles

Lists all performance cycles across the organization. This is required before the LLM can query reviews, as most review data is partitioned by cycle ID.

Returns: id, name, state, createdAt, updatedAt, processedAt.

"List all the performance cycles in our Culture Amp account and find the ID for the 'Q3 2024 Engineering Review' cycle."

list_all_culture_amp_performance_cycle_manager_reviews

Retrieves all manager reviews submitted within a specific performance cycle. This is incredibly powerful for bulk analysis, allowing the LLM to process organization-wide feedback.

Returns: performanceCycleId, managerReviewId, employeeId, managerId, performanceRating, openTextQuestions, multipleChoiceQuestions, status. Required: performance_cycle_id.

"Get all manager reviews for the Q3 2024 performance cycle. Filter the results to only show reviews with a status of 'completed'."

list_all_culture_amp_employee_manager_reviews

Retrieves the entire manager review history for a specific individual. Perfect for tracking performance trajectories over time.

Returns: performanceCycleId, managerReviewId, employeeId, managerId, performanceRating, status, completedAt. Required: employee_id.

"Fetch all historical manager reviews for employee ID 88312 and summarize their performance trajectory over the last two years."

get_single_culture_amp_manager_review_by_id

Retrieves the deep, verbose payload for a single manager review. The LLM uses this to read the actual text responses written by a manager during an appraisal.

Returns: Full review including employeeId, managerId, performanceRating, and complete nested question responses. Required: id.

"Pull the detailed manager review for review ID 9921. Read the open text questions and summarize the primary areas of improvement identified by the manager."

To view the complete schema definitions and the full inventory of available endpoints, visit the Culture Amp integration page.

Workflows in Action

Connecting these tools to ChatGPT unlocks powerful automation for HR teams and managers. Here is how standard requests translate into specific tool execution sequences.

Scenario 1: Summarizing an Employee's Historical Performance

An HR Business Partner wants to prepare for a compensation review meeting and asks ChatGPT to summarize a specific employee's track record.

"Find the employee record for Alex Chen, check what department he is in, and summarize all of his manager reviews from the past two years. Highlight his strengths and areas for growth."

Execution steps:

1. list_all_culture_amp_employees: ChatGPT searches for "Alex Chen" and extracts the id (e.g., 45521).
2. list_all_culture_amp_employee_demographics: The model queries demographics for 45521 to confirm he is in the Engineering department.
3. list_all_culture_amp_employee_manager_reviews: ChatGPT pulls the list of all manager reviews tied to 45521, extracting the managerReviewId for the last two cycles.
4. get_single_culture_amp_manager_review_by_id: The model loops through the review IDs, reading the deep payload of openTextQuestions.

Result: ChatGPT outputs a synthesized brief detailing Alex's role in Engineering, his numerical performance ratings over time, and a thematic summary of the open-text feedback written by his managers.

Scenario 2: Auditing Performance Cycle Completion

An HR administrator needs to know which managers are lagging behind on their reviews for the current cycle.

"Find the 'End of Year 2024' performance cycle. Check all the manager reviews for that cycle and give me a list of the manager IDs who have reviews currently stuck in the 'draft' or 'unacknowledged' status."

Execution steps:

1. list_all_culture_amp_performance_cycles: ChatGPT fetches the cycles and identifies the id for "End of Year 2024".
2. list_all_culture_amp_performance_cycle_manager_reviews: The model calls this tool using the cycle ID, returning the massive list of all reviews in that cycle.
3. Internal Logic: ChatGPT filters the JSON array in its context window, looking for objects where the status field is not completed.

Result: ChatGPT returns a bulleted list of manager IDs whose reviews are incomplete, saving the HR admin from exporting and formatting CSVs manually.

Security and Access Control

When dealing with HR and performance data, access control is non-negotiable. Truto provides four mechanisms at the MCP server level to guarantee that your LLM never accesses data it shouldn't.

• Method Filtering: You can strictly limit the MCP server by passing config.methods: ["read"] during creation. This enforces that the LLM can only execute GET or LIST operations. Even if the LLM hallucinates a POST request to update a review, the server will reject it at the routing layer.
• Tag Filtering: Integrations in Truto group resources by tags. You can pass config.tags: ["performance"] to ensure the server only exposes performance cycle and review tools, completely hiding other endpoints like surveys or feedback loops.
• Secondary Authentication (require_api_token_auth): By default, the cryptographically secure URL is enough to authorize requests. For high-security environments, you can enable require_api_token_auth: true. This forces the client to pass a valid Truto API token in the authorization header, ensuring that URL leakage does not result in a data breach.
• Automatic Expiration (expires_at): If you only need to grant temporary access to a specific workflow (e.g., a one-off audit agent), you can set an ISO datetime string in the expires_at field. Truto handles the automated cleanup and infrastructure tear-down when the token expires.

Closing the Loop on HR Automation

Exposing Culture Amp data to an LLM unlocks massive productivity gains for HR analytics. However, building the underlying integration architecture - navigating decoupled demographics, normalizing deep review schemas, and managing strict rate limit headers - is a painful distraction from your core product.

By leveraging Truto's dynamic MCP server generation, you offload the entire integration lifecycle. You get secure, explicitly scoped, and automatically documented tools that ChatGPT can consume natively. Stop fighting API quirks and start building agentic workflows.