MCP Overview - Thrindex docs

What is MCP?

The Model Context Protocol (MCP) is an open standard that lets AI clients — editors, assistants, and agent frameworks — talk to external tools and services over a uniform JSON-RPC 2.0 interface. Thrindex implements MCP’s Streamable HTTP transport, which means any MCP-compatible client can connect to a single HTTPS endpoint. No local processes, no npm packages, no binary to install.

Endpoint

POST https://api.thrindex.com/mcp

All JSON-RPC 2.0 messages — initialize, tools/list, and tools/call — are sent to this single endpoint. The server is stateless; each request is independently authenticated.

Authentication

Use any API key with the following scopes:

Scope	Required for
`memory:write`	`store_memory` tool
`memory:read`	`search_memories`, `list_memories`, `get_memory` tools
`memory:delete`	`delete_memory` tool

Pass the key as a Bearer token in every request:

Authorization: Bearer th_live_...

Create and manage API keys in the dashboard. Selecting all three scopes when creating a key for an MCP client is recommended.

org_id is derived from your API key. It is never sent in the request body. Memory isolation is enforced at the API level — one key can never read another organization’s data.

Client setup

Add the following to claude_desktop_config.json.macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "thrindex": {
      "type": "http",
      "url": "https://api.thrindex.com/mcp",
      "headers": {
        "Authorization": "Bearer th_live_..."
      }
    }
  }
}

Open Settings → Developer → Edit Config inside Claude Desktop to locate the file. Save and restart Claude Desktop after editing.

Run the following command once in your terminal:

claude mcp add thrindex \
  --transport http \
  https://api.thrindex.com/mcp \
  --header "Authorization: Bearer th_live_..."

Verify the server registered correctly:

claude mcp list

Thrindex memory tools are available in every Claude Code session after this.

Open or create ~/.cursor/mcp.json:

{
  "mcpServers": {
    "thrindex": {
      "url": "https://api.thrindex.com/mcp",
      "headers": {
        "Authorization": "Bearer th_live_..."
      }
    }
  }
}

Restart Cursor. The Thrindex tools appear in the agent tool list automatically.

Create .vscode/mcp.json in your project root:

{
  "servers": {
    "thrindex": {
      "type": "http",
      "url": "https://api.thrindex.com/mcp",
      "headers": {
        "Authorization": "Bearer th_live_..."
      }
    }
  }
}

Open Copilot Chat, switch to Agent mode, and Thrindex tools appear automatically. This configuration is workspace-scoped; add it to .gitignore if you don’t want to commit your API key.

Requires VS Code 1.99+ and the GitHub Copilot extension in Agent mode.

Install the SDK:

pip install openai-agents

Instantiate MCPServerStreamableHttp and pass it to your agent:

from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

thrindex = MCPServerStreamableHttp(
    name="thrindex",
    url="https://api.thrindex.com/mcp",
    headers={"Authorization": "Bearer th_live_..."},
)

agent = Agent(
    name="my-agent",
    instructions="Use Thrindex to store and recall memories for each user.",
    mcp_servers=[thrindex],
)

async with Runner() as runner:
    result = await runner.run(agent, "What do you know about me?")

All five memory tools are available to the agent on every run. No custom tool definitions required.

Open or create ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "thrindex": {
      "serverUrl": "https://api.thrindex.com/mcp",
      "headers": {
        "Authorization": "Bearer th_live_..."
      }
    }
  }
}

In Windsurf, open Cascade → hammer icon → Refresh to load the new server.

Open VS Code → Cline sidebar → MCP Servers → Configure MCP Servers to open cline_mcp_settings.json. Add the following inside the "mcpServers" object:

{
  "mcpServers": {
    "thrindex": {
      "type": "streamableHttp",
      "url": "https://api.thrindex.com/mcp",
      "headers": {
        "Authorization": "Bearer th_live_..."
      },
      "disabled": false
    }
  }
}

Save the file. Cline connects automatically.

Open or create ~/.continue/config.yaml and add an mcpServers block:

mcpServers:
  - name: thrindex
    type: streamable-http
    url: https://api.thrindex.com/mcp
    headers:
      Authorization: "Bearer th_live_..."

Reload VS Code and switch Continue to Agent mode to activate MCP tools.

Install the n8n-nodes-mcp community package in your n8n instance, then set the environment variable:

N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true

Restart n8n, then add an MCP Client node to an AI Agent workflow and configure it as follows:

Connection Type : HTTP Streamable
URL             : https://api.thrindex.com/mcp
Additional Headers:
  Authorization : Bearer th_live_...

All five Thrindex memory tools are available as AI Agent tools.

Available tools

Once connected, your AI client has access to five tools:

Tool	Scope	Description
`store_memory`	`memory:write`	Persist a fact, preference, or piece of context
`search_memories`	`memory:read`	Semantic search over stored memories
`list_memories`	`memory:read`	Browse memories in reverse-chronological order
`get_memory`	`memory:read`	Retrieve the full content of a single memory by ID
`delete_memory`	`memory:delete`	Soft-delete a memory by ID

See the Tool Reference for the full parameter documentation and example tool calls for each.

How memory is scoped

Every memory stored through MCP is scoped to three levels:

Scope	Source
Organization	From your API key — automatic, never sent in the request
`agent_id`	Passed as a tool argument (defaults to `"mcp-client"`)
`user_id`	Passed as a tool argument (defaults to `"default"`)

Use consistent, stable identifiers so memories accumulate correctly across sessions. For example, pass agent_id="claude-desktop" and user_id="alice" to isolate Alice’s memories from other users’ memories.

Any MCP-compatible client

The endpoint follows the MCP 2025-03-26 Streamable HTTP specification exactly. Any client that implements this spec can connect using:

Transport: Streamable HTTP (single POST endpoint)
Auth: Authorization: Bearer <api_key> header
Protocol: JSON-RPC 2.0

If your client is not listed above, use the configuration format it expects for a remote HTTP MCP server and point it at https://api.thrindex.com/mcp.

​What is MCP?

​Endpoint

​Authentication

​Client setup

​Available tools

​How memory is scoped

​Any MCP-compatible client

What is MCP?

Endpoint

Authentication

Client setup

Available tools

How memory is scoped

Any MCP-compatible client