---
title: "Connect Guru to Claude: Automate Answers, Folders, and Team Analytics"
slug: connect-guru-to-claude-automate-answers-folders-and-team-analytics
date: 2026-10-07
author: Roopendra Talekar
categories: ["AI & Agents"]
excerpt: "Learn how to connect Guru to claude using Truto. Step-by-step guide to tool calling, API quirks, and autonomous workflows."
canonical: https://truto.one/blog/connect-guru-to-claude-automate-answers-folders-and-team-analytics/
---

# Connect Guru to Claude: Automate Answers, Folders, and Team Analytics

**Guru in Claude, in about a minute.** The best way to connect Guru to Claude is Elaichi: connect Guru to Elaichi once, then add Elaichi to Claude as a connector. Two steps, about a minute, with a 14-day free trial and no credit card required.

1. **Start your free trial.** Create your Elaichi account. 14 days free, no credit card required.
2. **Connect Guru.** Connect Guru once in Elaichi. Claude never gets more access than you have.
3. **Add Elaichi to Claude.** In Claude, open Customize, then Connectors, press Add and paste https://api.elaichi.ai/mcp. Sign in and approve.

[Start free on Elaichi, 14 days, no credit card required](https://app.elaichi.ai/signup?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=guru) · [Guru on Elaichi](https://elaichi.ai/connectors/guru/?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=guru)

*Building Guru into your own product? The guide below is for you.*

---

If your team needs to connect Guru to Claude to automate knowledge retrieval, verify aging documentation, or analyze team usage patterns, you need a [Model Context Protocol (MCP)](https://truto.one/what-is-model-context-protocol-mcp/) server. This server acts as the translation layer between Claude's tool calls and Guru's REST APIs. You can either build and maintain this infrastructure yourself, or use a [managed integration platform](https://truto.one/what-is-an-embedded-ipass/) like Truto to dynamically generate a secure, authenticated MCP server URL. 

If your team uses ChatGPT, check out our guide on [/connect-guru-to-chatgpt-manage-cards-knowledge-agents-and-answers/](https://truto.one/connect-guru-to-chatgpt-manage-cards-knowledge-agents-and-answers/) or explore our broader architectural overview on [/connect-guru-to-ai-agents-verify-cards-audit-quality-and-sync-data/](https://truto.one/connect-guru-to-ai-agents-verify-cards-audit-quality-and-sync-data/).

Giving a Large Language Model (LLM) read and write access to a complex knowledge management system like Guru is a significant engineering challenge. You must handle token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Guru's domain-specific data constraints. Every time Guru updates an endpoint or changes its Card schema, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Guru, connect it natively to [Claude Desktop](https://truto.one/how-to-setup-mcp-on-claude-desktop/), and execute complex knowledge workflows using natural language.

> Want to give your [AI agents](https://truto.one/connect-guru-to-ai-agents-verify-cards-audit-quality-and-sync-data/) secure, authenticated access to Guru and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Guru API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against specialized B2B APIs is painful. Guru is built to manage trusted company knowledge, AI chat threads, and team analytics. Its API reflects that complexity.

If you decide to build a custom Guru MCP server, here are the specific integration challenges you will face:

**Complex Card Payloads and Verification States**
Guru does not treat cards as simple text documents. A card contains `verificationState`, `boards`, `tags`, and `collaborators`. If you want to update a card's content, a naive LLM might fetch the card, modify the text, and PUT the payload back. If the LLM strips out the `tags` or `verifiers` in its request, it permanently destroys that metadata. You must explicitly build tools that handle partial updates or enforce schema strictness so Claude understands how to manage the `extended` fact data without causing collateral damage.

**Asynchronous AI Chat and SSE Streams**
Guru's API offers endpoints for interacting with its own internal AI (Knowledge Agents). However, endpoints like `create_a_guru_answers_stream` return Server-Sent Event (SSE) streams rather than standard JSON objects. LLM function calling expects a synchronous JSON response. To expose this to Claude, you must either build an abstraction layer that consumes the stream and returns the final compiled string, or steer the model toward the asynchronous endpoints (`create_a_guru_chat_ask_async`), which require complex polling logic to check if a pending job has transitioned from `PENDING` to `COMPLETE`.

**Pagination via Link Headers**
Guru handles pagination through HTTP `Link` headers containing token parameters, rather than simple offset/limit query parameters in the payload. Your MCP server must intercept these headers, parse the next-page URL, and inject the `token` back into the tool response so Claude knows how to request the next batch of data. Truto handles this normalization automatically, injecting standard pagination fields directly into the tool schemas.

**Rate Limit Transparency**
API quotas are a reality for any high-volume integration. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Guru API returns an HTTP 429, Truto passes that error directly back to the caller (the LLM client). Truto normalizes the upstream rate limit information into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). The caller is responsible for implementing any necessary retry or backoff logic based on these headers.

## Deploying the Guru MCP Server

Truto dynamically generates MCP tools based on the existing `config.resources` and `documentation` schemas for the Guru integration. This documentation-driven tool generation means you only expose well-defined, curated endpoints to Claude. 

You can spin up a Guru MCP server using either the Truto UI or the Truto API.

### Method 1: Via the Truto UI

For teams who prefer a visual setup, generating an MCP server takes just a few clicks:

1. Log into your Truto dashboard and navigate to the **Integrated Accounts** page.
2. Select your active Guru connection.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Configure your server (set a name, select allowed HTTP methods, choose specific tags, or set an expiration date).
6. Click **Save** and copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

### Method 2: Via the Truto API

For platform engineers building automated environments, you can generate MCP servers programmatically. This is ideal for provisioning ephemeral MCP servers during CI/CD or assigning isolated servers to specific tenants.

Make a `POST` request to the `/integrated-account/:id/mcp` endpoint with your desired configuration:

```bash
curl -X POST https://api.truto.one/integrated-account/<guru_account_id>/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Guru Ops Agent",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["knowledge", "analytics"]
    },
    "expires_at": null
  }'
```

The API returns a secure, hashed token URL. This URL encapsulates the authentication state for this specific Guru tenant:

```json
{
  "id": "abc-123",
  "name": "Guru Ops Agent",
  "config": { "methods": ["read", "write", "custom"], "tags": ["knowledge", "analytics"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

## Connecting Claude to Guru

Once you have your Truto MCP URL, you need to connect it to your AI framework. You can do this through standard chat interfaces or via configuration files for local agents.

### Method A: Via the Claude UI

If you are using an enterprise AI chat interface that supports custom remote MCP connections (such as Claude for Enterprise or ChatGPT Developer Mode):

1. In your AI interface, navigate to **Settings** -> **Integrations** -> **Add MCP Server** (or **Settings** -> **Connectors** -> **Add custom connector**).
2. Provide a recognizable name (e.g., "Guru Knowledge Base").
3. Paste the Truto MCP URL generated in the previous step.
4. Click **Add** or **Save**.

The LLM will instantly call the `tools/list` JSON-RPC method, discover the available Guru tools, and make them available in the chat window.

### Method B: Via the Claude Desktop Config File

If you are running Claude Desktop locally and want to connect it to Truto's remote HTTP MCP endpoint, you can use the `@modelcontextprotocol/server-sse` bridge. This translates Claude's native `stdio` requirements into the remote network calls Truto expects.

Edit your `claude_desktop_config.json` file (typically located at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS or `%APPDATA%\Claude\claude_desktop_config.json` on Windows):

```json
{
  "mcpServers": {
    "guru_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}
```

Restart Claude Desktop. The "plug" icon will appear, indicating that Claude has successfully ingested the Guru tool schemas.

## Hero Tools for Guru Workflows

Truto automatically generates highly descriptive `snake_case` tools based on the Guru integration schema. Here are 6 high-leverage tools available for Claude to automate knowledge management.

### `create_a_guru_search_cardmgr`

This tool allows Claude to execute complex, structured JSON queries against Guru cards using the Card Manager query language. It is far more powerful than a basic keyword search, allowing the LLM to filter by owner, tag, folder IDs, verification state, and dates.

> "Search Guru for all cards tagged 'architecture' that are currently in an 'UNVERIFIED' state, and return the first 10 results."

### `get_single_guru_card_extended_by_id`

Standard card lookups return minimal data. This tool fetches a single Guru card with extended details, including the card's assigned boards, tags, verification state, and collaborators. This is essential context before Claude attempts to update or verify a card.

> "Fetch the extended details for the Guru card with ID 4f9b2a-11c... I need to see who the current verifiers are."

### `guru_card_extendeds_bulk_update`

This is the primary tool for mutating knowledge. It allows Claude to update a card's HTML/Markdown content, tags, share status, and verifiers in a single API call. Truto maps the query parameters and JSON schema properties so Claude knows exactly what fields are required.

> "Update the content of the 'Onboarding Checklist' card. Add a new section about 1Password provisioning at the bottom, but ensure the existing tags and verifiers remain unchanged."

### `guru_cards_bulk_update`

Despite the "bulk" in the upstream Guru API name, this endpoint is specifically used to verify a card by its ID. Verification is the lifeblood of a healthy Guru workspace. This tool allows Claude to step in as an automated knowledge manager.

> "Mark card ID 8a7b6c... as verified. The information regarding our SOC 2 compliance is still accurate."

### `create_a_guru_chat_ask_async`

Instead of searching for raw cards, Claude can route a question directly to Guru's internal Knowledge Agents asynchronously. This triggers Guru's internal RAG pipeline. The tool returns a job ID that can be polled until the status changes to `COMPLETE`.

> "Ask the Guru AI agent 'What is our standard SLA for enterprise customers?' Use the async ask tool and let me know the result."

### `list_all_guru_team_analytics`

This tool retrieves analytics events for a Guru team, including view counts and interactions over specific date ranges. Claude can use this data to identify which documentation is highly utilized and which is gathering dust.

> "Pull the team analytics for the last 30 days. Identify which 5 cards have the highest engagement."

To see the complete list of available resources, endpoints, and data schemas, check out the [Guru Integration Page](https://truto.one/integrations/detail/guru).

## Workflows in Action

By chaining these tools together, Claude transforms from a basic chat interface into a fully autonomous knowledge management system.

### Scenario 1: Automated Knowledge Verification

**Persona**: Knowledge Manager / Technical Writer

As documentation scales, keeping it verified becomes a massive operational burden. You can instruct Claude to act as a triage agent for aging documentation.

> "Find all Guru cards owned by the 'Engineering' team that are currently unverified. Fetch the extended details for each. If the card content hasn't fundamentally changed based on our recent architectural updates, verify the cards. If they need updates, draft a comment on the card tagging the owner."

**Execution Steps:**
1. Claude calls `create_a_guru_search_cardmgr` using a JSON payload filtering for `verificationState: UNVERIFIED` and `owner: Engineering`.
2. For the returned results, Claude calls `get_single_guru_card_extended_by_id` to read the specific markdown content.
3. Claude evaluates the content. If accurate, it calls `guru_cards_bulk_update` to mark the card as verified.
4. If inaccurate, Claude calls `create_a_guru_card_comment` to alert the original author that the documentation is stale.

### Scenario 2: Documentation Gap Analysis

**Persona**: Support Operations Manager

Support teams need to know if the answers they are looking for actually exist in the knowledge base, or if they are repeatedly asking questions that yield no results.

> "Ask the Guru Knowledge Agent how to configure SSO for a new enterprise tenant. If the answer comes back empty or lacks specific XML formatting instructions, search for the 'SSO Configuration' card, update it with the following XML template, and add a comment that it was updated by AI."

**Execution Steps:**
1. Claude calls `create_a_guru_chat_ask_async` with the query "How to configure SSO for a new enterprise tenant".
2. Claude polls `get_single_guru_chat_ask_async_by_id` until the status is `COMPLETE`.
3. Upon seeing a poor or empty response from Guru's internal AI, Claude uses `create_a_guru_search_cardmgr` to locate the source documentation.
4. Claude calls `guru_card_extendeds_bulk_update` to inject the missing XML template into the card's body.
5. Finally, Claude calls `create_a_guru_card_comment` on that card to leave an audit trail of the modification.

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP
    participant Guru as Guru API

    User->>Claude: "Ask Guru about SSO. Update docs if missing."
    Claude->>Truto: Call create_a_guru_chat_ask_async
    Truto->>Guru: POST /chat/ask-async
    Guru-->>Truto: job_id: 1234, status: PENDING
    Truto-->>Claude: Pending status
    Claude->>Truto: Call get_single_guru_chat_ask_async_by_id
    Truto->>Guru: GET /chat/ask-async/1234
    Guru-->>Truto: status: COMPLETE, response: "No SSO data found"
    Truto-->>Claude: Incomplete answer context
    Claude->>Truto: Call guru_card_extendeds_bulk_update
    Truto->>Guru: PUT /cards/extended/{id}
    Guru-->>Truto: Updated card payload
    Truto-->>Claude: Update successful
    Claude-->>User: "SSO documentation has been successfully updated."
```

## Security and Access Control

Exposing an enterprise knowledge base to an LLM requires strict security boundaries. Truto MCP servers are self-contained and scoped exclusively to a single integrated account. You can enforce granular controls at the server level:

*   **Method Filtering (`methods`)**: Restrict the MCP server to only allow `read` operations. This ensures Claude can query and search cards, but cannot accidentally delete folders or mutate card content.
*   **Tag Filtering (`tags`)**: Group integration resources by tag (e.g., `"knowledge"`, `"analytics"`). If you only want Claude to access the analytics endpoints, you can filter out the core documentation tools entirely.
*   **Expiration (`expires_at`)**: Set an ISO datetime for the server to auto-destruct. This is perfect for giving temporary agents access to perform a one-off knowledge audit.
*   **Double Authentication (`require_api_token_auth`)**: By default, the cryptographically hashed MCP URL is the only authentication needed. Enabling this flag requires the MCP client to also pass a valid Truto API token in the authorization header, protecting against accidental URL exposure.

## The Advantage of Managed MCP Infrastructure

Building a custom integration layer between Claude and Guru forces your engineering team to take on the maintenance burden of API versioning, complex pagination handling, rate limit normalization, and schema mapping. 

By utilizing Truto's dynamic, documentation-driven MCP servers, you eliminate the integration code entirely. You get a fully authenticated, LLM-ready server URL in seconds. Truto handles the protocol translation (JSON-RPC to REST), schema enforcement, and security scoping, allowing your team to focus on building high-value AI workflows rather than debugging third-party API quirks.