How to Connect Cursor, Claude and Any AI Tool to 363 APIs With One MCP Server in 2026

The usual way to give an AI tool access to an API is to find an MCP server for that API and install it. Do that eight times and you have eight servers to configure, eight things to keep updated, and a context window carrying every tool definition from all of them before you have asked a single question.

There is a simpler shape. One server, seven tools, 363 APIs. The agent searches the catalog for the operation it needs rather than being handed every operation up front, which means your eighth provider costs nothing extra in context.

This page is the setup for every tool, and what to do after it works.

Why one server instead of many

Every MCP server you connect loads its tool definitions into the model's context on every request. A server that exposes one tool per endpoint scales badly: ten of those is hundreds of definitions, which is both a standing token cost and a reason the model picks the wrong tool more often.

The alternative is a small, fixed set of tools that can reach anything. The default agent profile exposes seven:

Those seven reach every integration in the catalog. There is a second full profile with fifteen tools, adding init, bootstrap, version, get, doctor, policy_check, policy_add and policy_remove, which is worth running while you set things up and worth switching away from afterwards:

swy mcp serve --profile agent   # default
swy mcp serve --profile full    # while building

Install once

npm install -g swytchcode   # or npx swytchcode
swy login

Then pick your tool below. Each writes the right config in the right place, so you are not hand-editing JSON.

Setup per tool

Cursor

swy init --editor=cursor

Updates ~/.cursor/mcp.json. Restart Cursor and check the server appears in Settings with its tools enabled. The longer version, including which other servers are worth having alongside it, is in best MCP servers for Cursor.

Claude Code

swy mcp serve --claude

Registers directly, with no config file to edit. To change profile later:

claude mcp remove swytchcode
swy mcp serve --claude --profile full

More in best MCP servers for Claude Code.

Windsurf

swy init --editor=windsurf

Merges into ~/.codeium/windsurf/mcp_config.json. To add it by hand instead, go to Settings > MCP Servers and add a server with command swy mcp serve and transport stdio.

GitHub Copilot in VS Code

swy init --editor=copilot

Creates .vscode/mcp.json and .github/copilot-instructions.md, so the project carries both the server config and the instructions telling Copilot how to use it.

Codex

swy init --editor=codex

Then follow the Codex quickstart in the docs.

Gemini CLI

swy init --editor=gemini

Then the Gemini CLI quickstart in the same place.

OpenClaw

swy init --editor=openclaw

Updates ~/.openclaw/settings.json.

Hermes

swy init --editor=hermes

Updates ~/.hermes/config.yaml.

Anything else

If your client is not on the list, point it at the server directly. stdio needs no token:

swy mcp serve

HTTP mode binds to localhost and needs a bearer token:

swy mcp serve --transport http --port 5476
swy mcp token            # print it
swy mcp token --rotate   # invalidate and reissue

That serves at http://127.0.0.1:5476/sse, and the token lives at ~/.swytchcode/mcp_token. Add -d to run it in the background.

Verify it

swy mcp status

If something looks wrong, swy doctor checks the project setup, and the MCP Inspector will show you exactly what the server is advertising:

npx @modelcontextprotocol/inspector ./swy mcp serve

Adding your first API

Connecting the server is half of it. The other half is deciding what the agent may actually do, which takes four commands:

swy get stripe                       # pull the integration
swy discover "refund a charge"       # find the operation by description
swy info stripe.refund.create3       # check its real parameters
swy add method stripe.refund.create3 # allow exactly this one
swy auth connect stripe              # store the credential

Two of those deserve emphasis.

swy add method is an allow list, and it is the actual security boundary. Only methods you have added can run. An agent that asks for an operation you never approved fails at the runtime, before a request reaches the provider. This is what makes "the agent has access to Stripe" mean something narrower than it sounds.

swy auth connect keeps the secret away from the model. The credential goes into ~/.swytchcode/credentials.db, a local store outside your project folder. There is no .env file in this setup, nothing secret in the repo, and nothing secret in a prompt. The reasoning is in credential brokering for AI agents.

Mode is set once, at init, and stored in .swytchcode/tooling.json:

swy init --mode=sandbox --editor=cursor

It is not an environment variable and your code never reads it. Start in sandbox and stay there until you have watched the audit output for a while.

The part that is not the protocol

MCP gets the call from the model to the server. It does not make the call correct, repeatable or accountable, and assuming otherwise is where production incidents come from. Four things sit outside the protocol.

Schema validation. Coding agents invent parameter names. With info in the loop the model can look up the real ones instead of recalling them, which removes most of the failures described in why your AI agent calls the wrong API and the opaque failures in a 400 with no error message.

Idempotency. A retried write is a second write unless the same key goes with it. The 2026-07-28 revision made MCP stateless and removed stream resumability, so a retry carries a new request ID and you cannot deduplicate on it. See MCP went stateless and idempotency explained.

Policy. An allow list permits a method. It does not say how large a refund may be or who has to approve it:

{
  "id": "big-refunds",
  "target": ["stripe.refund.create3"],
  "when": { "field": "amount", "operator": ">", "value": 50000 },
  "action": {
    "type": "REQUIRES_APPROVAL",
    "message": "Refunds over 500.00 need approval"
  },
  "approval_timeout": "2h"
}

Keep it in git and changes get reviewed: policy-as-code for AI agents, and human-in-the-loop approval.

An audit trail. Written by whatever sent the request, including the calls that were refused:

swy audit network   # what ran
swy audit policy    # what was denied or held

The fields worth recording are in logging every API call an agent makes, and the distinction between transport and execution is in MCP gateway vs execution layer.

Keeping it working

The reason integrations rot is that providers change them. A parameter gets renamed, an endpoint is deprecated, a required field appears, and the operation your agent called last month fails this month for reasons nobody logged.

Every API added to Swytchcode becomes agent-ready in minutes, and from then on its specs and documentation are observed for breaking changes and updates. That is the difference between drift being somebody's job and being nobody's, and it is the underlying cause behind why AI coding agents keep using deprecated APIs.

FAQ

How do I connect Cursor or Claude Code to an API through MCP?

Install the CLI, sign in, then run one command for your tool: swy init --editor=cursor for Cursor, or swy mcp serve --claude for Claude Code. Then pull the integration with swy get, find the operation with swy discover, allow it with swy add method, and connect the credential with swy auth connect. The agent can then call it by name.

Do I need a separate MCP server for every API?

No, and that is the point. One server with seven tools reaches all 363 integrations in the catalog, because the agent searches for operations rather than being given every operation as its own tool. Running a server per provider means more configuration to maintain and more tool definitions sitting in context on every request.

Which AI tools can connect to this?

Cursor, Claude Code, Windsurf, GitHub Copilot in VS Code, Codex, Gemini CLI, OpenClaw and Hermes all have a one-command setup. Anything else that speaks MCP can point at swy mcp serve over stdio, or at the localhost HTTP transport with a bearer token.

Where is the MCP config file for each editor?

Cursor uses ~/.cursor/mcp.json, Windsurf uses ~/.codeium/windsurf/mcp_config.json, GitHub Copilot uses .vscode/mcp.json alongside .github/copilot-instructions.md, OpenClaw uses ~/.openclaw/settings.json and Hermes uses ~/.hermes/config.yaml. Claude Code registers servers directly instead of using a file you edit.

How do I stop the agent calling something dangerous?

Two layers. The allow list means only methods you added with swy add method can run at all. Policies then gate how an allowed method may be used, so a refund over a threshold can require human approval or be denied outright. Both are checked at execution time rather than being instructions in a prompt.

Does the agent see my API keys?

No. Credentials are stored in ~/.swytchcode/credentials.db outside your project and injected when a call runs. Nothing secret goes into the repository, into code, into an environment variable or into a prompt, and there is no .env file in this setup.

What is the difference between the agent and full tool profiles?

agent is the default with seven tools, sized for day-to-day use. full has fifteen, adding setup and policy-write commands. Use full while configuring and switch back to agent for anything running regularly, since every extra tool definition is context you pay for on every request.

Commands on this page come from the Swytchcode MCP docs, the MCP quickstart and the CLI project docs. The agent-readable version of all of this lives at swytchcode.com/skills.md.