---
title: Connect an AI agent
description: Create an API key and connect Claude, Cursor, VS Code or any MCP client to your RoboGNSS caster — plus the full tool list and what the error codes mean.
order: 0
---

# Connect an AI agent to RoboGNSS

RoboGNSS has an MCP server, so any AI assistant that supports the Model
Context Protocol can read your base stations, hand out rover credentials, and
test a rover login the way field hardware would. This page covers creating a
key, connecting the assistants we know work today, and what to do when a call
fails. For what agents can do with a caster and why some actions stay in the
dashboard, read the
[announcement post](https://robognss.com/blog/ntrip-caster-mcp-server).

The essentials, if you already know MCP:

- **Endpoint:** `https://robognss.com/api/mcp` (remote server, Streamable HTTP)
- **Auth:** `Authorization: Bearer rgk_YOUR_KEY` — an API key from
  [app.robognss.com/settings](https://app.robognss.com/settings)
- **Works on every plan.** Your plan decides what the tools may do, not
  whether you can connect.

## 1. Create an API key

1. Sign in at **app.robognss.com** and open **Settings**.
2. Under **API keys**, name the key for where it will live (`laptop-claude`,
   `shop-pc-cursor`) and click **Create key**.
3. **Copy the key now.** It starts with `rgk_` and is shown exactly once.
   Treat it like a password: it can see and operate your base stations.
4. Revoke it any time on the same page. Anything using it stops immediately.

An account can hold up to 10 keys at a time; revoke one to make room for
another. Keys are created only by you, signed in — a key cannot create or
revoke keys.

## 2. What a key can do

The tool list is short on purpose. A leaked key can misconfigure an account;
it must not be able to destroy one or start a feed to another caster in your
name.

**Read**

- `list_bases` — your base stations with live status: connection, data rate,
  broadcast position, satellites, rover and forward counts.
- `get_base` — full detail for one base: status, rover credentials, anomaly
  flags, live rover connections, forwards (read-only), archive availability.
  Includes the upload token, so treat the output as sensitive.
- `get_status` — live health for every base: connected, bytes per second,
  last data, broadcast-versus-declared position check, satellites per
  constellation, 24-hour uptime.
- `list_flags` — anomaly findings for one base: `position_mismatch`,
  `moving_base`, `station_id_mismatch`, `hardware_verification_revoked`.
- `list_rover_connections` — who is connected right now: username, address,
  client software, connected since, bytes out.
- `get_plan` — your plan, its limits, and current usage.
- `list_ppp_surveys` — PPP surveys for one base with status and results.
- `list_archive_hours` — which raw-data hours are archived for one base.
  Downloading happens in the dashboard.

**Act**

- `create_base` — create a base station from a declared position and datum.
  Returns the upload token once. Uses one of your plan's base slots.
- `mint_rover_credential` — create a rover login for one base. Returns the
  username and password once.
- `revoke_rover_credential` — revoke one rover login.
- `test_rover_credential` — dial the public NTRIP endpoint as a real rover
  with a stored credential and report what that rover sees (see below).
- `rotate_upload_token` — replace a base's upload token. The old one stops
  working immediately; the receiver needs the new one.
- `start_ppp_survey` — submit a window of archived observations for a PPP
  survey. Paid plans only. Results arrive later; poll `list_ppp_surveys`.

**Dashboard only, by design**

A key cannot set up, change, or enable forwarding to Onocoy or any other
caster; delete a base station; apply a PPP result to a base's declared
position; or manage API keys. Those need you, signed in.

## 3. Connect your agent

### Claude Code (terminal)

```bash
claude mcp add --transport http robognss https://robognss.com/api/mcp \
  --header "Authorization: Bearer rgk_YOUR_KEY"
```

Then ask: *"list my base stations and tell me which are healthy"*.

Or add it to a project's `.mcp.json` and keep the key in an environment
variable:

```json
{
  "mcpServers": {
    "robognss": {
      "type": "http",
      "url": "https://robognss.com/api/mcp",
      "headers": { "Authorization": "Bearer ${ROBOGNSS_API_KEY}" }
    }
  }
}
```

### Cursor

Settings → MCP → Add server:

```json
{
  "mcpServers": {
    "robognss": {
      "url": "https://robognss.com/api/mcp",
      "headers": { "Authorization": "Bearer ${env:ROBOGNSS_API_KEY}" }
    }
  }
}
```

### VS Code with Copilot

Run **MCP: Add Server** from the Command Palette and pick **HTTP** — give it
`https://robognss.com/api/mcp`, then add the `Authorization` header to the
entry it creates. Or write `.vscode/mcp.json` yourself:

```json
{
  "servers": {
    "robognss": {
      "type": "http",
      "url": "https://robognss.com/api/mcp",
      "headers": { "Authorization": "Bearer ${input:robognss_key}" }
    }
  },
  "inputs": [
    {
      "type": "promptString",
      "id": "robognss_key",
      "description": "RoboGNSS API key",
      "password": true
    }
  ]
}
```

The `inputs` block keeps the key out of the file — VS Code asks for it once and
stores it for you. Click **Start** above the server entry, then open Copilot
Chat in **Agent** mode; the RoboGNSS tools appear in its tools list.

### Any other MCP client

Zed, Windsurf, and Codex CLI take the same shape: a remote HTTP MCP server at
`https://robognss.com/api/mcp` with an `Authorization: Bearer rgk_YOUR_KEY`
header, wherever that client keeps its MCP settings.

### Claude Desktop — through a local bridge, for now

The Connectors screen expects a sign-in flow rather than an API key, so run a
small local bridge (`mcp-remote`, needs Node) that presents the key for you.
It runs on the same machine as the app. Add this to
`claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "robognss": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote", "https://robognss.com/api/mcp",
        "--header", "Authorization: Bearer ${ROBOGNSS_API_KEY}"
      ],
      "env": { "ROBOGNSS_API_KEY": "rgk_YOUR_KEY" }
    }
  }
}
```

The bridge is only needed while the connector screen insists on a sign-in
flow; a key-based connector would replace it.

### claude.ai and ChatGPT — not yet

The browser apps connect to remote servers directly, so a bridge running on
your own machine is not something they can reach, and their connector screens
accept only a sign-in flow — not an API key. ChatGPT's is OpenAI's rule, not
ours. Connecting either would need a sign-in flow we have not built; until
then, use one of the clients above.

## 4. Things to try

- *"List my base stations and their live status."*
- *"Why won't my rover get a fix?"* — the agent reads health and anomaly
  flags, then runs `test_rover_credential`, which dials the public NTRIP
  endpoint as a real rover with your stored credential and reports one of:
  caster unreachable, invalid credentials, mountpoint not found, client limit
  reached, connected and waiting (base not streaming), or receiving
  correction data.
- *"Mint a rover credential for the new tractor and give me the settings to
  type into its NTRIP client."*
- *"Start a 6-hour PPP survey over last night's data on my farm base."*
  (paid plans)
- *"Any anomaly flags on my bases this week?"*

## Troubleshooting

- **401 / `invalid_token`** — the key is mistyped or revoked, or the
  `Bearer ` prefix is missing from the header value.
- **403 with an upgrade hint** — the request is over your plan's limits. The
  message names the limit and points to
  [robognss.com/pricing](https://robognss.com/pricing).
- **404 on a base you can see in the dashboard** — the key belongs to a
  different account than the one you are signed in to.
- **"an account can have at most 10 API keys"** (on the Settings page) —
  revoke a key you no longer use, then create the new one.
