Connecting your assistant to Reelwire

The Reelwire MCP server speaks two transports, and which one you use depends on the client, not on what you want to do. The tools are identical either way.

Transport	Use it when	Address
Streamable HTTP	The server runs somewhere and several clients connect to it	`https://mcp.reelwire.io/mcp`
stdio	The client starts the process itself, on your own machine	`node .../mcp/dist/index.js --stdio`

Prefer HTTP unless the client only supports stdio. One server, one key, one place to rotate it.

Before you start: make the key

Connecting from claude.ai or ChatGPT? Skip this: they sign you in instead of taking a key, and the connection makes its own. See claude.ai and ChatGPT below.

Everything the assistant can do comes from this key, so make one for it rather than reusing a key some other system already holds.

Sign in to Reelwire and open Connections → API keys.
Press Create key and name it after the assistant, not after yourself: Claude, ChatGPT, Ops assistant. When you come to revoke one, the name is how you know which.
Tick the permissions you want it to have. The picker is grouped exactly like the side menu, so "everything except publishing" is a thing you can actually see and tick. See Permissions for what each area covers.
Copy the secret. It is shown once. If you lose it, revoke the key and make another; there is no way to recover it, by design.

Start narrower than you think

A key with read-only permissions is a genuinely useful assistant: it can answer what went out, why something failed and what is scheduled. Widen it once you have watched it work for a week.

Claude

Claude Desktop and Claude Code

Both read the same kind of configuration file. Open Settings → Developer → Edit Config in Claude Desktop, or use claude mcp add in Claude Code.

{
  "mcpServers": {
    "reelwire": {
      "type": "http",
      "url": "https://mcp.reelwire.io/mcp",
      "headers": {
        "Authorization": "Bearer rw_your_key_here"
      }
    }
  }
}

Restart the client. You should see Reelwire in the tools list with 104 tools.

In Claude Code the same thing in one line:

claude mcp add --transport http reelwire https://mcp.reelwire.io/mcp \
  --header "Authorization: Bearer rw_your_key_here"

claude.ai

claude.ai connects by signing you in to Reelwire, so there is no key to make or paste.

In claude.ai open Settings → Connectors and add a custom connector.
Give it the address https://mcp.reelwire.io/mcp and a name, Reelwire.
Press Connect. A Reelwire page opens: sign in if you are not already, and it asks whether Claude may use your workspace.
Choose what it may do. Reading is always included; the switch below it decides whether Claude may also change things. Press Allow, and you are back in claude.ai, connected.

What you allowed becomes a key of its own, listed under Connections → API keys with the assistant's name and (connected) after it. Revoke it there to end the connection; it stops working within a minute. It renews itself while you use it and lapses after thirty days of not being used.

Who may connect

Connecting makes a key, so it needs the same right as making one by hand: the workspace owner, or a colleague given the admin power. Anybody else sees a page saying so.

ChatGPT

ChatGPT connects the same way claude.ai does: by signing you in, with no key to paste. Add a custom connector (ChatGPT keeps these in its settings, and depending on your plan may ask you to switch on developer mode first), give it https://mcp.reelwire.io/mcp, choose OAuth if it asks how to authenticate, and sign in to Reelwire when the page opens. The consent page and the key it makes are exactly those described under claude.ai.

Some ChatGPT surfaces expose only search-shaped and fetch-shaped tools to the model rather than the full set. Where that is the case, reelwire_search_docs, reelwire_read_doc and the reelwire_list_* tools still work, and the ones that change things may not appear. If you need the full set, use a client that passes MCP tools through whole.

Coding agents

The agents that live in a terminal or an editor connect the same way, and they are worth naming separately because the reason to use one here is different. An assistant in a chat window answers questions about the workspace; an agent sitting in your repository can write the script that pushes events at a custom feed, and then run it and watch what arrives, without leaving the editor.

All of them take the same key from the step above, and all of them are bound by exactly what that key may do.

Claude Code

One line, and the configuration above covers the desktop app at the same time:

claude mcp add --transport http reelwire https://mcp.reelwire.io/mcp   --header "Authorization: Bearer rw_your_key_here"

Codex

Codex keeps its MCP servers in ~/.codex/config.toml, as TOML rather than JSON:

[mcp_servers.reelwire]
url = "https://mcp.reelwire.io/mcp"

[mcp_servers.reelwire.http_headers]
Authorization = "Bearer rw_your_key_here"

On a build of Codex that only starts servers itself, give it the stdio form instead:

[mcp_servers.reelwire]
command = "node"
args = ["/path/to/reelwire/mcp/dist/index.js", "--stdio"]
env = { REELWIRE_BASE_URL = "https://api.reelwire.io", REELWIRE_API_KEY = "rw_your_key_here" }

Cursor

Cursor reads ~/.cursor/mcp.json for every project, or .cursor/mcp.json inside one. The second is the better place for a workspace key, because it travels with the repository that uses it:

{
  "mcpServers": {
    "reelwire": {
      "url": "https://mcp.reelwire.io/mcp",
      "headers": { "Authorization": "Bearer rw_your_key_here" }
    }
  }
}

Then Settings → MCP, where Reelwire should appear with its tools listed. Cursor asks before each tool call until you tell it not to, which is worth leaving on while the key can publish.

VS Code

VS Code reads .vscode/mcp.json in a workspace. Note it says servers, not mcpServers:

{
  "servers": {
    "reelwire": {
      "type": "http",
      "url": "https://mcp.reelwire.io/mcp",
      "headers": { "Authorization": "Bearer rw_your_key_here" }
    }
  }
}

Or add it from the command line:

code --add-mcp '{"name":"reelwire","type":"http","url":"https://mcp.reelwire.io/mcp","headers":{"Authorization":"Bearer rw_your_key_here"}}'

The tools appear to the agent mode of the editor's chat, not to plain completions.

A key in a repository is a key in your history

.cursor/mcp.json and .vscode/mcp.json sit inside the project, so a key pasted into either is a key somebody can commit. Put the file in .gitignore, or keep the server in the per-user configuration and leave the project file out of it. Revoking is one press under Connections → API keys if it does get out.

Any other client

Anything that speaks MCP can connect. The two shapes are:

Streamable HTTP, for a server somebody is running:

{
  "mcpServers": {
    "reelwire": {
      "type": "http",
      "url": "https://mcp.reelwire.io/mcp",
      "headers": { "Authorization": "Bearer rw_your_key_here" }
    }
  }
}

stdio, for a client that starts the process:

{
  "mcpServers": {
    "reelwire": {
      "command": "node",
      "args": ["/path/to/reelwire/mcp/dist/index.js", "--stdio"],
      "env": {
        "REELWIRE_BASE_URL": "https://api.reelwire.io",
        "REELWIRE_API_KEY": "rw_your_key_here"
      }
    }
  }
}

Clients known to work with one or both, besides the ones above: Windsurf, Zed, Cline, Continue, LibreChat, and anything built on the official MCP SDKs.

Running it yourself

The server is a container. If you would rather it sat inside your own network, next to your own systems:

docker run -d \
  -p 4500:4500 \
  -e REELWIRE_BASE_URL=https://api.reelwire.io \
  -e REELWIRE_API_KEY=rw_your_key_here \
  reelwire/mcp

Variable	What it is
`REELWIRE_BASE_URL`	Where the Reelwire API lives
`REELWIRE_API_KEY`	The key from the step above. The only credential the server holds
`REELWIRE_DOWNLOAD_DIR`	Where tools that produce a file write it. Defaults to a temporary directory
`PORT`	What it listens on. Defaults to 4500

GET /health says whether it is up and how many documentation pages it is carrying.

Checking it worked

Ask the assistant:

Who am I on Reelwire, and what can you do?

It should call reelwire_whoami and answer with the workspace name and the permissions the key holds. That one question tells you three things at once: the connection works, the key is valid, and the permissions are what you meant to grant.

Then:

What is scheduled to go out this week?

which reaches reelwire_calendar.

When it does not work

The assistant does not see any Reelwire tools. The client did not connect. Restart it fully, not just the conversation. Check the URL ends in /mcp.

Everything is refused with "this key may not..." The key is valid and too narrow. The refusal names the permission; go back to Connections → API keys, open the key and tick it.

"Invalid credentials" on every call. The key is wrong, revoked, or was pasted with a trailing space. Keys start rw_. Make a fresh one rather than hunting for the typo.

Tools appear but time out. The client cannot reach the server. If you are running it yourself, check the container is up and the port is published.

A render never finishes. It takes about a minute. The assistant should leave ten to fifteen seconds between polls of reelwire_export_status; some will poll harder than that and give up. Tell it to wait.

Before you start: make the key​

Claude​

Claude Desktop and Claude Code​

claude.ai​

ChatGPT​

Coding agents​

Claude Code​

Codex​

Cursor​

VS Code​

Any other client​

Running it yourself​

Checking it worked​

When it does not work​