How does Cursor discover and load MCP servers?

Flashcard·Easy·4.0 · 0·~30s·Asked atAirbnb Cursor Qualcomm·Relevant atAnthropic Microsoft

Attempt it

Cursor is the AI-first VS Code fork that ships with an MCP client built into the editor shell. You declare servers in one of two JSON files: globally at ~/.cursor/mcp.json (loads for every project) or per project at .cursor/mcp.json in the repo root (loads only when that repo is open). Both files use an mcpServers map where each entry specifies command + args + env for a local stdio server or url for a remote streamable HTTP endpoint. After a reload, Cursor lists the servers under Settings > Features > MCP with status indicators. Their tools become callable inside Composer and Agent mode alongside Cursor's built-in editor tools like edit_file and run_command. The per-project file is the standout feature: a repo can commit its MCP config so new engineers get the team's databases, ticketing, and ops servers wired up on first open.

Your answer

**Cursor** is an AI-first code editor (a VS Code fork) with an MCP client built into the editor shell. That makes Cursor an MCP host: it discovers MCP servers, connects to them, and exposes their tools to its AI features. You tell Cursor about servers by editing a JSON config file. Two locations are supported. Global servers go in `~/.cursor/mcp.json` and load for every project you open. Per-project servers go in `.cursor/mcp.json` at the repo root and load only when you open that repo. Both files use a shape that mirrors Claude Desktop's: an `mcpServers` map where each entry is either `command + args + env` for a local stdio subprocess or `url` for a remote streamable HTTP endpoint. After saving and reloading, Cursor lists the servers under Settings > Features > MCP with a status indicator for each (running, errored, disabled). The tools the servers advertise then appear inside Composer and Agent mode. The model can call MCP tools alongside Cursor's native editor tools like `edit_file` and `run_command` in the same agent turn. The per-project file is the headline feature. A team can commit `.cursor/mcp.json` to the repo so everyone who clones it gets the team's Postgres, GitHub, and Sentry servers wired in automatically, with no manual setup beyond opening the repo.

**Cursor** is the AI-first VS Code fork that ships with an MCP client in the core editor shell, making it one of the most widely used MCP hosts in 2026 alongside Claude Desktop. It is not an extension; the MCP client is part of Cursor itself. Configuration uses a two-tier model. Global servers live in `~/.cursor/mcp.json` and load for every project. Per-project servers live in `.cursor/mcp.json` at the repo root and load only when you open that repo. Both files use the canonical `mcpServers` map shape: server name as key, value of `{ command, args, env? }` for stdio or `{ url }` for remote streamable HTTP. Cursor exposes a polished settings panel at Settings > Features > MCP that lists loaded servers with status indicators and a one-click reload, which avoids the full quit and restart loop Claude Desktop requires. Once loaded, server tools are callable inside both Composer (single-turn) and Agent mode (multi-step). The model mixes MCP calls with Cursor's native editor tools (`edit_file`, `run_command`, `read_file`) in the same trajectory. A prompt like 'find the TODOs that reference the auth flow and create Linear tickets for them' can hop from the codebase to the Linear MCP server in one agent run. The per-project config is the feature that changes team workflows. Committing `.cursor/mcp.json` means the repo ships its own MCP toolchain. New engineers clone the repo, open it, and the tool surface lights up with the team's databases, ticketing systems, and ops servers on first launch.

TL;DR

Cursor loads MCP servers from `.cursor/mcp.json` per project or `~/.cursor/mcp.json` globally, exposing their tools inside Composer and Agent mode alongside the editor's native tools.

Memory aid

Easy to grasp

Imagine your code editor has hands. By default the hands can only do editor things: open a file, type, run a build. MCP lets you give the editor extra hands by listing helpers in a small file inside your project folder. One helper might know how to talk to your team's database; another might know how to comment on a pull request; another might know how to read your team's docs. The editor reads the list, starts every helper listed, and now the AI inside the editor can ask any helper to do its job. When you switch projects, the helpers change with the project, because the list lives inside the project folder. You can also keep personal helpers in a file at home that load for every project.

Key concepts

Cursor editor IDE integration MCP host

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Cursor is the editor most engineers reach for when they want an AI-native coding experience, and it has been an MCP host since early 2025. Alongside Claude Desktop it is one of the two reference hosts that MCP server authors test against first, and it is where most engineers first discover why MCP matters in their daily work.

This walkthrough covers what Cursor's MCP integration actually is, the two-tier config model that enables per-project setup, how MCP tools coexist with the editor's native tools inside Composer and Agent mode, and the operational details that separate a working setup from one that leaks secrets or confuses the agent.

Cursor as an MCP host

Cursor is a fork of VS Code with an AI-first chat surface (Composer) and a multi-step agentic mode (Agent mode) layered on top. The MCP client is built into the editor shell, not installed as a third-party extension. MCP servers are first-class citizens: they appear in the settings UI, they restart when the editor reloads, and they are callable from the same agent loop that drives the built-in tools.

The useful framing is to think of MCP as the way Cursor reaches outside the IDE. Cursor already has native tools for editing files, reading files, and running shell commands. You do not need MCP for any of that. What you do need MCP for is everything outside the codebase: your team's database, your ticketing system, your monitoring stack, your internal documentation. An MCP server is the standardized way to teach Cursor's agent how to talk to those external systems without writing a custom VS Code extension. The standardization is what matters: the same server you write for Cursor also works in Claude Desktop, Zed, and any other compliant host.

Two config files: global and per-project

Where servers show up inside the editor

Per-project config as the team onboarding win

Operational sharp edges

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

A monorepo commits `.cursor/mcp.json` with a Postgres MCP server pointed at the dev database. Every engineer who opens the repo gets schema introspection in Agent mode without local setup.
An ops team adds the Sentry MCP server globally in `~/.cursor/mcp.json` so Agent mode can fetch recent error groups when debugging any project.

What an interviewer would ask next. Try answering before peeking at the approach.

QWhy does per-project MCP config matter more than global config in a team setting?

Committing .cursor/mcp.json means the toolchain travels with the code. New engineers clone the repo and immediately get the team's database, ticketing, and ops servers without any per-machine setup.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Thinking Cursor exposes built-in tools like edit_file through MCP. Those are native editor tools; MCP servers add capabilities beyond the IDE itself, like database access and ticketing.

60 second bullets to scan on the way to the call.

What kind of editor Cursor is and what 'MCP host' means in this context
The two config file locations and which scope each applies to

Primary sources. Browse if you want the original framing.