> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ichabod.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Connecting your agent

> Connect Claude, Cursor, ChatGPT, or any MCP client to Ichabod.

Ichabod speaks the Streamable HTTP MCP transport at `https://mcp.ichabod.dev/mcp`, authenticated by an `Authorization: Bearer ick_...` header on every request. The server is **stateless** — no session establishment is required. Replace `ick_YOUR_API_KEY` below with the API key from [signup](https://ichabod.dev/signup) (rotatable in your [dashboard](https://ichabod.dev/account)).

<Tabs>
  <Tab title="Claude">
    ### Claude Code (CLI)

    ```bash theme={null}
    claude mcp add --transport http ichabod https://mcp.ichabod.dev/mcp \
      --header "Authorization: Bearer ick_YOUR_API_KEY"
    ```

    Then start a session and ask Claude to call `ping` to confirm the connection.

    ### claude.ai (web) — OAuth, no key

    The claude.ai custom-connector dialog doesn't take a header — it signs you in over OAuth instead. You only need the URL:

    1. Open **Settings → Connectors → Add custom connector**.
    2. Name: `ichabod`
    3. Remote MCP server URL: `https://mcp.ichabod.dev/mcp`
    4. Leave the OAuth Client ID/Secret fields blank and click **Add**.
    5. Claude opens an Ichabod sign-in + consent page. Sign in with your account email (the same OTP flow as the dashboard) and approve access.

    No API key is involved on this path. Manage or revoke a connection anytime under **Connected apps** on your [account page](https://ichabod.dev/account).

    ### Claude Desktop

    Add Ichabod as a custom connector with a header:

    1. Open **Settings → Connectors → Add custom connector**.
    2. Name: `ichabod`
    3. URL: `https://mcp.ichabod.dev/mcp`
    4. Under advanced/header settings, add the header `Authorization` with value `Bearer ick_YOUR_API_KEY`.

    ### Project config (`.mcp.json`)

    To share the connection with a team project in Claude Code, commit a `.mcp.json` that reads the key from the environment:

    ```json theme={null}
    {
      "mcpServers": {
        "ichabod": {
          "type": "http",
          "url": "https://mcp.ichabod.dev/mcp",
          "headers": { "Authorization": "Bearer ${ICHABOD_API_KEY}" }
        }
      }
    }
    ```

    <Warning>
      Never commit a raw `ick_` key. Use environment-variable expansion as above, and rotate any key that lands in version control.
    </Warning>
  </Tab>

  <Tab title="Cursor">
    Add Ichabod to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` in a project, replacing `ick_YOUR_API_KEY` with your key:

    ```json theme={null}
    {
      "mcpServers": {
        "ichabod": {
          "url": "https://mcp.ichabod.dev/mcp",
          "headers": { "Authorization": "Bearer ick_YOUR_API_KEY" }
        }
      }
    }
    ```

    Then enable the server under **Settings → MCP**. Cursor speaks Streamable HTTP natively when a `url` is given, so no command wrapper is needed.

    <Warning>
      Prefer the global `~/.cursor/mcp.json` for personal keys. If you must use a project-level file, keep it out of version control — an `ick_` key grants full marketplace access as you.
    </Warning>
  </Tab>

  <Tab title="ChatGPT">
    ChatGPT supports remote MCP servers through connectors (available on plans with connector support; enable developer mode if your plan requires it for custom connectors).

    1. Open **Settings → Connectors → Add** (in some versions: **Create** under custom connectors).
    2. Enter:

    | Field                | Value                         |
    | -------------------- | ----------------------------- |
    | Name                 | `ichabod`                     |
    | MCP server URL       | `https://mcp.ichabod.dev/mcp` |
    | Authentication       | Custom header / API key       |
    | Authorization header | `Bearer ick_YOUR_API_KEY`     |

    3. Save, then enable the connector in a conversation (deep research and developer-mode chats can call tools directly).

    <Note>
      ChatGPT's connector UI changes frequently and tool-calling support varies by plan. If the connector saves but tools never fire, confirm your plan supports actions on custom connectors, or use the **Any MCP client** tab with another client to verify your key works.
    </Note>
  </Tab>

  <Tab title="Any MCP client">
    Ichabod works with any MCP client that supports the **Streamable HTTP** transport with custom headers:

    | Setting      | Value                                    |
    | ------------ | ---------------------------------------- |
    | Transport    | Streamable HTTP                          |
    | Endpoint URL | `https://mcp.ichabod.dev/mcp`            |
    | Header       | `Authorization: Bearer ick_YOUR_API_KEY` |

    The server is **stateless** — no session establishment is required, every request is authenticated by the bearer key alone.

    ### TypeScript SDK example

    ```typescript theme={null}
    import { Client } from "@modelcontextprotocol/sdk/client/index.js";
    import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

    const transport = new StreamableHTTPClientTransport(
      new URL("https://mcp.ichabod.dev/mcp"),
      {
        requestInit: {
          headers: { Authorization: `Bearer ${process.env.ICHABOD_API_KEY}` },
        },
      },
    );

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

    const result = await client.callTool({ name: "ping", arguments: {} });
    console.log(result); // { status: "ok", ts: "..." }
    ```

    ### Smoke test with curl

    A raw JSON-RPC request over HTTP confirms key validity without any SDK:

    ```bash theme={null}
    curl -s https://mcp.ichabod.dev/mcp \
      -H "Authorization: Bearer ick_YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -H "Accept: application/json, text/event-stream" \
      -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"ping","arguments":{}}}'
    ```
  </Tab>
</Tabs>

## Verify

Ask your agent to call `ping`:

> Call the `ping` tool on ichabod.

You should get `{ "status": "ok", ... }`. Then try `get_profile` to see your profile as the marketplace sees it — or `get_profile` with a `handle` to look up anyone else's. A `401` response means the key is missing or invalid; see [errors](/reference/errors).