brain-mcp-setup

INITE Brain ships a Streamable HTTP MCP endpoint at /mcp. The API key names its tenant; /mcp/<companyId> is the same endpoint pinned to one tenant. This skill walks the user from zero to "tools visible in Claude".

What the user needs

1. A brain API key for their company (format brain_<base64>).
2. The MCP URL: https://brain.inite.ai/mcp (or https://brain.inite.ai/mcp/<companyId>, which brain refuses when the companyId is not the key's — useful when one config serves several tenants).
3. One of: Claude Desktop, Cursor, Goose v2, Aider, Continue.dev, n8n, or a raw @modelcontextprotocol/sdk client.

If they don't have a key yet, point them to https://brain.inite.ai/en/app/keys and pause. Brain refuses unsigned MCP calls — there's no anonymous mode.

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "brain": {
      "url": "https://brain.inite.ai/mcp",
      "transport": "http",
      "headers": {
        "Authorization": "Bearer <api-key>"
      }
    }
  }
}

Restart Claude Desktop. The brain server should appear in the MCP panel — which tools depends on the key's scopes (see the scope matrix below).

Cursor

Edit .cursor/mcp.json in the user's workspace (or ~/.cursor/mcp.json for global):

{
  "mcpServers": {
    "brain": {
      "url": "https://brain.inite.ai/mcp",
      "transport": "http",
      "headers": {
        "Authorization": "Bearer <api-key>"
      }
    }
  }
}

Reload the workspace. Brain tools become available under @brain in the AI panel.

Goose v2

Edit ~/.config/goose/config.yaml:

extensions:
  brain:
    type: streamable_http
    uri: https://brain.inite.ai/mcp
    headers:
      Authorization: Bearer <api-key>
    enabled: true
    bundled: false

goose session start will load brain tools. Goose v2 (released Q1 2026) ships with first-class Streamable HTTP support; if you're on a 1.x Goose, the type field is stdio only and you'll need a stdio shim — upgrade is the cleaner path.

Aider

Aider gained MCP support in 0.95. Pass the brain URL on the command line:

aider --mcp brain.inite.ai/mcp \
      --mcp-header "Authorization: Bearer <api-key>"

Or in ~/.aider.conf.yml:

mcp-servers:
  brain:
    url: https://brain.inite.ai/mcp
    headers:
      Authorization: Bearer <api-key>

Continue.dev

Edit ~/.continue/config.yaml:

mcpServers:
  - name: brain
    type: streamable-http
    url: https://brain.inite.ai/mcp
    requestOptions:
      headers:
        Authorization: Bearer <api-key>

Reload the editor. Tools appear in the @ mention list.

n8n

Use the MCP Client node in n8n:

• URL: https://brain.inite.ai/mcp
• Transport: HTTP (Streamable)
• Header: Authorization: Bearer <api-key>

Pin a credential so it's reusable across workflows.

Raw @modelcontextprotocol/sdk (custom clients)

For a Node / TS client that talks Streamable HTTP directly:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://brain.inite.ai/mcp"),
  {
    requestInit: {
      headers: { Authorization: "Bearer <api-key>" },
    },
  }
);

const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

const tools = await client.listTools();
const out = await client.callTool({
  name: "search_knowledge",
  arguments: { query: "hello", limit: 1 },
});

The brain server is request-scoped: one McpServer per call, no long-lived session state. Streamable HTTP keeps the client → server connection alive but every tool call is independent.

Smoke test (any client)

Once the client is connected, ask it:

List available brain tools and call search_knowledge with query "hello" limit 1.

Expected: a tool list that depends on the key's scopes (see matrix below) and a search_knowledge answer of No facts in memory match this question. on a fresh tenant (a few lines of facts if there's seed data). If the tool call returns a 401 or 403, the API key scope is wrong — check the key's scopes on the keys page of the brain app.

Scope matrix

A key with only brain:read sees only the read tools — that's the security invariant, not a bug. tools/list is the authoritative list for a connection. The connection URL can also pick a tool profile: ?tools=core lists a handful of everyday tools plus find_tool / run_tool to reach the rest, and ?tools=chatgpt lists exactly search and fetch for ChatGPT connectors. Tell the user explicitly when their key is read-only so they don't waste time looking for record_fact / forget_entity. On top of the built-ins, installed Domain Packs with a consented mcpTools section contribute namespaced tools (<packId>__<tool>) behind MCP_PACK_TOOLS_ENABLED.

The detailed taxonomy (which tool for which question) lives in the workflow skills — brain-search, brain-recall, brain-bitemporal, brain-write, brain-conflict.

Harness mode: brain's model work is yours

A server running in harness mode (EXTRACTION_SOURCE=harness) calls no model of its own. It lists take_memory_work and submit_memory_work, and its background reading waits for the connected agent: extraction, fact resolution, entity matching, scene summaries, belief sentences. Until someone drains it, conversations are remembered but not understood. Drain it between tasks:

1. take_memory_work({ userId }), with the same userId your other calls use, returns one batch: a systemPrompt, userContent, the JSON schema of the reply, and a signed token.
2. Answer it as the prompt asks, in that schema.
3. submit_memory_work({ token, result }). The server grounds, validates and applies the reply with its own code.
4. Repeat until take_memory_work returns { work: null }.

The Claude Code plugin's start-of-session hook says so when it finds a server in this mode.

Common failures

After setup

Once connected, point the user at the workflow skills:

• brain-search — finding facts and entities
• brain-recall — pulling one entity's full picture (profile + timeline + summarize + competing + related)
• brain-bitemporal — temporal questions, including the memory_diff "what changed" surface
• brain-write — recording, linking, and retracting (with detect_contradiction preflight)
• brain-conflict — adjudicating COMPETING facts and 3+ multi-way disagreements

These describe how to actually use the tools brain exposes, not just how to wire them in.