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

# Connect a client

> Complete, copy-pasteable Attensira MCP setup for Claude Code, Claude Desktop, Claude.ai, Cursor, VS Code, Codex CLI, Windsurf, Zed, Cline, ChatGPT, n8n, and any other MCP client.

Every client below connects to the same endpoint with the same header. What changes is where you put them.

| Setting    | Value                                       |
| ---------- | ------------------------------------------- |
| Server URL | `https://mcp.attensira.com/mcp`             |
| Transport  | Streamable HTTP                             |
| Header     | `Authorization: Bearer atn_live_<your key>` |

## Get a key first

Mint a key at [app.attensira.com/settings/developer](https://app.attensira.com/settings/developer). It is shown exactly once: only a hash is stored, so Attensira cannot re-display it. Copy it somewhere safe — a password manager or your shell environment — before you close the dialog.

The key names your workspace, so no tool asks for a workspace id. If you lose it, revoke and mint a new one; there is no recovery path.

<Tip>
  Export it once and reference it by name wherever a client supports environment variables:

  ```bash Shell theme={null}
  export ATTENSIRA_API_KEY="atn_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
  ```

  Put that line in your shell profile so GUI clients launched from a terminal inherit it.
</Tip>

## Which clients need a bridge

The Attensira server speaks **Streamable HTTP only**. Clients that speak remote HTTP natively connect directly. Clients that only launch local stdio processes cannot, and need the `mcp-remote` bridge, which runs locally over stdio and forwards to the HTTPS endpoint.

| Client                                     | Connects directly | Notes                                    |
| ------------------------------------------ | ----------------- | ---------------------------------------- |
| Claude Code, Claude Desktop, Claude.ai     | Yes               | Native remote HTTP support               |
| Cursor, VS Code + Copilot, Windsurf, Cline | Yes               | Config file takes a `url` and `headers`  |
| Codex CLI                                  | Yes               | TOML table with `url` and `http_headers` |
| ChatGPT, n8n                               | Yes               | URL and header entered in the UI         |
| Zed, older client builds                   | Via `mcp-remote`  | stdio-only; see the Zed section          |

<Warning>
  `.cursor/mcp.json`, `.vscode/mcp.json`, and any config file inside a repository are shared files. A key pasted into one and committed is a leaked key — assume it is public the moment it is pushed, revoke it, and mint a new one. Use the environment-variable form in repo-visible files, and add local overrides to `.gitignore`.
</Warning>

## Claude Code

Add the server with one command. The key is read from your environment, so it never lands in a file:

```bash Shell theme={null}
claude mcp add --transport http attensira https://mcp.attensira.com/mcp \
  --header "Authorization: Bearer $ATTENSIRA_API_KEY"
```

If you prefer the literal key, substitute it inline:

```bash Shell theme={null}
claude mcp add --transport http attensira https://mcp.attensira.com/mcp \
  --header "Authorization: Bearer atn_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
```

Add `--scope user` to make the server available in every project instead of only the current one. Verify with `claude mcp list`, then ask Claude to call `get_account` — a successful reply names your workspace.

## Claude Desktop

Edit `claude_desktop_config.json` (Settings → Developer → Edit Config), add the block below, and restart the app. Claude Desktop does not expand shell variables in this file, so the key is written literally — protect the file with filesystem permissions and never copy it into a repository.

```json claude_desktop_config.json theme={null}
{
  "mcpServers": {
    "attensira": {
      "url": "https://mcp.attensira.com/mcp",
      "headers": {
        "Authorization": "Bearer atn_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}
```

After restarting, the Attensira tools appear in the tool menu of a new conversation. Existing conversations do not pick up new servers.

## Claude.ai

Claude.ai connects over the web, so there is no file to edit. Go to Settings → Connectors → Add custom connector, give it the name `Attensira`, and enter `https://mcp.attensira.com/mcp` as the URL.

In the advanced or header section of the dialog, add one header: name `Authorization`, value `Bearer atn_live_...`. Save, then open a new chat and enable the connector from the tools menu. Availability of custom connectors depends on your Claude plan and, on Team and Enterprise, on whether an administrator has allowed them.

## Cursor

Create `.cursor/mcp.json` in the project, or `~/.cursor/mcp.json` for all projects. Cursor expands `${env:VAR}`, so prefer the secret-free form:

```json .cursor/mcp.json theme={null}
{
  "mcpServers": {
    "attensira": {
      "url": "https://mcp.attensira.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:ATTENSIRA_API_KEY}"
      }
    }
  }
}
```

Only if your Cursor build does not expand the variable, write the key literally in `~/.cursor/mcp.json` — the home-directory file, never the in-repo one:

```json ~/.cursor/mcp.json theme={null}
{
  "mcpServers": {
    "attensira": {
      "url": "https://mcp.attensira.com/mcp",
      "headers": {
        "Authorization": "Bearer atn_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}
```

Reload Cursor, then check Settings → MCP: the server should list 15 tools.

## VS Code + Copilot

VS Code reads `.mcp.json` at the workspace root or `.vscode/mcp.json`. Its `inputs` mechanism prompts you for the key on first use and stores it in secret storage, which keeps it out of the committed file:

```json .vscode/mcp.json theme={null}
{
  "inputs": [
    {
      "id": "attensira-key",
      "type": "promptString",
      "description": "Attensira API key (atn_live_...)",
      "password": true
    }
  ],
  "servers": {
    "attensira": {
      "type": "http",
      "url": "https://mcp.attensira.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:attensira-key}"
      }
    }
  }
}
```

This file is safe to commit — it contains a prompt, not a secret. Start the server from the Start link that appears above the entry, then open Copilot Chat in Agent mode and check the tools picker.

## Codex CLI

Codex CLI uses `~/.codex/config.toml`. Add an `mcp_servers` table:

```toml ~/.codex/config.toml theme={null}
[mcp_servers.attensira]
url = "https://mcp.attensira.com/mcp"

[mcp_servers.attensira.http_headers]
Authorization = "Bearer atn_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
```

If your Codex build supports reading headers from the environment, prefer that form so the key stays out of the file:

```toml ~/.codex/config.toml theme={null}
[mcp_servers.attensira]
url = "https://mcp.attensira.com/mcp"

[mcp_servers.attensira.env_http_headers]
Authorization = "ATTENSIRA_AUTH_HEADER"
```

With that variant, set `export ATTENSIRA_AUTH_HEADER="Bearer $ATTENSIRA_API_KEY"` in your shell profile. Restart Codex after editing the file.

## Windsurf

Windsurf reads `~/.codeium/windsurf/mcp_config.json`, using the same shape as the other config-file clients:

```json ~/.codeium/windsurf/mcp_config.json theme={null}
{
  "mcpServers": {
    "attensira": {
      "serverUrl": "https://mcp.attensira.com/mcp",
      "headers": {
        "Authorization": "Bearer atn_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}
```

If your Windsurf version rejects `serverUrl`, use `"url"` instead — the two spellings have both shipped. Press the refresh control in the Cascade MCP panel after saving. Since this file lives in your home directory, it is not part of any repository, but it is still plaintext on disk.

## Zed

Zed launches MCP servers as local processes, so it needs the `mcp-remote` bridge to reach a Streamable HTTP endpoint. Add a context server in `settings.json`:

```json Zed settings.json theme={null}
{
  "context_servers": {
    "attensira": {
      "source": "custom",
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.attensira.com/mcp",
        "--header",
        "Authorization: Bearer ${ATTENSIRA_API_KEY}"
      ],
      "env": {
        "ATTENSIRA_API_KEY": "atn_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}
```

The bridge needs Node.js on your machine. Its first run downloads the package, so allow a few seconds before the tools appear.

## Cline

In VS Code, open Cline → MCP Servers → Configure, and add a remote entry:

```json cline_mcp_settings.json theme={null}
{
  "mcpServers": {
    "attensira": {
      "type": "streamableHttp",
      "url": "https://mcp.attensira.com/mcp",
      "headers": {
        "Authorization": "Bearer atn_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}
```

Cline also has a "Remote Servers" tab where you can paste the URL and header without editing JSON. If your Cline version offers only stdio entries, use the `mcp-remote` command shown in the Zed section instead.

## ChatGPT

ChatGPT connects to remote MCP servers as a connector, configured in the UI rather than a file. Under Settings → Connectors → Create, choose a custom or developer-mode connector, enter `https://mcp.attensira.com/mcp`, and select **no authentication** at the OAuth step — Attensira uses a static bearer header, not OAuth.

Then add a custom header with name `Authorization` and value `Bearer atn_live_...`, and save. Enable the connector per conversation from the tools menu.

<Note>
  Custom MCP connectors in ChatGPT depend on your plan and workspace settings, and some surfaces restrict which tools a connector may call. If write tools such as `add_prompts` are unavailable, that is a ChatGPT-side restriction, not a server error.
</Note>

## n8n

Use the **MCP Client Tool** node inside an AI Agent workflow. Set the endpoint to `https://mcp.attensira.com/mcp` and the transport to HTTP Streamable — not SSE, which the server does not offer.

For credentials, choose the Bearer or header-auth credential type and store the key there. n8n credentials are encrypted at rest and are not written into the workflow JSON, so an exported or version-controlled workflow does not carry the key. Once connected, the node exposes the Attensira tools to the agent; restrict the tool list on the node if you do not want the agent reaching credit-spending tools such as `run_automation`.

## Any other MCP client

Any client that supports remote MCP servers can connect with three facts:

```text Connection details theme={null}
URL:       https://mcp.attensira.com/mcp
Transport: Streamable HTTP (POST + SSE response stream). No stdio, no plain SSE transport.
Header:    Authorization: Bearer atn_live_<32 hex>
```

If the client speaks stdio only, run the bridge locally and point the client at it:

```bash Shell theme={null}
npx -y mcp-remote https://mcp.attensira.com/mcp \
  --header "Authorization: Bearer ${ATTENSIRA_API_KEY}"
```

To confirm the endpoint is reachable before you debug the client, request the unauthenticated health path:

```bash Shell theme={null}
curl -i https://mcp.attensira.com/healthz
```

<Check>
  Connected. Ask your assistant to call `get_account` — it returns your workspace without you supplying a workspace id, which confirms the key is bound correctly.
</Check>

If a client stays silent or shows no tools, see [Troubleshooting](/mcp/troubleshooting).