Best MCP Servers for Cursor (2026)

What is Cursor?

Cursor is a popular AI-powered code editor built on top of VS Code. It adds deep AI integration directly into the editing experience, with features like AI-powered autocomplete, inline editing, and a chat panel that understands your codebase. Cursor supports the Model Context Protocol (MCP), which allows you to extend its AI capabilities with external tools, file system access, database connections, GitHub integration, and any custom tooling you build.

How MCP Works with Cursor

Cursor reads MCP server configurations from a .cursor/mcp.json file in your project root. When you open a project with this file, Cursor automatically starts the configured MCP servers and makes their tools available in both the Chat panel and Composer. The AI can then use these tools to fetch data, run queries, interact with APIs, and perform actions on your behalf.

Because the config file lives in your project directory, it is easy to commit it to version control so your entire team shares the same MCP setup. This is one of Cursor's biggest advantages over clients like Claude Desktop that use a global configuration.

Detailed Setup Process

1. Install Cursor from cursor.sh. Cursor is available on macOS, Windows, and Linux.
2. Open your project in Cursor.
3. Create the config directory: In your project root, create a .cursor directory if it does not already exist.
4. Create .cursor/mcp.json with your MCP server definitions. The file uses an mcpServers object where each key is a server name and the value is its configuration.
5. Save the file. Cursor detects changes to .cursor/mcp.json automatically - no restart needed in most cases.
6. Open the Chat panel (Cmd+L on macOS, Ctrl+L on Windows/Linux) and verify that your MCP servers appear in the available tools list. You can see connected servers by clicking the tools icon.
7. Start using the AI - ask questions or give instructions that require your MCP tools, and Cursor's AI will use them automatically.

Advanced Configuration

Project-Level vs. Global Configuration

Cursor primarily uses project-level configuration via .cursor/mcp.json. This means different projects can have completely different MCP server setups. For global configuration that applies to all projects, you can place an mcp.json file in your Cursor user settings directory. Project-level settings take precedence when both exist.

Environment Variables

Use the env field in each server configuration to pass environment variables like API keys and tokens. For team projects, consider using a .cursor/mcp.json that references environment variable names, and have each developer set those variables in their shell profile. This avoids committing secrets to version control while still sharing the server configuration.

Transport Options

Cursor supports both stdio and SSE transport types. For stdio servers (the most common), specify command and args. For SSE servers, specify a url field. SSE transport is useful for connecting to remote or shared MCP servers that run as HTTP services.

Composer and Chat Integration

MCP tools are available in both Cursor's Chat panel and Composer. In Chat, the AI uses tools to answer questions and perform lookups. In Composer, tools are used as part of multi-step coding workflows where the AI might need to query a database schema before generating code, or check a GitHub issue before implementing a fix.

Troubleshooting Common Issues

• "No MCP servers detected" - Verify that .cursor/mcp.json is in the root of your opened project, not a subdirectory. Check that the JSON is valid using a linter.
• "Server failed to start: ENOENT" - The command specified in your config was not found. Ensure npx, node, or the specified binary is in your PATH. Try running the command in Cursor's integrated terminal to confirm.
• "Server connected but no tools available" - The server started but is not exposing any tools. This can happen if the server requires additional setup (like database credentials) or if the server version is incompatible. Check the server's logs in Cursor's Output panel (select "MCP" from the dropdown).
• Tools work in Chat but not in Composer - Ensure you are using a Cursor version that supports MCP in Composer. Update Cursor to the latest version if needed.
• Config changes not detected - While Cursor usually auto-detects config changes, sometimes a reload is needed. Use the Command Palette (Cmd+Shift+P) and run "Developer: Reload Window".

Recommended MCP Servers

Cursor works well with all standard MCP servers. These are particularly useful for code editor workflows:

• Filesystem Server - Extended file operations beyond what Cursor provides natively, useful for complex file manipulation tasks.
• GitHub Server - Manage issues, pull requests, and code reviews without leaving the editor.
• PostgreSQL Server - Query databases while coding, perfect for backend development where you need to check schemas and test queries.
• Brave Search Server - Research documentation, find code examples, and look up error messages from within Cursor.
• Memory Server - Store project context, coding decisions, and preferences that persist across sessions.

Explore our full MCP server directory for more options.

Related Guides

For a comprehensive comparison of MCP setup across editors, read our MCP Servers for Cursor, VS Code, and Claude guide. Our tutorials section has step-by-step guides for specific server configurations.

Performance Tips

• Keep your server list focused. Configure only the servers you actively use for the current project. Each server consumes resources and adds to startup time.
• Use globally installed packages instead of npx -y for frequently used servers. This eliminates the package resolution step: npm install -g @modelcontextprotocol/server-filesystem.
• Monitor server health through Cursor's Output panel. Select "MCP" from the output channel dropdown to see server logs and detect issues early.
• Restart individual servers when needed rather than reloading the entire window. Some servers can be restarted through Cursor's MCP management interface.
• Use stdio transport for local servers to minimize latency. SSE adds HTTP overhead that is unnecessary for local communication.

Security Considerations

MCP servers in Cursor run as local processes with your user permissions. Keep these practices in mind:

• Review what you commit. If your .cursor/mcp.json contains API keys, add it to .gitignore. Better yet, use environment variables and only commit the config structure without secrets.
• Scope filesystem access. When using the filesystem server, point it at the specific project directory rather than broad paths like your home directory.
• Vet third-party servers. Only use MCP servers from trusted sources. Review source code for servers that access sensitive data like databases or API credentials.
• Approve tool calls. Cursor shows you what the AI wants to do before executing MCP tool calls. Review these requests, especially for servers that can modify data or make network requests.
• Read our MCP Server Security Guide for comprehensive security best practices.

Comparing Cursor with Other Clients

Cursor is ideal if you want an AI-first IDE with deep code understanding and MCP integration. For a lightweight terminal experience, consider Claude Code CLI. If you prefer the broader VS Code extension ecosystem, check out VS Code with GitHub Copilot. For an autonomous agent approach within VS Code, try Cline. All these clients support the same MCP servers with slightly different configuration formats.