15 Best MCP Servers You Can Add to Cursor For 10x Productivity

It is funny how fast new trends are emerging in AI. It took the concept of Model Context Protocol (MCP) just four months to evolve from an initial idea to a mainstream development standard everybody is raving about. Well, let me be part of that fully deserved hype and present to you my best MCP finds you can add to your IDE (Cursor, Windsurf, Cline, etc.). But before we do that, let’s touch on important terms around MCP that might leave you confused if you are just getting started.

At the foundation is the protocol itself - a standardized communication system that enables seamless interaction between AI models and data sources. The MCP protocol:

• Uses lightweight JSON-RPC 2.0 for message exchange
• Defines standard formats for requests, responses, and errors
• Creates a universal “language” for AI systems to communicate with various tools
• Handles security, authentication, and data formatting

The protocol supports multiple transport mechanisms, including standard input/output (stdio) for local processes and HTTP with Server-Sent Events for web-based communication. All messages follow specific formats for requests (which expect responses), results (successful responses), errors (failed requests), and notifications (one-way messages).

Think of this as a universal adapter or language that allows different systems to understand each other, similar to how USB-C created a standard for charging various devices.

Building on the protocol, MCP servers are specialized programs that expose specific data sources or tools through the standardized protocol. Each server:

• Provides access to a particular resource (GitHub, Google Drive, databases, etc.)
• Authenticates and processes incoming requests
• Translates general requests into specific actions for its data source
• Returns formatted results that follow the protocol standards

Anthropic has released pre-built MCP servers for popular systems like Google Drive, Slack, GitHub, Git, Postgres, and Puppeteer. This means developers don’t need to create these integrations from scratch. Each server excels at handling its specific data type while speaking the same protocol language.

For example, a database MCP server might receive a request for sales data, translate it into SQL, execute the query, and return the results in a standardized format that any MCP client can understand.

Leveraging both the protocol and servers, MCP clients are the AI applications that need to access external data. These clients:

• Connect directly to servers using the protocol
• Send standardized requests for information or actions
• Process the responses from servers
• Maintain separate connections with different servers for various data needs

Each client maintains a one-to-one connection with specific servers. When you ask Claude (an MCP client) to retrieve sales data, it sends a query to the appropriate MCP server using the protocol. The client then processes the results it receives to provide you with a coherent answer.

Clients are like apps on your phone that need data from different sources but use a standard way to request and receive that information.

At the top level, MCP hosts are the applications that bring everything together. A host:

• Acts as a container and coordinator for multiple MCP clients
• Manages user authentication and authorization
• Coordinates communication between components
• Provides the environment where clients operate

Examples of hosts include Claude Desktop, development environments like Cursor, Zed, Replit, and other AI-powered tools. These applications create the framework where clients can connect to various servers.

Now that we understand the key concepts behind Model Context Protocol, let’s explore some essential resources that will help you get started with MCP. Whether you’re looking to implement servers, build clients, or just learn more about the protocol, these resources can serve as references you can visit time and again.

1. Official MCP documentation

The official MCP website is your starting point for all things related to the protocol. Here you’ll find comprehensive documentation about the architecture, detailed specifications, and guides for implementing both clients and servers. The site includes clear explanations of core concepts and step-by-step tutorials for developers at all experience levels.

2. Ready-to-use example servers

The examples page from the official website showcases tested and reliable MCP servers that you can start using immediately. These examples demonstrate best practices for server implementation and cover popular use cases like accessing databases, file systems, and web APIs. Each example includes documentation and source code, making it easy to understand how they work or modify them for your needs.

3. Community-curated MCP servers

For a broader collection of MCP servers beyond the official examples and the ones I will present below, check out the awesome-mcp-servers GitHub repository. This community-maintained list features servers for various data sources and tools, ranging from simple implementations to complex enterprise solutions. The repository is regularly updated as new servers are developed, making it a valuable resource for finding the right server for your specific requirements.

4. Explore available MCP clients

If you’re interested in what clients are available or want to see how others have implemented MCP client functionality, the awesome-mcp-clients repository provides a comprehensive list. This collection showcases different approaches to building MCP clients across various programming languages and frameworks. Examining these implementations can give you insights into best practices and common patterns.

Now that we’ve explored the essential resources for Model Context Protocol, let’s put this knowledge into practice. While we’ll focus on installing MCP servers in Cursor, the process follows similar patterns for other compatible hosts like Cline, Windsurf, or Claude Desktop.

Before adding MCP servers, you’ll need to ensure you have the necessary tools installed, as most MCP servers depend on either Node.js (with npx) or Python (with UV).

For Windows:

1. Download the Node.js installer from nodejs.org
2. Run the installer and follow the installation wizard
3. npx comes bundled with Node.js, so no separate installation is needed
4. Verify installation by opening Command Prompt and typing:

node --version
npx --version

For macOS:

1. Using Homebrew (recommended):

brew install node

2. Alternatively, download the macOS installer from nodejs.org
3. Verify installation in Terminal:

node --version
npx --version

For Windows:

1. Download and install Python from python.org
2. Open Command Prompt and install UV:

pip install uv

3. Verify installation:

uv --version

For macOS:

1. Using Homebrew:

brew install python
pip3 install uv

2. Verify installation:

uv --version

Cursor supports two main approaches for configuring MCP servers, depending on whether you want the servers available for a specific project or globally across all your work.

You can place MCP configurations in one of two locations:

1. Project configuration: Create a .cursor/mcp.json file in your project directory to define MCP servers that should only be available within that specific project.

2. Global configuration: Create a ~/.cursor/mcp.json file in your home directory to make MCP servers available across all your Cursor workspaces.

Cursor supports two transport types for MCP servers:

1. stdio Transport - Runs locally on your machine and is managed automatically by Cursor:

   • Communicates directly via stdout
   • Only accessible by you locally
   • Requires a valid shell command that Cursor will run automatically

2. SSE Transport - Can run locally or remotely:

   • Managed and run by you
   • Communicates over the network
   • Can be shared across machines
   • Requires a URL to the /sse endpoint of an MCP server

The MCP configuration file uses a JSON format. Here’s the basic structure:

{
  "mcpServers": {
    "server-name": {
      "command": "command-to-run",
      "args": ["arg1", "arg2"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

For example, to configure a Node.js-based MCP server:

{
  "mcpServers": {
    "github-tools": {
      "command": "npx",
      "args": ["-y", "mcp-github"],
      "env": {
        "GITHUB_TOKEN": "your-github-token"
      }
    }
  }
}

For Python-based MCP servers:

{
  "mcpServers": {
    "database-query": {
      "command": "uv",
      "args": ["run", "python", "-m", "mcp_database_tool"],
      "env": {
        "DB_CONNECTION_STRING": "your-connection-string"
      }
    }
  }
}

For SSE servers, you would specify the URL:

{
  "mcpServers": {
    "remote-service": {
      "url": "http://example.com:8000/sse"
    }
  }
}

If you’re having trouble with the configuration methods above, you can use an alternative approach through Cursor’s built-in MCP Server settings interface. This method simplifies the process by using a shell script to manage environment variables and execution - particularly useful when troubleshooting or when you need more control over how the server runs.

The example below demonstrates how to set up the Tavily search API integration, but the same pattern works for any MCP server:

1. Create a shell script (e.g., script.sh) with the following content:

#!/bin/bash
TARGET_DIR=/path/to/your-server-directory
cd "${TARGET_DIR}"
export API_KEY="your-api-key"
export PYTHONIOENCODING=utf-8
uv --directory $PWD run your-server-command

This script:

• Sets a target directory where your server code or dependencies live
• Changes to that directory
• Exports necessary environment variables (like API keys)
• Ensures proper encoding for Python output
• Runs the server command in the correct directory context

2. Make the script executable:

chmod +x script.sh

3. Configure Cursor’s MCP Server settings as follows:

   • Name: your-service-name
   • Type: command
   • Command: /path/to/your/script.sh

4. Save the settings.

5. Once saved, you can ask Cursor’s Composer-Agent to use your new tool by mentioning it specifically in your prompts.

After configuration, the Composer Agent will automatically use any MCP tools that are listed under “Available Tools” on the MCP settings page when it determines them to be relevant. To explicitly prompt a tool’s usage, simply tell the agent to use the tool by name or description.

By default, when the Agent wants to use an MCP tool, it will display a message asking for your approval. You can expand the message to see what arguments the Agent is calling the tool with.

If you prefer automatic execution without approval prompts, you can enable “Yolo mode” in Cursor’s settings, which allows the Agent to run MCP tools without requiring explicit approval for each use.

When a tool is used successfully, Cursor will display the response in the chat, showing both the tool call arguments and the tool call response.

With these configurations in place, you’ll be able to leverage the power of MCP servers to extend Cursor’s capabilities and integrate with your existing tools and data sources.

Now, without further ado, let’s explore some of the best servers the MCP community has to offer.

The Firecrawl MCP server is a comprehensive web scraping solution that enhances your development workflow by providing direct access to web content within your IDE. With over 1.8k stars on GitHub, it has quickly become one of the most popular MCP servers available.

Firecrawl empowers developers to extract structured data from websites without leaving their coding environment. This is particularly valuable when you need to:

• Research competitors’ products or services
• Gather data for machine learning projects
• Extract information from documentation sites
• Monitor content changes across multiple websites
• Convert web content into usable formats like markdown

The server offers several specialized tools:

• Basic scraping: Extract content from any URL with customizable formats
• Batch scraping: Process multiple URLs efficiently with built-in rate limiting
• Search: Query the web and extract content from search results
• Crawling: Perform deep crawls with configurable depth and domain constraints
• Structured extraction: Pull specific data from websites using intelligent parsing

To add Firecrawl to your Cursor setup, first get an API key from firecrawl.dev, then add the following to your .cursor/mcp.json file:

{
  "mcpServers": {
    "firecrawl": {
      "command": "npx",
      "args": ["-y", "@firecrawl/mcp-server"],
      "env": {
        "FIRECRAWL_API_KEY": "your_api_key_here"
      }
    }
  }
}

Once configured, you can ask Cursor’s Agent to perform web research tasks like “Use Firecrawl to research the latest React features” or “Scrape product information from these websites.”

The Browserbase MCP server brings powerful cloud browser automation capabilities directly into your development environment. It allows you to interact with websites programmatically, handling complex scenarios like JavaScript-rendered content, login systems, and dynamic page elements.

Developers find this server particularly useful when:

• Testing web applications across different scenarios
• Automating repetitive website interactions
• Capturing visual representation of web elements
• Extracting data from JavaScript-heavy sites
• Debugging client-side issues

Browserbase provides several specialized tools:

• Session management: Create and control browser sessions
• Navigation: Visit and interact with websites
• Screenshots: Capture full-page or element-specific images
• DOM interaction: Click elements and fill forms
• JavaScript execution: Run custom scripts in the browser context
• Content extraction: Pull visible content from rendered pages
• Parallel sessions: Work with multiple browser instances simultaneously

To add Browserbase to Cursor, first obtain API credentials from browserbase.io, then add the following configuration to your .cursor/mcp.json file:

{
  "mcpServers": {
    "browserbase": {
      "command": "node",
      "args": ["path/to/mcp-server-browserbase/browserbase/dist/index.js"],
      "env": {
        "BROWSERBASE_API_KEY": "your_api_key_here",
        "BROWSERBASE_PROJECT_ID": "your_project_id_here"
      }
    }
  }
}

After configuration, you can prompt Cursor to “Take a screenshot of the website” or “Use Browserbase to test the login flow on my application.”

The Magic MCP server brings generative AI capabilities directly into your development environment. This versatile MCP server enables you to generate images, run text transformations, and perform other AI-powered operations without switching contexts.

Developers find Magic MCP valuable when:

• Creating placeholder images during front-end development
• Generating illustrations for documentation
• Transforming text into various formats or styles
• Summarizing content for documentation
• Creating code samples from natural language descriptions

To add Magic MCP to your Cursor setup, add the following to your .cursor/mcp.json file:

{
  "mcpServers": {
    "magic": {
      "command": "npx",
      "args": ["-y", "@21st/magic-mcp"],
      "env": {
        "OPENAI_API_KEY": "your_openai_api_key_here"
      }
    }
  }
}

You’ll need an OpenAI API key, which you can obtain from the OpenAI platform.

The Opik MCP server integrates experiment tracking capabilities directly into your development environment, powered by Comet ML. This server helps data scientists and machine learning engineers manage, visualize, and track their ML experiments without leaving their coding context.

This server is particularly useful when:

• Working on machine learning projects
• Tracking model training metrics
• Comparing different experiment runs
• Visualizing model performance
• Collaborating with team members on ML projects

To add Opik to your Cursor configuration, first create an account on Comet ML, then add the following to your .cursor/mcp.json file:

{
  "mcpServers": {
    "opik": {
      "command": "npx",
      "args": ["-y", "@comet-ml/opik-mcp"],
      "env": {
        "COMET_API_KEY": "your_comet_api_key_here"
      }
    }
  }
}

The Figma Context MCP server bridges the gap between your design assets in Figma and your development environment. This integration allows developers to create, access, view, and analyze Figma designs directly within Cursor.

This server is invaluable when:

• Implementing designs from Figma
• Checking design specifications and measurements
• Extracting color schemes and typography details
• Understanding component relationships
• Ensuring design consistency during development

To add Figma Context to your setup, first generate a Figma personal access token from your Figma account settings, then add this configuration to your .cursor/mcp.json file:

{
  "mcpServers": {
    "figma": {
      "command": "npx",
      "args": ["-y", "figma-context-mcp"],
      "env": {
        "FIGMA_ACCESS_TOKEN": "your_figma_token_here"
      }
    }
  }
}

The Pandoc MCP server integrates the powerful document conversion capabilities of Pandoc directly into your development environment. This server allows you to transform documents between various formats without switching context.

Developers find this tool especially useful when:

• Converting markdown files to PDF, HTML, DOCX, or other formats
• Creating documentation in multiple output formats
• Processing academic papers or research notes
• Generating reports from different source materials
• Building publishing workflows

To add Pandoc MCP to your Cursor setup, first ensure Pandoc is installed on your system, then add the following to your .cursor/mcp.json file:

{
  "mcpServers": {
    "pandoc": {
      "command": "npx",
      "args": ["-y", "mcp-pandoc"]
    }
  }
}

The Excel MCP server enables direct interaction with Excel spreadsheets from within your development environment. This integration allows you to read, modify, and analyze Excel files without switching applications.

This server becomes particularly valuable when:

• Processing data stored in Excel spreadsheets
• Generating reports based on spreadsheet data
• Creating or modifying Excel files programmatically
• Performing data analysis on tabular data
• Building data import/export functionality

To add the Excel MCP server to your Cursor configuration, add this to your .cursor/mcp.json file:

{
  "mcpServers": {
    "excel": {
      "command": "npx",
      "args": ["-y", "excel-mcp-server"]
    }
  }
}

The Mindmap MCP server brings concept visualization capabilities directly into your development environment. This tool helps developers organize ideas, plan features, and visualize complex relationships without context switching.

This server proves especially useful when:

• Planning new feature development
• Organizing project architecture
• Creating concept maps for documentation
• Brainstorming solutions to complex problems
• Visualizing data relationships

To add the Mindmap MCP server to your Cursor setup, add the following to your .cursor/mcp.json file:

{
  "mcpServers": {
    "mindmap": {
      "command": "npx",
      "args": ["-y", "mindmap-mcp-server"]
    }
  }
}

The Markdownify MCP server enables conversion of various content formats into clean, structured markdown. This tool helps developers transform HTML, text, and other formats into markdown without leaving their coding environment.

This server is particularly valuable when:

• Converting HTML content to markdown
• Cleaning up documentation
• Standardizing content formats
• Preparing content for GitHub or other markdown-based platforms
• Creating blog posts or technical articles

To add Markdownify to your Cursor configuration, add this to your .cursor/mcp.json file:

{
  "mcpServers": {
    "markdownify": {
      "command": "npx",
      "args": ["-y", "markdownify-mcp"]
    }
  }
}

The Filesystem MCP server provides advanced file system operations directly within your development environment. This official MCP server from the Model Context Protocol team enables you to perform various file operations beyond what’s available in the standard editor.

Developers find this tool particularly useful when:

• Working with files outside the current project
• Processing large numbers of files programmatically
• Searching and filtering files based on complex criteria
• Analyzing file metadata and statistics
• Performing batch file operations

To add the Filesystem MCP server to Cursor, add the following to your .cursor/mcp.json file:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@mcp/filesystem"]
    }
  }
}

The Google Drive MCP server integrates Google Drive capabilities directly into your development environment. This official MCP server allows you to access, search, and manipulate files stored in Google Drive without switching context.

This server becomes especially valuable when:

• Accessing documentation stored in Google Drive
• Incorporating content from shared Google documents
• Managing project assets stored in the cloud
• Collaborating on files with team members
• Automating file operations between local and cloud storage

To add the Google Drive MCP server to your Cursor setup, first create OAuth credentials from the Google Cloud Console, then add this configuration to your .cursor/mcp.json file:

{
  "mcpServers": {
    "gdrive": {
      "command": "npx",
      "args": ["-y", "@mcp/gdrive"],
      "env": {
        "GOOGLE_CLIENT_ID": "your_client_id_here",
        "GOOGLE_CLIENT_SECRET": "your_client_secret_here"
      }
    }
  }
}

The Brave Search MCP server brings Brave’s privacy-focused search capabilities directly into your development environment. This official MCP server allows you to perform web searches while respecting privacy concerns.

This server is particularly useful when:

• Researching technical topics while coding
• Finding reference materials or documentation
• Exploring solutions to programming problems
• Gathering information for development tasks
• Conducting research with enhanced privacy

To add the Brave Search MCP server to Cursor, first obtain an API key from the Brave Search API portal, then add the following to your .cursor/mcp.json file:

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@mcp/brave-search"],
      "env": {
        "BRAVE_API_KEY": "your_brave_api_key_here"
      }
    }
  }
}

The Tavily MCP server integrates AI-powered search capabilities directly into your development environment. This server leverages Tavily’s search API to provide intelligent, contextually-aware search results.

Developers find this tool particularly valuable when:

• Researching technical topics with AI assistance
• Finding relevant documentation for specific problems
• Gathering information for development decisions
• Exploring solutions with semantic understanding
• Conducting comprehensive research on complex topics

To add the Tavily MCP server to your Cursor setup, first obtain an API key from Tavily’s website, then add this configuration to your .cursor/mcp.json file:

{
  "mcpServers": {
    "tavily": {
      "command": "npx",
      "args": ["-y", "mcp-server-tavily"],
      "env": {
        "TAVILY_API_KEY": "your_tavily_api_key_here"
      }
    }
  }
}

The DuckDuckGo MCP server brings privacy-focused search capabilities directly into your development environment. This integration allows you to perform web searches without tracking while staying within your coding context.

This server is especially useful when:

• Researching programming topics privately
• Finding documentation without tracking
• Gathering reference materials for development
• Exploring solutions to technical problems
• Conducting research with enhanced privacy protection

To add the DuckDuckGo MCP server to your Cursor configuration, add this to your .cursor/mcp.json file:

{
  "mcpServers": {
    "duckduckgo": {
      "command": "npx",
      "args": ["-y", "duckduckgo-mcp-server"]
    }
  }
}

The FastMCP framework enables rapid development and integration of custom MCP servers. While not a traditional MCP server itself, this tool allows developers to quickly create their own specialized servers with minimal boilerplate code.

This framework becomes particularly valuable when:

• Building custom MCP servers for specific APIs
• Creating integrations with internal tools
• Developing specialized data access patterns
• Prototyping new MCP server capabilities
• Extending Cursor with organization-specific functionality

To use FastMCP for developing your own MCP servers, install it as a dependency in your project:

npm install fastmcp

Then, create your custom MCP server using the FastMCP framework:

import { FastMCP } from 'fastmcp';

const app = new FastMCP();

app.addTool('my_custom_tool', async (args) => {
  // Your tool implementation here
  return { result: 'Success!' };
});

app.start();

To add your custom FastMCP server to Cursor, configure your .cursor/mcp.json file to point to your implementation:

{
  "mcpServers": {
    "my-custom-server": {
      "command": "node",
      "args": ["path/to/your/server.js"]
    }
  }
}

Model Context Protocol servers are an exciting new development workflow optimization. By utilizing these tools right in your coding environment, you can greatly reduce constant context switching to various applications to access relevant materials in your daily workflow. Each MCP server serves a specific need in the development workflow, such as data retrieval, document conversion, searching, and visualization capabilities. All types of MCP server configuration follows a similar process, which means you can quickly build up your workflow as you discover what works for shared or individual development approaches.

For developers who are not yet using an MCP server, Firecrawl is a pragmatic starting point because it has a large documentation base for learning, and an active development community. The use of web scraping relates to a data gathering scenario that most, if not all, development teams experience throughout their work. To deploy Firecrawl, follow the link to the GitHub repository, confirm the installation instructions discussed earlier, and get an API key from the Firecrawl website. This basic setup will allow you to begin realizing the benefits of MCP servers before searching for more specific tools for your development needs.