# Connect your assistant

Two things go into every client on this page: an address and a key.

```
https://api.atmon.ai/mcp
```

The key is an agent key from the console; see [Start](../start.md) if you do not have one yet. It travels as an `Authorization` header, never in a message and never in a file the assistant reads.

If you run atmon on your own machines, the address is your own node's `/mcp` instead and everything else on this page is unchanged.

The console's key page prints the block below with your own key already in it, so copying from there is one step fewer than copying from here.

## Every client at once

```
npx add-mcp https://api.atmon.ai/mcp
```

That reads which assistants are installed and writes the configuration into each of them.

## Claude Code

By command, naming the transport and passing the key as a header:

```
claude mcp add --transport http atmon https://api.atmon.ai/mcp \
  --header "Authorization: Bearer amk_your_key_here"
```

By file, in `.mcp.json` at the root of a project:

```json
{
  "mcpServers": {
    "atmon": {
      "type": "http",
      "url": "https://api.atmon.ai/mcp",
      "headers": { "Authorization": "Bearer amk_your_key_here" }
    }
  }
}
```

An entry with a `url` and no `type` is read as a local command, skipped, and reported as a server that has a url but no type. That one line is the most common reason a copied block does nothing.

## Claude Desktop

Claude Desktop does not take a remote server from its configuration file. Open Settings, then Connectors, then Add custom connector, and paste the address.

It shows a warning about connecting servers you trust. That warning is right to be there, and the [safety page](https://atmon.ai/safety) answers it.

## Cursor

In `.cursor/mcp.json`. No type field here.

```json
{
  "mcpServers": {
    "atmon": {
      "url": "https://api.atmon.ai/mcp",
      "headers": { "Authorization": "Bearer amk_your_key_here" }
    }
  }
}
```

## VS Code with Copilot

By command. VS Code asks for the key the first time the server starts and keeps it after that:

```
code --add-mcp "{\"name\":\"atmon\",\"type\":\"http\",\"url\":\"https://api.atmon.ai/mcp\"}"
```

By file, in `.vscode/mcp.json`. The top-level key is `servers`, not `mcpServers`:

```json
{
  "servers": {
    "atmon": {
      "type": "http",
      "url": "https://api.atmon.ai/mcp",
      "headers": { "Authorization": "Bearer ${input:atmon-key}" }
    }
  }
}
```

## Windsurf

In `mcp_config.json`. The address field is `serverUrl` rather than `url`, which is the single most common reason a copied block does nothing there:

```json
{
  "mcpServers": {
    "atmon": {
      "serverUrl": "https://api.atmon.ai/mcp",
      "headers": { "Authorization": "Bearer amk_your_key_here" }
    }
  }
}
```

## Codex CLI

```
codex mcp add atmon --url https://api.atmon.ai/mcp
```

In `config.toml`, with the key read from the environment rather than written into the file:

```toml
[mcp_servers.atmon]
url = "https://api.atmon.ai/mcp"
bearer_token_env_var = "ATMON_KEY"
```

## Anything else

Any client that speaks streamable HTTP MCP works. It needs the address, and it needs to send the key on the `Authorization` header. If a client cannot send a header, it cannot connect: there is no way to put a key in the address instead, on purpose, because addresses end up in logs.

## Check it worked

Ask the assistant what tools it has. Four names should come back: `search_tools`, `describe_tool`, `call_tool`, and `submit_job`, plus `get_job` beside the last one.

Then ask it to do something small and real. If nothing is connected yet the answer will say `not_connected`, which is the right answer and means the connection is working. [Connect an app](../using/connect-apps.md) is the next step.

Install [the atmon skill](./skill.md) too. The connection makes acting possible; the skill is what makes it act well.