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

# Connect your client

> Set up the Tiro MCP server in Claude, ChatGPT, Cursor, Claude Code, or any MCP-compatible AI client.

export const ClientSetupAccordion = ({children}) => <div className="tiro-client-setup">
    <AccordionGroup>{children}</AccordionGroup>
  </div>;

The Tiro MCP server lives at `https://mcp.tiro.ooo/mcp`. Pick the client you use, follow the steps, and you're connected. Each client has a recommended authentication method, and most support an alternative.

<Note>
  **Don't have an API key yet?** Create one at the [Tiro Platform API Keys page](https://platform.tiro.ooo/dashboard/api-keys). Your key looks like `abc123.xR7mK9pL2qW4...` — copy the **entire string including the dot**. The dashboard shows a "Key ID" (e.g., `abc123`) for reference, but your Bearer token is the **complete string** shown only once at creation. If lost, generate a new one.
</Note>

<ClientSetupAccordion>
  <Accordion title="Claude Desktop" defaultOpen>
    **Recommended: OAuth.** Sign in once, the client manages tokens.

    <Note>
      [Node.js](https://nodejs.org/) is required. The `mcp-remote` package bridges streamable-http to the stdio transport that Claude Desktop expects.
    </Note>

    Open the configuration file for your platform:

    <CodeGroup>
      ```bash macOS theme={"system"}
      ~/Library/Application Support/Claude/claude_desktop_config.json
      ```

      ```bash Windows theme={"system"}
      %APPDATA%\Claude\claude_desktop_config.json
      ```

      ```bash Linux theme={"system"}
      ~/.config/Claude/claude_desktop_config.json
      ```
    </CodeGroup>

    Add the OAuth configuration:

    ```json claude_desktop_config.json theme={"system"}
    {
      "mcpServers": {
        "tiro": {
          "command": "npx",
          "args": ["-y", "mcp-remote", "https://mcp.tiro.ooo/mcp"]
        }
      }
    }
    ```

    Restart Claude Desktop. On first connection, your browser opens for Google sign-in. Tokens are cached locally and valid for 180 days.

    **Alternative: API Key.** If you prefer no browser flow, use:

    ```json claude_desktop_config.json theme={"system"}
    {
      "mcpServers": {
        "tiro": {
          "command": "npx",
          "args": [
            "-y", "mcp-remote",
            "https://mcp.tiro.ooo/mcp",
            "--header", "Authorization:Bearer YOUR_API_KEY"
          ]
        }
      }
    }
    ```
  </Accordion>

  <Accordion title="Claude Code (CLI)">
    **Recommended: API Key.** Avoids browser dependency, easy to rotate.

    ```bash theme={"system"}
    claude mcp add --transport http tiro-mcp https://mcp.tiro.ooo/mcp \
      --header "Authorization:Bearer YOUR_API_KEY"
    ```

    **Alternative: OAuth.** Omit `--header`. Claude Code opens a browser on first connection.

    ```bash theme={"system"}
    claude mcp add --transport http tiro-mcp https://mcp.tiro.ooo/mcp
    ```
  </Accordion>

  <Accordion title="ChatGPT">
    **Recommended: OAuth.** Most browser-capable MCP clients support OAuth out of the box:

    1. Add the server URL `https://mcp.tiro.ooo/mcp`.
    2. ChatGPT opens a browser window for Google sign-in.
    3. The client caches the access token.

    For clients without a built-in browser flow, run `mcp-remote` as a local stdio proxy and point ChatGPT at the local process:

    ```bash theme={"system"}
    npx -y mcp-remote https://mcp.tiro.ooo/mcp
    ```
  </Accordion>

  <Accordion title="Cursor">
    **Recommended: API Key.**

    1. Open **Settings** > **MCP**.
    2. Click **Add new MCP server**.
    3. Set transport to **HTTP**.
    4. Enter the server URL: `https://mcp.tiro.ooo/mcp`.
    5. Add a header: `Authorization: Bearer YOUR_API_KEY`.
  </Accordion>

  <Accordion title="VS Code (Copilot)">
    **Recommended: API Key.** Create or edit `.vscode/mcp.json` in your workspace:

    ```json .vscode/mcp.json theme={"system"}
    {
      "servers": {
        "tiro": {
          "type": "http",
          "url": "https://mcp.tiro.ooo/mcp",
          "headers": {
            "Authorization": "Bearer YOUR_API_KEY"
          }
        }
      }
    }
    ```
  </Accordion>

  <Accordion title="Other MCP clients">
    Any MCP client that speaks streamable-http works with these raw values:

    | Field        | Value                                                                |
    | ------------ | -------------------------------------------------------------------- |
    | Server URL   | `https://mcp.tiro.ooo/mcp`                                           |
    | Transport    | HTTP (streamable)                                                    |
    | Auth header  | `Authorization: Bearer YOUR_API_KEY`                                 |
    | OAuth issuer | `https://mcp.tiro.ooo` (if your client supports OAuth 2.0 with PKCE) |

    For stdio-only clients, wrap the endpoint with `mcp-remote`:

    ```bash theme={"system"}
    npx -y mcp-remote https://mcp.tiro.ooo/mcp \
      --header "Authorization:Bearer YOUR_API_KEY"
    ```
  </Accordion>
</ClientSetupAccordion>

***

## Scopes

Scopes define what the MCP server can access on your behalf. API keys currently grant **all scopes** automatically.

| Scope              | Description                                                  |
| ------------------ | ------------------------------------------------------------ |
| `mcp:notes:read`   | Read notes, transcripts, summaries, documents, and templates |
| `mcp:folders:read` | Search user and team folder structure                        |

<Note>
  Granular scope selection is not yet available. All authenticated connections receive full access. Fine-grained scope control is planned for a future release.
</Note>

***

## API key types

| Key Kind                 | Tied To       | Access                                                                                        |
| ------------------------ | ------------- | --------------------------------------------------------------------------------------------- |
| **User-scoped key**      | A user        | Every note, summary, document, and folder that user can access — can span multiple workspaces |
| **Workspace-scoped key** | One workspace | Everything in that single workspace; no user identity                                         |

<Info>
  **Which key do you need?** Most users start with a **user-scoped key** — you can search and read all notes you have access to, including notes in team folders, across every workspace you belong to. A **workspace-scoped key** is tied to a single workspace and searches that workspace automatically. Either kind can use the folder tools (`search_private_folders`, `search_team_folders`); both need only the `mcp:folders:read` scope, and the private/team distinction is the folder type, not the key.
</Info>

API keys do not expire unless revoked from the [Tiro Platform API Keys page](https://platform.tiro.ooo/dashboard/api-keys). We recommend rotating keys periodically and using separate keys for development and production.

OAuth tokens are valid for **180 days**. To rotate sooner, sign out from your client and sign in again. For immediate revocation, contact support.

Once connected, explore [what tools are available](/en/developers/mcp/tools/overview) — or head to [Troubleshooting](/en/developers/mcp/troubleshooting) if your client isn't connecting.