Hello, Lena is coming. I wasn't trying to set up anything complicated that afternoon.

I just wanted Cursor to reach into a database and pull context without me copying things manually. Simple enough, in theory. But the first time I looked at MCP servers in Cursor, I paused for longer than expected. The settings panel felt slightly different from what I'd seen documented two versions earlier. The config path had shifted. The UI had a new label. Not broken — just… the same as I remembered.

That's actually what this piece is about. Not just "here's the JSON." More like — here's what I noticed when I went through the process carefully, including the parts that confused me at first.

What MCP Servers Do in Cursor

How tool calling works inside the Cursor IDE

MCP — Model Context Protocol — is an open protocol that standardizes how applications give tools and context to LLMs. Anthropic open-sourced it in November 2024. By mid-2025, OpenAI and Google DeepMind had adopted it too. In December 2025, it moved under the Agentic AI Foundation — a Linux Foundation project. That shift matters a little. It went from being Anthropic's thing to something more genuinely shared.

Inside Cursor, MCP works like a plugin layer for the Agent. When you open an agent session, Cursor scans your enabled MCP servers, loads the tools they expose, and figures out which ones to call as part of whatever task it's running.

The protocol defines three pieces: hosts (Cursor itself), clients (the connectors inside Cursor), and servers (lightweight programs on the other end, exposing tools via JSON-RPC 2.0).

Tools are the main one — executable functions like create_issue or run_query. Cursor has supported tools from early on. Resources — contextual data like file contents and database schemas — arrived in Cursor v1.6 (September 2025). Prompts, which let servers offer reusable templates, came slightly later.

Hmm… I didn't realize resources were that recent. That might explain why some older tutorials feel incomplete.

Before You Start: Prerequisites

Cursor version that supports MCP

MCP support has been part of Cursor for a while now, but the configuration format has shifted between releases. Before doing anything else, check your version. Open Cursor → Help → About. The current stable release as of early 2026 supports all three transport types: stdio, SSE, and Streamable HTTP.

One thing worth confirming: the Settings panel now labels this section Tools & MCP, not just "Extensions" or something more generic. If you're looking for it and can't find it — that's probably why.

Node.js or Python requirements depending on server

Most MCP servers you'll encounter run on one of two stacks:

Node.js-based servers — launched via npx or node. Require Node.js 18+ in your PATH.
Python-based servers — launched via uv run or python. Require Python 3.10+ and often uv as a package manager.

I'd suggest running node --version and python --version in your terminal before anything else. It sounds obvious, but missing this step is quietly responsible for a surprising number of failed setups. The server process just… never starts, and Cursor gives you nothing useful in the panel.

How to Add an MCP Server to Cursor

Step 1: Find or build your MCP server

There are already a fair number of servers available — for GitHub, Postgres, Slack, browser automation, and more. The official MCP server registry on GitHub is a reasonable starting point. Some have one-click "Add to Cursor" buttons in their documentation, which handle the config automatically.

If you're building your own: servers just need to print to stdout (stdio transport) or serve an HTTP endpoint. Any language works, which is one of the things that makes this feel slightly different from earlier plugin systems I've used.

Step 2: Configure in Cursor settings

This is where I want to be precise, because the format matters and the docs don't always warn you when it's wrong.

There are two config locations:

Project-scoped: .cursor/mcp.json in your project root
Global: ~/.cursor/mcp.json in your home directory

The structure looks like this:

JSON

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "your-mcp-server-package"],
      "env": {
        "API_KEY": "your-value-here"
      }
    }
  }
}

The env field is how you pass API keys and sensitive config — they don't go in args. That took me a moment to understand intuitively.

One thing that catches people: if you miss the "mcpServers" root key, Cursor silently ignores the entire file. No error, no warning. The server just doesn't appear. I'm not sure why it works that way, but it does.

For Python servers using uv:

JSON

{
  "mcpServers": {
    "my-python-server": {
      "command": "uv",
      "args": ["run", "--with", "my-server-package", "my-server-package", "run"]
    }
  }
}

Alternatively, you can add servers through the UI: Settings → Tools & MCP → New MCP Server. That path is a bit more forgiving if you're not comfortable editing JSON directly.

Step 3: Verify the connection

After saving the config, open Settings → Tools & MCP. Each server should appear with a status indicator — green means connected, something else means it isn't.

If a server isn't showing up: check the root key first ("mcpServers", not "servers" or anything else). Then check that the command is actually available in your PATH. Cursor doesn't always surface useful errors here — that's one of the parts that still feels a bit unresolved to me.

Step 4: Test tool calls in an agent session

Open a new Agent session in Cursor (not a regular chat). Type something that would naturally invoke one of the server's tools. Cursor should ask for your confirmation before executing — that's expected behavior, not a problem.

If the tool call runs but returns nothing useful, check that the server is actually exporting the tool you think it is. The Tools & MCP panel shows which tools each server exposes. That list is worth reviewing before assuming something is broken.

Troubleshooting Common MCP Setup Issues

Server not showing up

Usually one of three things: missing "mcpServers" root key, a command that can't be found in PATH, or a JSON syntax error. Cursor is quiet about all of these. Validating your JSON manually — even pasting it into a linter — saves time.

Tool calls failing silently

Cursor has a limit of around 40 active tools across all servers. Past that, the agent starts struggling to pick the right tool because context fills up. If you have many servers enabled, try turning off the ones you're not using and hitting the refresh button in the Tools & MCP panel. That helped me more than once.

Authentication errors

If your server requires an API key and the tool call fails with a permissions error, double-check that the key is in the env field of your config, not hardcoded into args. Some server packages also expect specific environment variable names — worth checking the server's own documentation for the exact variable name expected.

Making Your Cursor MCP Setup Reusable

Why your config resets and how to make it stick

If you're only using .cursor/mcp.json inside a single project, the config disappears when you work in a different folder. That surprised me the first time. The solution is to also maintain a ~/.cursor/mcp.json at the global level for servers you want everywhere — things like a filesystem server or a documentation lookup tool.

For team setups, committing .cursor/mcp.json to source control means everyone on the project gets the same server configuration. The env values obviously shouldn't be committed — those belong in local environment config or a secrets manager.

One more thing worth keeping in mind: MCP servers run code with your credentials. Whatever permissions you give to a server — database access, GitHub tokens, API keys — it will use them. Before adding any third-party server, it's worth checking the MCP security guidance from the official documentation. The 2025 CVE disclosures around Cursor MCP were patched, but the underlying principle remains: treat each server as a fully trusted integration.

FAQ

How do I add an MCP server to Cursor?

Create or edit .cursor/mcp.json in your project directory (or ~/.cursor/mcp.json for global access), using the "mcpServers" root key. Add your server's command, args, and any environment variables. Then check Settings → Tools & MCP to confirm it connected.

Which version of Cursor supports MCP**?**

MCP tool support has been available in Cursor for some time. Resource support (contextual data like schemas and file contents) arrived in v1.6 (September 2025). Check Help → About to confirm your version, and keep Cursor updated — the MCP integration has changed meaningfully across releases.

Why is my MCP server not showing up in Cursor?

The most common cause is a missing or misspelled "mcpServers" root key in your config file. Cursor silently ignores the file if this key is absent. Other causes include the command not being found in PATH, or a JSON syntax error. Validate your config file and check that your runtime (Node.js or Python) is accessible from your terminal.

I'll probably keep watching how this evolves. The MCP ecosystem is still forming — servers are being added, the protocol is gaining adoption across more tools — and what the configuration looks like in another release or two, I'm genuinely not sure yet.

…but it doesn't feel random.

How to Add MCP Servers to Cursor: Complete Setup Tutorial