Connect Chorus to ChatGPT: Manage Meetings & Team Workflows

If you are building AI workflows around conversation intelligence, you need to connect Chorus to ChatGPT. Engineering teams waste hundreds of hours reading vendor docs and mapping nested media payloads just to get an LLM to interact with recorded meetings. By exposing Chorus via Truto's Model Context Protocol (MCP) server, you can turn complex conversation logic into a set of highly reliable, ready-to-use tools for ChatGPT.

This article is part of a set on integrating conversation intelligence with AI. If your team uses Claude, check out our guide on connecting Chorus to Claude, or explore general agentic setups in our guide to connecting Chorus to AI Agents.

Below, we cover how to generate a secure MCP server for Chorus, connect it to ChatGPT, and execute complex workflows without writing glue code.

The Engineering Reality of the Chorus API

Building a Chorus integration from scratch requires navigating several highly specific API behaviors that break generic REST clients:

• Media format negotiation: The media endpoints (get_single_chorus_media_by_id) default to returning binary video files. If you want metadata and a download link, you must explicitly pass an Accept: application/json header. Truto's proxy architecture normalizes this for tool calling so LLMs don't inadvertently try to ingest raw MP4 blobs.
• HMAC and AuthMS complexity: Chorus relies on specific AuthMS connectors for third-party syncs (Google, Zoom, Webex) and handles certain authentications via HMAC signed requests (create_a_chorus_auth_signed_request). Truto handles these backend handshake flows automatically, abstracting the multi-step 307 redirects away from the LLM.
• Verification constraints: Service accounts in Chorus (like Office 365 or Google Calendars) require verifying at least two accessible email addresses during the initial setup via chorus_integrations_office_365_calendars_verify.

Creating the MCP Server for Chorus

Truto automatically generates dynamic, documentation-driven MCP tools from the connected Chorus instance. You can instantiate an MCP server via the Truto UI or programmatically via the API. If you are interested in the underlying architecture, check out our guide to building MCP servers.

1. Via the Truto UI

1. Navigate to the Integrated Accounts section in your Truto dashboard.
2. Select your connected Chorus instance.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select the desired filters (e.g., read-only, specific tags, or expiration times).
6. Copy the generated MCP server URL.

2. Via the API

For production workflows, you can generate MCP servers programmatically for your tenants by making an authenticated request to the Truto API.

Endpoint: POST /integrated-account/:id/mcp

{
  "name": "ChatGPT Chorus Access",
  "config": {
    "methods": ["read", "write", "custom"]
  }
}

The API securely hashes a token, persists it to a distributed Key-Value store for low-latency lookups, and returns the server URL.

{
  "id": "mcp_abc123",
  "name": "ChatGPT Chorus Access",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/token..."
}

Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, you can plug it into ChatGPT. There are two primary methods depending on your environment.

UI Connector Flow

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode on (requires a Plus, Team, or Enterprise account).
3. Under MCP servers / Custom connectors, add a new server.
4. Name: "Chorus (Truto)".
5. Server URL: Paste the Truto MCP URL.
6. Save the configuration. ChatGPT will immediately initialize the JSON-RPC 2.0 handshake and list the available Chorus tools.

Manual Config File Approach

If you are running a custom ChatGPT desktop wrapper or a local agent environment, you can configure the MCP connection via your standard configuration file:

{
  "mcpServers": {
    "chorus": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-openapi",
        "https://api.truto.one/mcp/token..."
      ]
    }
  }
}

Chorus Tool Inventory

Truto exposes the entirety of the Chorus API as callable tools. For full schema details, visit the Chorus integration page.

Hero Tools

These are the highest-impact tools for meeting intelligence workflows:

list_all_chorus_conversations

Fetches meeting conversations via the engagements endpoint. Returns engagement objects filtered to type MEETING, providing duration, processing state, and participant data.

"List all my Chorus conversations from this week that lasted longer than 30 minutes."

get_single_chorus_conversation_by_id

Retrieves the complete conversation object, including the transcript, deal metrics, recording details, participants, and generated action items.

"Get the details and summary for conversation ID 98765."

chorus_conversations_join

Instructs the Chorus recorder to join a live call immediately. Requires posting the plain text invitation link (e.g., a Zoom or Google Meet URL).

"Send the Chorus bot to join the live Zoom meeting at https://zoom.us/j/123456."

create_a_chorus_moment

Creates a "moment" (a flagged bookmark or note) within a specific conversation. Links directly to a speaker, timecode, and opportunity.

"Flag a moment in conversation 98765 at the 15-minute mark labeled 'Pricing Discussion'."

create_a_chorus_sales_qualification

Triggers the Sales Qualification Framework extraction against a call transcript, scanning for CRM intelligence (like MEDDIC criteria).

"Run a sales qualification extraction for recording ID 98765 to find missing MEDDIC fields."

chorus_sales_qualifications_writeback_crm

Submits field-level changes directly to a connected CRM (like Salesforce) based on the insights gathered during a meeting.

"Write the discovered budget criteria from meeting 98765 back to the Salesforce Opportunity."

Workflows in Action

With Chorus connected to ChatGPT via Truto's MCP server, you can construct complex, multi-step workflows.

Scenario 1: On-Demand Meeting Capture & Annotation

Sales teams frequently jump into ad-hoc calls and realize mid-way that the discussion is critical. ChatGPT can instruct Chorus to join and immediately begin tracking insights.

"Send the Chorus bot to join my ad-hoc meeting at https://zoom.us/j/999888. Once it joins, flag a moment to note that the client initiated a security review."

Execution Steps:

1. chorus_conversations_join: The LLM passes the Zoom link in the request body. Chorus returns the new conversation_id.
2. create_a_chorus_moment: Using the returned ID, the LLM creates a moment describing the security review initiation, pinning it to the active call timeline.

Scenario 2: Post-Call CRM Qualification

Sales engineers need to ensure CRM data reflects reality without doing manual data entry. ChatGPT can extract insights and push them to Salesforce via Chorus.

"Pull the conversation details for our last meeting with Acme Corp. Run a sales qualification analysis on it, and if budget is confirmed, write that back to the CRM opportunity."

Execution Steps:

1. list_all_chorus_conversations: The LLM searches recent engagements to find the specific Acme Corp meeting ID.
2. create_a_chorus_sales_qualification: The LLM requests an SQF analysis against the meeting transcript to extract qualification fields.
3. chorus_sales_qualifications_writeback_crm: If the analysis returns a positive budget indication, the LLM submits the crm_changes payload, updating the connected CRM opportunity directly through the Chorus API.

Handling Rate Limits

When connecting ChatGPT to Chorus, it is vital to understand how rate limiting operates at the infrastructure level. Truto does not retry, throttle, or apply backoff logic to rate limit errors.

When the upstream Chorus API returns an HTTP 429 response, Truto passes that error directly to the caller. However, Truto does normalize the upstream rate limit information into standardized HTTP headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. Your client or agent framework is responsible for detecting the 429 status, reading the normalized headers, and implementing the appropriate retry and backoff logic.

Security and Access Control

Truto MCP servers implement a zero-trust model out of the box, allowing granular control over what the LLM can access. (See our guide on how to safely give an AI agent access to SaaS data).

• Method Filtering: Constrain the server during creation to specific operations. For example, passing methods: ["read"] ensures the LLM can only query data and cannot alter CRM records or delete recordings.
• Tag Filtering: Group tools by functional area using config.tool_tags. If you only want ChatGPT to manage users, you can filter the MCP server to only include directory-related endpoints.
• Require API Token Auth: By setting require_api_token_auth: true, you mandate a second layer of authentication. The caller must provide a valid Truto API token in addition to possessing the MCP server URL.
• Expires At: For temporary agent access, assign an ISO datetime to the expires_at property. Truto automatically schedules a database and KV store cleanup, permanently invalidating the connection when the time elapses.

Stop writing integration boilerplate. Generate secure, reliable MCP servers for 100+ APIs in minutes with Truto. :::