How to Set Up MCP Servers in Cursor: Complete 2026 Guide

Cursor can write code. It can refactor, explain, and debug. But by default, it can't look up what changed in your GitHub repo, query your database, or search the web for current information — not until you wire up MCP servers.

Here's exactly how to do it, which servers are worth adding, and where MCP starts to show its limits.

What MCP Servers Do in Cursor

MCP (Model Context Protocol) is the open standard that lets AI agents connect to external tools through a consistent interface. When you add an MCP server to Cursor, the agent gains access to the tools that server exposes.

Add the GitHub MCP server → Cursor can create issues, fetch pull requests, read file contents from any repo.

Add a PostgreSQL server → Cursor can run queries and inspect your database schema directly.

Add a web search server → Cursor can fetch current information without you pasting it in manually.

The agent discovers these tools automatically. You don't need to write prompt instructions explaining how to call GitHub — the server's schema does that.

Two Ways to Add MCP Servers in Cursor

Method 1: Cursor Settings UI

1. Open Cursor
2. Go to Settings → Features → MCP Servers
3. Click Add MCP Server
4. Fill in the server name, command, arguments, and any required environment variables
5. Click Save — Cursor picks up the new server immediately

This is the fastest way to add a server for personal use.

Method 2: .cursor/mcp.json (Recommended for Teams)

Create a .cursor/mcp.json file in your project root. Commit it to version control. Every team member gets the same MCP configuration when they open the project in Cursor.

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "your_brave_api_key"
      }
    },
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost/mydb"
      ]
    }
  }
}

Cursor reads this file on startup and makes all listed servers available to the agent.

Security note: Don't commit API keys directly to your repo. Use environment variable references or a secrets manager, and add .cursor/mcp.json to .gitignore if it contains credentials.

The 6 Most Useful MCP Servers for Cursor Users

1. GitHub

{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-github"],
  "env": { "GITHUB_TOKEN": "ghp_your_token" }
}

What it unlocks: Create/close issues, list pull requests, read file contents from any repo, search repositories. Invaluable for teams using Cursor alongside GitHub workflows.

2. Brave Search

{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-brave-search"],
  "env": { "BRAVE_API_KEY": "your_key" }
}

What it unlocks: Real-time web search. The agent can fetch current documentation, changelogs, Stack Overflow answers, and news — instead of relying on training data that may be months old.

3. PostgreSQL

{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:password@localhost/dbname"]
}

What it unlocks: Run queries, inspect table schemas, analyze data. The agent can write and validate SQL against your actual database structure, not a guessed schema.

4. Filesystem

{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/directory"]
}

What it unlocks: Expanded file system access beyond the project directory. Useful when the agent needs to read config files, reference docs, or assets stored outside the main repo.

5. Notion

{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-notion"],
  "env": { "NOTION_API_TOKEN": "your_token" }
}

What it unlocks: Read and search your team's Notion workspace. The agent can pull in product specs, design documents, and meeting notes directly into its working context.

6. Slack

{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-slack"],
  "env": {
    "SLACK_BOT_TOKEN": "xoxb-your-token",
    "SLACK_TEAM_ID": "T01234"
  }
}

What it unlocks: Read channel messages, post updates, check thread history. Useful for agents that need to stay in sync with team communication.

Troubleshooting Cursor MCP Issues

When in doubt: Remove the server from settings, restart Cursor, and re-add it. This clears cached schema state that can cause phantom issues.

The Token Math: Why MCP Has Limits

Every MCP server you add loads its tool schemas into Cursor's context window. A typical server adds 3,000–8,000 tokens.

On a 200K context window, five servers can consume up to 20% of the available space before the agent processes a single line of your code or context.

This is fine for a handful of internal integrations. It becomes a real constraint when you need many capabilities for complex workflows.

What MCP Doesn't Cover Well in Cursor

MCP server coverage is strong for internal systems (GitHub, databases, Slack, Notion). It's thinner for the capabilities most agent workflows eventually need:

• Image generation — no stable, production-grade MCP server covers multi-model image generation reliably
• Video generation — not covered via MCP in any meaningful way
• Cloud file storage — no consolidated MCP server for upload + public URL generation
• Web page publishing — not part of the MCP server ecosystem

For these capabilities, a capability runtime handles the gap more cleanly than stacking more servers.

# With AnyCap installed as a Cursor skill
anycap image generate "hero image for dashboard UI"
anycap search "latest React 19 breaking changes"
anycap drive upload ./build/assets/
anycap page publish ./dist/index.html

One CLI, one auth flow, no additional context-window overhead from tool schemas. The agent gets search, media, storage, and publishing without a separate MCP server for each.

See how that fits alongside your existing MCP setup: MCP Servers vs Capability Runtimes →

The Recommended Setup for Most Cursor Teams

Most production Cursor teams end up with a hybrid:

MCP servers for what they do best — narrow, specific, internal integrations:

• GitHub for repo operations
• PostgreSQL or SQLite for database access
• Notion or Confluence for internal docs

A capability runtime for the common cross-functional capabilities that MCP doesn't cover well:

• Web search with grounded citations
• Image and video generation
• File hosting and sharing
• Publishing outputs to a live URL

This split keeps your context budget reasonable while giving the agent everything it needs for real project work.

FAQ

Does Cursor support all MCP servers?

Cursor supports the full MCP specification. Any server that conforms to the protocol works in Cursor. Servers built for Claude Code or Windsurf generally work in Cursor without modification.

Is .cursor/mcp.json the same as .mcp.json in Claude Code?

Similar concept, different file location. Claude Code reads .mcp.json at the repo root. Cursor reads .cursor/mcp.json. If your team uses both tools, you'll need separate config files.

Can I use MCP servers in Cursor's regular chat mode or only in Agent Mode?

MCP server tools are primarily available in Cursor's Agent Mode (formerly Composer). Regular chat can reference your context but doesn't invoke external tool calls the same way.

Are there MCP servers for image or video generation?

A few experimental ones exist, but there's no production-grade MCP server for multi-model media generation with reliable quality and model selection. Teams that need media generation in their agent workflows typically use a capability runtime like AnyCap rather than a media-specific MCP server.

How do I know if a server is working correctly?

Open a Cursor Agent chat and ask directly: "What tools do you have available?" The agent will list the tools from all connected MCP servers. If a server is connected but tools are missing, the schema didn't load — restart Cursor.

Read Next

• What Is Model Context Protocol (MCP)? — Understand the protocol before configuring it.
• Cursor Image Generation Guide — Give Cursor the ability to generate images for your projects.
• Cursor Video Generation Guide — Add video generation to your Cursor agent workflows.
• MCP Servers vs Capability Runtimes — Where the protocol layer ends and the execution layer begins.