Connect Guru to ChatGPT: Manage Cards, Knowledge Agents, and Answers

If you need to connect Guru to ChatGPT to automate knowledge retrieval, verify outdated documentation, or query internal experts, you need a Model Context Protocol (MCP) server. This server translates ChatGPT's native tool-calling JSON into Guru's specific REST API operations.

If your team uses Claude, check out our guide on connecting Guru to Claude and connecting Guru to AI Agents.

Giving a Large Language Model (LLM) read and write access to a company's internal knowledge base is a serious engineering challenge. Guru's API surface is deep—handling everything from simple card CRUD to async AI evaluations, complex access control lists, and streaming chat thread outputs. If you decide to build a custom MCP server, you are signing up to map every single one of these endpoints to a JSON schema by hand, manage OAuth token refreshes, and deploy infrastructure to handle the JSON-RPC traffic.

This guide breaks down how to bypass that boilerplate by using Truto to dynamically generate a secure, authenticated MCP server for Guru, connect it to ChatGPT, and execute complex knowledge management workflows using natural language.

The Engineering Reality of the Guru API

Building a custom MCP server requires strict adherence to the open MCP standard so models can discover and invoke your tools. While the MCP side is standard, implementing it against Guru's highly specific backend architecture introduces severe friction.

If you build this layer yourself, you own the entire API lifecycle. Here are the specific integration challenges that make wrapping the Guru API in a custom MCP server uniquely painful:

Async Processing and Server-Sent Events (SSE)

Guru's modern AI features do not behave like standard REST endpoints. When you invoke operations like create_a_guru_chat_ask_async, the API does not return a final answer. Instead, it returns an HTTP 202 Accepted status with a pending state. Your MCP server must implement polling logic to continuously check get_single_guru_chat_ask_async_by_id until the status changes to COMPLETE or ERRORED.

Worse, endpoints like create_a_guru_answers_stream return Server-Sent Events (text/event-stream). ChatGPT's native tool-calling expects a synchronous JSON response. If you build your own MCP server, you must write a buffer layer that consumes the SSE stream, waits for completion, concatenates the chunks, and formats it back into a valid JSON-RPC response payload before timing out the LLM's context window.

Token Scopes and Read vs. Write Constraints

Guru relies heavily on token types. A read-only Collection token cannot be used to write data. If your LLM attempts to call create_a_guru_chat_ask using a Collection token, the request will immediately fail with a 403 Forbidden. Your custom MCP server must implement a routing layer that validates the token scope against the intended operation before passing the request to Guru, otherwise you risk confusing the LLM with opaque permission errors.

The Extended Payload Dilemma

When an LLM asks, "Who are the verifiers for this card?" a standard GET request to the base cards endpoint might omit relational data to save bandwidth. To get the full picture, you have to use specific extended endpoints like get_single_guru_card_extended_by_id, which aggressively joins the card data with its boards and collaborators. If you expose the basic endpoint to the LLM instead of the extended one, the LLM will hallucinate answers because the relationships are missing from its context window.

How to Generate and Connect the Guru MCP Server

Instead of writing and hosting a custom Node.js or Python server to handle Guru's API quirks, you can use Truto to dynamically generate an MCP server. Truto derives the tool schemas directly from Guru's OpenAPI definitions, ensuring the LLM always has the correct payload structure.

Here is how to create the server and connect it to ChatGPT.

Step 1: Create the MCP Server for Guru

You can generate the MCP server in two ways: via the Truto UI or programmatically via the API.

Option A: Via the Truto UI

1. In the Truto dashboard, navigate to the Integrated Accounts page and select your connected Guru account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., restrict to read methods only, or filter by specific tags like cards and knowledge_agents).
5. Copy the generated MCP server URL. (It will look like https://api.truto.one/mcp/<secure-token>).

Option B: Via the Truto API If you are provisioning AI workspaces dynamically for your customers, you can generate the MCP server via a single POST request:

curl -X POST https://api.truto.one/integrated-account/<GURU_INTEGRATED_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ChatGPT Guru Assistant",
    "config": {
      "methods": ["read", "write"],
      "tags": ["cards", "knowledgeagents", "comments"]
    },
    "expires_at": null
  }'

The API returns a JSON object containing the secure url. This URL handles all protocol handshakes, routing, and authentication.

Step 2: Connect the MCP Server to ChatGPT

Now that you have the secure URL, you can connect it to your LLM.

Option A: Via the ChatGPT UI (For Enterprise/Pro users)

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Ensure Developer mode is toggled on (required for MCP custom connectors).
3. Click Add custom connector.
4. Enter a name (e.g., "Guru Knowledge Base") and paste the Truto MCP URL.
5. Click Add. ChatGPT will perform the JSON-RPC initialization handshake and immediately discover all permitted Guru tools.

Option B: Via Manual Config File (For Claude Desktop, Cursor, or CLI Agents) If you are using a local agent or IDE that supports MCP configuration files, you can define the server using the standard SSE transport command:

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

Hero Tools for Guru

Truto automatically generates hundreds of tools from the Guru API, but exposing all of them to an LLM simultaneously can overwhelm its context window. Here are the highest-leverage "hero tools" to expose for knowledge management workflows.

create_a_guru_search_cardmgr

This is the most powerful retrieval tool in the Guru integration. It allows the LLM to search Guru cards using a structured JSON query (the Card Manager query language). It supports filtering by verification state, owner, tags, and specific folders, returning up to 50 detailed cards per page.

"Search Guru for all cards tagged 'engineering-onboarding' that are currently in an 'unverified' state."

get_single_guru_card_extended_by_id

Standard card lookups miss crucial context. This extended tool loads a single Guru card alongside its teams, boards, and collaborators. This is essential when the LLM needs to know not just what the documentation says, but who is responsible for maintaining it.

"Pull the extended details for card ID 12345, specifically looking for who the assigned verifiers are."

guru_card_extendeds_bulk_update

This tool allows the LLM to update a card's content, modify its share status, change its tags, and update its verification state in a single call. It is the primary tool for automated documentation hygiene.

"Update the 'Q3 Deploy Process' card with the new staging environment URLs I just provided, and mark the card as verified."

create_a_guru_chat_ask

Instead of making the LLM read raw cards, this tool routes a question directly to Guru's native AI assistant. The LLM can ask a question, and Guru will return an answer synthesized from your team's trusted knowledge base. Note that this endpoint requires a User-level token.

"Ask Guru what the current corporate policy is on expensing home office equipment, and give me the exact text it returns."

list_all_guru_knowledgeagents

Guru supports specialized "Knowledge Agents" (custom assistants configured for specific domains). This tool lists all available agents, allowing the LLM to discover which specialized bot it should route complex queries to.

"List all active knowledge agents in our Guru workspace and tell me if there is one dedicated to HR or IT Support."

create_a_guru_card_comment

When an AI agent detects outdated information but lacks the authority to change it directly, it can use this tool to drop a comment on the card, tagging the human owner to review the content.

"Leave a comment on the 'API Rate Limits' card stating that the limits were updated yesterday and requesting the author to revise the page."

View the complete tool inventory and schema definitions on the Guru integration page.

Workflows in Action

Once the MCP server is connected, ChatGPT can orchestrate complex, multi-step workflows across Guru automatically. Here are two real-world examples of how AI agents leverage these tools.

Workflow 1: Automated Knowledge Gap Remediation

Documentation degrades over time. You can instruct ChatGPT to act as a "Knowledge Manager" that audits documentation and prompts human experts to fix gaps.

"Find all unverified cards in the 'Engineering' folder. For any card that hasn't been verified in over 6 months, read its content. If the content references the old 'v1 API', leave a comment on the card asking the owner to update it to v2."

How the agent executes this:

1. create_a_guru_search_cardmgr: The agent constructs a JSON query filtering by the Engineering folder ID, verificationState: UNVERIFIED, and a date filter for last verified.
2. get_single_guru_card_extended_by_id: For the resulting cards, the agent iterates through and reads the full content payload to check for mentions of "v1 API".
3. create_a_guru_card_comment: If the outdated reference is found, the agent extracts the card_id and submits a new comment payload alerting the human owner.

sequenceDiagram
    participant User as ChatGPT (AI Agent)
    participant Truto as Truto MCP Server
    participant Upstream as "Guru API"

    User->>Truto: Call create_a_guru_search_cardmgr (unverified)
    Truto->>Upstream: POST /api/v1/search/cardmgr
    Upstream-->>Truto: Returns matching card records
    Truto-->>User: JSON-RPC Result (Card IDs)

    loop For each outdated card
        User->>Truto: Call get_single_guru_card_extended_by_id
        Truto->>Upstream: GET /api/v1/cards/{id}/extended
        Upstream-->>Truto: Full card content
        Truto-->>User: JSON-RPC Result (Content)
        
        opt Contains 'v1 API'
            User->>Truto: Call create_a_guru_card_comment
            Truto->>Upstream: POST /api/v1/cards/{id}/comments
            Upstream-->>Truto: 200 OK
            Truto-->>User: JSON-RPC Result (Comment created)
        end
    end

Workflow 2: The Support Agent Handoff

When a support engineer is dealing with a complex customer issue, they can ask ChatGPT to consult Guru's internal experts and aggregate the response.

"Ask Guru how to reset the primary admin password on a legacy on-premise deployment. Then, find the specific documentation cards it used as sources and summarize the steps for me."

How the agent executes this:

1. create_a_guru_chat_ask: The agent submits the question payload to Guru's AI. Guru processes the natural language request against the trusted knowledge base and returns an answer object, which includes an answer_id.
2. list_all_guru_answer_boosteddocuments: The agent takes the answer_id and queries Guru to find the exact source documents that were used to generate the answer.
3. Synthesis: The LLM reads the final response and the metadata of the source documents, formatting a clean, cited summary for the support engineer.

Handling Rate Limits

When executing multi-step workflows like the ones above, your AI agent might fire dozens of requests in quick succession. Guru enforces rate limits to protect its infrastructure.

Factual note on rate limits: Truto does not automatically retry, throttle, or apply backoff logic when an upstream API returns an HTTP 429 (Too Many Requests) error. If Guru rate-limits the connection, Truto passes that 429 error directly back to the caller. However, Truto actively normalizes the upstream Guru rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller (your AI agent, LangChain framework, or custom application) is fully responsible for reading these headers and implementing its own retry and backoff mechanisms.

Security and Access Control

Exposing an entire enterprise knowledge base to an AI model requires strict governance. Truto's MCP servers provide granular controls to ensure LLMs only touch what they are supposed to:

• Method Filtering: During server creation, you can set config.methods = ["read"]. This hard-codes the MCP server to only expose get and list operations. The LLM simply won't know that delete or update tools exist.
• Tag Filtering: You can restrict the server to specific operational domains using config.tags = ["cards", "comments"]. This scopes the available tools down, keeping the LLM's context window clean and focused.
• Require API Token Auth: By default, the cryptographically hashed URL acts as the authentication vector. For zero-trust environments, you can enable require_api_token_auth: true, forcing the connecting client to also pass a valid Truto API token in the Authorization header.
• Time-to-Live (Expires At): If you are spinning up a temporary agent for a specific audit, you can set an expires_at timestamp. Truto's edge network automatically revokes the token and triggers a cleanup alarm when the time expires.

Strategic Wrap-up

Building AI agents that can reliably interact with Guru requires more than just knowing the API endpoints. You have to handle streaming responses, complex payload structures, and strict authentication rules.

By leveraging Truto's dynamically generated MCP servers, you eliminate the need to write and maintain custom API proxy code. Your agents get immediate, schema-accurate access to Guru's entire feature set, secured by robust filtering and access controls.