# Cursor MCP Setup vs Claude Code MCP Setup

> Cursor configures MCP servers by hand-editing mcp.json; Claude Code adds them with claude mcp add from the CLI. Config file locations, project-vs-global scoping, servers that behave identically, and a migration checklist for founders running both tools.

Canonical: https://www.agentickit.co/compare/cursor-mcp-setup-vs-claude-code-mcp-setup
Last updated: 2026-11-18

Both tools speak the same Model Context Protocol, so a server that works in one generally works in the other — but the two editors get you there differently. Cursor wants you to hand-edit a mcp.json file; Claude Code wants you to run claude mcp add from the terminal and manages the JSON for you. The servers themselves aren't the hard part — matching scope (project vs. global) and file location across two tools you run against the same repo is. Last updated 2026-11-17 by Rakshit Yadav.



## Config file locations and syntax, side by side
**Cursor** stores MCP servers as plain JSON under a `mcpServers` key, in `.cursor/mcp.json` for a single project or `~/.cursor/mcp.json` for every project on the machine. You open the file (or use Cursor's Settings &gt; MCP panel, which writes to the same file) and add an entry by hand:
`{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": ["-y", "@supabase/mcp-server-supabase", "--project-ref=&lt;ref&gt;"]
    }
  }
}`**Claude Code** skips the hand-editing. You run a CLI command and it writes the config for you:
`claude mcp add supabase -- npx -y @supabase/mcp-server-supabase --project-ref=&lt;ref&gt;
claude mcp list
claude mcp remove supabase`Under the hood Claude Code's project-scoped servers land in `.mcp.json` at the repo root (shareable via git) or in your user config for personal servers — `claude mcp list` tells you which scope a given server is in without you needing to open a file at all.

## Scoping: project vs. global in each tool
<table><thead><tr><th></th><th>Cursor</th><th>Claude Code</th></tr></thead><tbody><tr><td>**Project-scoped file**</td><td>`.cursor/mcp.json` in the repo</td><td>`.mcp.json` at the repo root (add with `claude mcp add --scope project`)</td></tr><tr><td>**Global/user-scoped file**</td><td>`~/.cursor/mcp.json`</td><td>User-level config, written by `claude mcp add` with no `--scope` flag or `--scope user`</td></tr><tr><td>**Shared with teammates via git?**</td><td>Yes, if you commit `.cursor/mcp.json` — but it's easy to accidentally leave API keys inline in it</td><td>Yes for `.mcp.json` — same caveat on committing secrets inline instead of via env var references</td></tr><tr><td>**How you check what's active**</td><td>Settings &gt; MCP panel, or read the JSON files directly</td><td>`claude mcp list` from any directory inside the project</td></tr></tbody></table>The practical risk is identical in both tools: a project-scoped MCP config with a raw API key committed to git. Reference an environment variable in the command/args instead of a literal key, in either `mcp.json` or via `claude mcp add`.

## Servers that work identically across tools
Because both editors implement the same MCP client-server handshake, any server distributed as a plain stdio command — `npx -y @some-org/mcp-server-x` or a local binary — drops into either tool's config with the same `command` and `args`. In practice that covers most of what solo founders reach for first: GitHub, Supabase/Postgres, Playwright, and filesystem-style servers all behave the same whether Cursor or Claude Code is the client making the calls, since none of them depend on editor-specific hooks or UI.

## Gotchas when behavior diverges
Three places the two tools don't line up, even with an identical server running:
- **Tool-call approval UI differs.** Cursor and Claude Code each render their own confirmation prompt before an MCP tool call that writes or deletes something — the server doesn't control this, so a server built assuming one tool's prompt flow may feel abrupt in the other.
- **Resource vs. tool support can lag.** Both clients support MCP tools; support for MCP resources (read-only context, not an action) has historically rolled out at different paces across editor versions, so a server that leans on resources is worth testing in whichever tool you'll actually run it in before assuming parity.
- **Where the server's output lands.** Claude Code subagents can route an MCP tool's output to a specific agent's isolated context; Cursor has no equivalent isolation layer, so the same server's output always lands in your one active chat.

## Migration checklist: moving an MCP setup between tools
<ol>- List what's currently configured — `claude mcp list`, or open `.cursor/mcp.json` / `~/.cursor/mcp.json` directly.
- For each server, copy just the `command` and `args` array — these are the two fields that transfer as-is.
- Re-add on the target side: paste into the matching `mcpServers` block for Cursor, or run `claude mcp add &lt;name&gt; -- &lt;command&gt; &lt;args...&gt;` for Claude Code.
- Re-enter any secrets as environment variable references rather than copying literal keys out of the old file.
- Decide scope deliberately on the new side — a server you had global in one tool doesn't have to be global in the other; match it to whether every project needs it.
- Confirm with `claude mcp list` or the Cursor MCP panel, then run one real tool call before deleting the old config.
</ol>If you're also carrying rules/CLAUDE.md or commands between the two tools at the same time, the [Config Converter](https://www.agentickit.co/tools/config-converter) handles those formats — MCP config isn't part of that conversion since both tools already read the same server definitions, just from different files.



## FAQ

### Does an MCP server need to be written differently for Cursor vs. Claude Code?
No. MCP is a protocol, not an editor feature — a server written to the spec works with any compliant client. The difference is entirely in how each editor stores the config that tells it to launch that server, not in the server's own code.

### Can I run the same MCP server in both Cursor and Claude Code at once, on the same project?
Yes. Add it to both .cursor/mcp.json and via claude mcp add (or .mcp.json) — they're independent configs pointing at the same underlying command, so both tools can launch their own instance of the server without conflict.

### Which tool makes MCP setup easier for a non-technical founder?
Claude Code's claude mcp add writes the JSON for you, so there's no file to hand-edit or risk breaking with a syntax error. Cursor's Settings > MCP panel also writes to mcp.json without manual editing, but the project-scoped file is still something you may need to open directly to debug.

### Is it safe to commit .mcp.json or .cursor/mcp.json to git?
Only if it contains no literal secrets. Reference API keys through environment variables in the command/args rather than typing them directly into the JSON — otherwise committing either file leaks credentials to anyone with repo access.

## Related
- [Cursor Skills vs MCP Servers](https://www.agentickit.co/compare/cursor-skills-vs-mcp)
- [Claude Code Hooks vs MCP Servers](https://www.agentickit.co/compare/claude-code-hooks-vs-mcp-servers)
- [Claude Code Plugins vs Skills vs MCP](https://www.agentickit.co/compare/claude-code-plugins-vs-skills-vs-mcp)
- [Best MCP Servers for Claude Code SaaS Founders](https://www.agentickit.co/blog/best-mcp-servers-claude-code-saas-founders)
- [Cursor Rules vs Claude Code CLAUDE.md](https://www.agentickit.co/compare/cursor-rules-vs-claude-md)
- [Config Converter](https://www.agentickit.co/tools/config-converter)
- [The 34 AgenticKit agents](https://www.agentickit.co/agents)
