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

# Quickstart

> A key, a URL, and a model driving your workspace in about five minutes.

**Preview.** You will mint a key, point one client at the server, and watch a
model call a tool against your own workspace.

## 1. Mint a key with `mcp:connect`

In the dashboard, **Developers → API keys → Create key**. The key is a workspace
credential with the `tgcc_` prefix, and it is shown once.

<ParamField path="mcp:connect" type="scope" required>
  Reaching the transport at all. Without it, `POST /mcp` is **403**.
</ParamField>

<ParamField path="per-tool scopes" type="scope">
  Each tool demands its own scope on top — `agents:read` to list agents,
  `documents:create` to upload one, and so on.
</ParamField>

<Warning>
  **`mcp:connect` on its own authorises nothing.** A key holding only that scope
  connects and lists every tool — and calls none of them. That is deliberate: connecting is one decision, and what a model may then
  do with your workspace is another. Grant the per-tool scopes you actually
  intend, and no more.
</Warning>

## 2. Check the endpoint answers

The transport is JSON-RPC 2.0 over `POST` to one URL. `initialize` needs no
arguments worth writing down, and it is what every shipping MCP client sends
today:

<CodeGroup>
  ```bash curl theme={null}
  curl https://api.impellabs.tech/mcp \
    -H "Authorization: Bearer tgcc_xxxxxxxxxxxx" \
    -H "Content-Type: application/json" \
    -H "MCP-Protocol-Version: 2025-06-18" \
    -d '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "initialize",
      "params": {
        "protocolVersion": "2025-06-18",
        "capabilities": {},
        "clientInfo": {"name": "curl", "version": "1.0"}
      }
    }'
  ```

  ```python python theme={null}
  import httpx

  r = httpx.post(
      "https://api.impellabs.tech/mcp",
      headers={
          "Authorization": "Bearer tgcc_xxxxxxxxxxxx",
          "MCP-Protocol-Version": "2025-06-18",
      },
      json={
          "jsonrpc": "2.0",
          "id": 1,
          "method": "initialize",
          "params": {
              "protocolVersion": "2025-06-18",
              "capabilities": {},
              "clientInfo": {"name": "probe", "version": "1.0"},
          },
      },
  )
  print(r.json()["result"]["protocolVersion"])   # 2025-06-18
  ```

  ```typescript typescript theme={null}
  const r = await fetch("https://api.impellabs.tech/mcp", {
    method: "POST",
    headers: {
      "Authorization": "Bearer tgcc_xxxxxxxxxxxx",
      "Content-Type": "application/json",
      "MCP-Protocol-Version": "2025-06-18",
    },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: 1,
      method: "initialize",
      params: {
        protocolVersion: "2025-06-18",
        capabilities: {},
        clientInfo: { name: "probe", version: "1.0" },
      },
    }),
  });
  console.log((await r.json()).result.protocolVersion);   // 2025-06-18
  ```
</CodeGroup>

<Check>
  A `200` carrying `"protocolVersion": "2025-06-18"` means the credential is
  good and the server is reachable. A `401` means the key was not recognised; a
  `403` means it lacks `mcp:connect`. Both are covered in
  [Authentication](/connect/authentication).
</Check>

### If your client speaks `2026-07-28`

There is no handshake to run — that revision removed it. `server/discover`
answers the same question, and the request declares its own revision instead of
agreeing one:

<CodeGroup>
  ```bash curl theme={null}
  curl https://api.impellabs.tech/mcp \
    -H "Authorization: Bearer tgcc_xxxxxxxxxxxx" \
    -H "Content-Type: application/json" \
    -H "MCP-Protocol-Version: 2026-07-28" \
    -H "Mcp-Method: server/discover" \
    -d '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "server/discover",
      "params": {
        "_meta": {
          "io.modelcontextprotocol/protocolVersion": "2026-07-28",
          "io.modelcontextprotocol/clientCapabilities": {}
        }
      }
    }'
  ```

  ```python python theme={null}
  import httpx

  VERSION = "2026-07-28"

  r = httpx.post(
      "https://api.impellabs.tech/mcp",
      headers={
          "Authorization": "Bearer tgcc_xxxxxxxxxxxx",
          "MCP-Protocol-Version": VERSION,
          # Mirrored so a gateway can route without parsing the body. It is
          # checked against the body, and a mismatch is -32020.
          "Mcp-Method": "server/discover",
      },
      json={
          "jsonrpc": "2.0",
          "id": 1,
          "method": "server/discover",
          "params": {
              "_meta": {
                  "io.modelcontextprotocol/protocolVersion": VERSION,
                  "io.modelcontextprotocol/clientCapabilities": {},
              }
          },
      },
  )
  print(r.json()["result"]["supportedVersions"])   # every revision we answer on
  ```
</CodeGroup>

<Note>
  **You do not need this to connect.** The `2025-06-18` calls above are the
  default path and will stay one — the era is chosen by the
  `MCP-Protocol-Version` header alone, and an absent header still means
  `2025-03-26`. [Protocol revisions](/connect/protocol) covers what a modern
  client must send on *every* request, and the error codes it gets for leaving
  a piece out.
</Note>

## 3. See what the key may call

`tools/list` is the honest answer to "what exists" — it is filtered by nothing,
so a key holding only `mcp:connect` still sees the whole catalogue. The registry
is curated and still growing, so this call, not a table in these docs, is what is
current for your connection.

<CodeGroup>
  ```bash 2025-06-18 theme={null}
  curl https://api.impellabs.tech/mcp \
    -H "Authorization: Bearer tgcc_xxxxxxxxxxxx" \
    -H "Content-Type: application/json" \
    -H "MCP-Protocol-Version: 2025-06-18" \
    -d '{"jsonrpc": "2.0", "id": 2, "method": "tools/list"}'
  ```

  ```bash 2026-07-28 theme={null}
  curl https://api.impellabs.tech/mcp \
    -H "Authorization: Bearer tgcc_xxxxxxxxxxxx" \
    -H "Content-Type: application/json" \
    -H "MCP-Protocol-Version: 2026-07-28" \
    -H "Mcp-Method: tools/list" \
    -d '{
      "jsonrpc": "2.0",
      "id": 2,
      "method": "tools/list",
      "params": {
        "_meta": {
          "io.modelcontextprotocol/protocolVersion": "2026-07-28",
          "io.modelcontextprotocol/clientCapabilities": {}
        }
      }
    }'
  ```
</CodeGroup>

The modern result carries the same `tools` array plus `ttlMs` and `cacheScope`,
the freshness hints that revision requires — worth honouring, because this
server declares `listChanged: false` and can never tell you the catalogue moved.

## 4. Point a client at it

<CardGroup cols={2}>
  <Card title="Claude" icon="https://mintcdn.com/mahadev/-gWik8vU43pna0pu/images/harnesses/claude.svg?fit=max&auto=format&n=-gWik8vU43pna0pu&q=85&s=7832e9eacb56f571be1ddf2cad765813" href="/connect/claude" width="248" height="248" data-path="images/harnesses/claude.svg">
    A custom connector on claude.ai or Claude Desktop.
  </Card>

  <Card title="Claude Code" icon="https://mintcdn.com/mahadev/-gWik8vU43pna0pu/images/harnesses/claude.svg?fit=max&auto=format&n=-gWik8vU43pna0pu&q=85&s=7832e9eacb56f571be1ddf2cad765813" href="/connect/claude-code" width="248" height="248" data-path="images/harnesses/claude.svg">
    `claude mcp add`, and a `.mcp.json` the team shares.
  </Card>

  <Card title="ChatGPT" icon="https://mintcdn.com/mahadev/-gWik8vU43pna0pu/images/harnesses/chatgpt.svg?fit=max&auto=format&n=-gWik8vU43pna0pu&q=85&s=a8dda8c64066b70ef994980d378002e6" href="/connect/chatgpt" width="267" height="267" data-path="images/harnesses/chatgpt.svg">
    Connector in the chat UI, or the Responses API `mcp` tool.
  </Card>

  <Card title="Grok" icon="https://mintcdn.com/mahadev/-gWik8vU43pna0pu/images/harnesses/grok-light.svg?fit=max&auto=format&n=-gWik8vU43pna0pu&q=85&s=f4164b603e360ff3d355430b4293a73d" href="/connect/grok" width="1024" height="1024" data-path="images/harnesses/grok-light.svg">
    A custom connector, or the xAI API's remote MCP tool.
  </Card>

  <Card title="Cursor" icon="https://mintcdn.com/mahadev/-gWik8vU43pna0pu/images/harnesses/cursor.svg?fit=max&auto=format&n=-gWik8vU43pna0pu&q=85&s=e2cc64cf7b211015b7939ea83bd19030" href="/connect/cursor" width="532" height="532" data-path="images/harnesses/cursor.svg">
    One `mcp.json` entry.
  </Card>

  <Card title="VS Code" icon="https://mintcdn.com/mahadev/-gWik8vU43pna0pu/images/harnesses/vscode.svg?fit=max&auto=format&n=-gWik8vU43pna0pu&q=85&s=8c9516667dba7313f12a62a6181fcc4d" href="/connect/vscode" width="100" height="100" data-path="images/harnesses/vscode.svg">
    One `.vscode/mcp.json` entry, agent mode on.
  </Card>
</CardGroup>

<Card title="Something else?" icon="plug" href="/connect/clients" horizontal>
  Windsurf, Zed, Cline, Continue, Goose, Junie, LibreChat, Warp and n8n all
  connect, and so does anything built on an MCP SDK. Nothing here checks which
  client is calling.
</Card>

## 5. Ask for something

> *List the agents in my workspace.*

The model calls a read tool, gets a JSON payload, and reads it back to you. Then
try something that spends:

> *Upload this contract and pull out the parties, the term and the notice period.*

That one uploads a document, waits for it to parse, starts an extraction and
polls a job. It also costs credits — see [Credits](/connect/credits).

The scopes the set can ever need are advertised separately, and need no
credential at all:

```bash theme={null}
curl -s https://api.impellabs.tech/.well-known/oauth-protected-resource \
  | jq '.scopes_supported'
```

<Note>
  **Four kinds of work never answer inline.** Extractions, reports, knowledge
  ingestions and jobs all hand back a job id instead of a result, and the model
  has to poll. A client that reports "started" and stops is behaving correctly;
  ask it to check the job. [Tools](/connect/tools) explains why.
</Note>