Best MCP Servers for Cursor/Claude 2026

The Model Context Protocol (MCP) has rapidly become the standard way to extend AI coding assistants with external capabilities. By connecting MCP servers to tools like Cursor, Claude Desktop, or Windsurf, you give your AI assistant the ability to browse the web, query databases, manage files, interact with APIs, and much more — all from within your development workflow.

This guide covers the best MCP servers available in 2026, organized by category. Whether you need web scraping, database access, cloud management, or specialized tooling, there is an MCP server that fits.

What Is MCP?
How to Install MCP Servers
Best Web Scraping MCP Servers
Best Database MCP Servers
Best File & Code MCP Servers
Best Cloud & DevOps MCP Servers
Best Communication MCP Servers
Best Productivity MCP Servers
Best Specialized MCP Servers
How to Choose MCP Servers
FAQ

What Is MCP?

The Model Context Protocol (MCP) is an open standard developed by Anthropic that allows AI assistants to interact with external tools and data sources. Think of it as a universal plugin system for AI — any MCP-compatible tool can use any MCP server.

How It Works

AI Assistant (Cursor/Claude) ←→ MCP Protocol ←→ MCP Server ←→ External Service

You configure an MCP server in your AI tool’s settings
The AI assistant discovers available tools from the server
When the AI needs to use a tool, it calls the MCP server
The server executes the action and returns results
The AI uses the results to continue its response

Compatible AI Tools

Tool	MCP Support
Cursor	Full support
Claude Desktop	Full support
Windsurf	Full support
Cline	Full support
Continue.dev	Full support
VS Code (with extensions)	Via plugins

How to Install MCP Servers

General Configuration

Most MCP servers use the same configuration pattern. Edit your tool’s MCP config file:

Cursor: ~/.cursor/mcp.json

Claude Desktop (macOS): ~/Library/Application Support/Claude/claude_desktop_config.json

Windsurf: ~/.windsurf/mcp.json

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "server-package-name"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

Installation Methods

Method	Command	Best For
npx	`npx -y package-name`	Quick setup, auto-updates
Global npm	`npm i -g package-name`	Reliable, fixed version
Docker	`docker run image`	Isolation, complex dependencies
uvx (Python)	`uvx package-name`	Python-based servers

Best Web Scraping MCP Servers

1. Firecrawl MCP

Best for: AI-powered web scraping with clean markdown output.

The Firecrawl MCP server connects Firecrawl’s powerful scraping engine to your AI assistant. Scrape pages, crawl sites, and extract structured data directly from your editor.

Tools provided: scrape, crawl, map, extract, batch_scrape

{
  "firecrawl": {
    "command": "npx",
    "args": ["-y", "firecrawl-mcp"],
    "env": {
      "FIRECRAWL_API_KEY": "fc-your-key"
    }
  }
}

Strengths: Best markdown output, JavaScript rendering, AI extraction, anti-bot handling

Cost: Free tier (500 credits/month), paid plans from $19/month

2. Browserbase MCP

Best for: Full browser automation with anti-detection.

Browserbase provides cloud browser instances. The MCP server gives your AI assistant control of a real browser — navigate, click, fill forms, and take screenshots.

Tools provided: navigate, screenshot, click, fill, evaluate

{
  "browserbase": {
    "command": "npx",
    "args": ["-y", "@browserbasehq/mcp-server"],
    "env": {
      "BROWSERBASE_API_KEY": "your-key",
      "BROWSERBASE_PROJECT_ID": "your-project-id"
    }
  }
}

Strengths: Full browser control, anti-detection, session recording

Cost: Paid plans

3. Puppeteer MCP

Best for: Free local browser automation.

The Puppeteer MCP server runs a local Chromium browser. No API keys or costs — everything runs on your machine.

Tools provided: navigate, screenshot, click, fill, evaluate, get_content

{
  "puppeteer": {
    "command": "npx",
    "args": ["-y", "@anthropic/mcp-puppeteer"]
  }
}

Strengths: Free, local, no API keys

Weaknesses: No anti-detection, requires local resources

4. Fetch MCP

Best for: Simple URL fetching without browser rendering.

The official Anthropic Fetch MCP server makes HTTP requests and converts HTML to markdown. Lightweight and fast, but doesn’t handle JavaScript rendering.

Tools provided: fetch

{
  "fetch": {
    "command": "npx",
    "args": ["-y", "@anthropic/mcp-fetch"]
  }
}

Strengths: Free, fast, no dependencies

Weaknesses: No JavaScript rendering, no anti-bot handling

5. Jina Reader MCP

Best for: Quick URL-to-markdown without configuration.

Uses Jina’s Reader API to convert web pages to clean markdown.

{
  "jina": {
    "command": "npx",
    "args": ["-y", "jina-reader-mcp"],
    "env": {
      "JINA_API_KEY": "your-key"
    }
  }
}

Strengths: Very simple, good markdown output

Cost: Free tier available

Best Database MCP Servers

6. PostgreSQL MCP

Best for: Querying PostgreSQL databases from your AI assistant.

{
  "postgres": {
    "command": "npx",
    "args": ["-y", "@anthropic/mcp-postgres", "postgresql://user:pass@host:5432/dbname"]
  }
}

Tools provided: query, list_tables, describe_table

7. Supabase MCP

Best for: Interacting with Supabase projects.

{
  "supabase": {
    "command": "npx",
    "args": ["-y", "supabase-mcp"],
    "env": {
      "SUPABASE_URL": "https://your-project.supabase.co",
      "SUPABASE_KEY": "your-key"
    }
  }
}

Tools provided: query, insert, update, rpc, list_tables

8. SQLite MCP

Best for: Local SQLite database operations.

{
  "sqlite": {
    "command": "npx",
    "args": ["-y", "@anthropic/mcp-sqlite", "/path/to/database.db"]
  }
}

9. Redis MCP

Best for: Redis cache and data store operations.

{
  "redis": {
    "command": "npx",
    "args": ["-y", "redis-mcp"],
    "env": {
      "REDIS_URL": "redis://localhost:6379"
    }
  }
}

Best File & Code MCP Servers

10. Filesystem MCP

Best for: File operations beyond what your AI tool provides natively.

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

Tools provided: read_file, write_file, list_directory, move_file, search_files

11. GitHub MCP

Best for: GitHub repository operations — issues, PRs, code search.

{
  "github": {
    "command": "npx",
    "args": ["-y", "@anthropic/mcp-github"],
    "env": {
      "GITHUB_TOKEN": "ghp-your-token"
    }
  }
}

Tools provided: create_issue, list_issues, create_pr, search_code, get_file_contents

12. Git MCP

Best for: Local git operations.

{
  "git": {
    "command": "npx",
    "args": ["-y", "@anthropic/mcp-git"]
  }
}

Tools provided: status, diff, log, commit, branch

Best Cloud & DevOps MCP Servers

13. AWS MCP

Best for: Managing AWS resources.

{
  "aws": {
    "command": "npx",
    "args": ["-y", "aws-mcp"],
    "env": {
      "AWS_ACCESS_KEY_ID": "your-key",
      "AWS_SECRET_ACCESS_KEY": "your-secret",
      "AWS_REGION": "us-east-1"
    }
  }
}

14. Docker MCP

Best for: Managing Docker containers and images.

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

Tools provided: list_containers, run_container, stop_container, build_image, logs

15. Kubernetes MCP

Best for: K8s cluster management and troubleshooting.

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

Best Communication MCP Servers

16. Slack MCP

Best for: Reading and sending Slack messages from your AI assistant.

{
  "slack": {
    "command": "npx",
    "args": ["-y", "@anthropic/mcp-slack"],
    "env": {
      "SLACK_BOT_TOKEN": "xoxb-your-token"
    }
  }
}

17. Gmail MCP

Best for: Reading and composing emails.

18. Linear MCP

Best for: Issue tracking and project management with Linear.

{
  "linear": {
    "command": "npx",
    "args": ["-y", "linear-mcp"],
    "env": {
      "LINEAR_API_KEY": "your-key"
    }
  }
}

Best Productivity MCP Servers

19. Notion MCP

Best for: Reading and writing to Notion databases and pages.

{
  "notion": {
    "command": "npx",
    "args": ["-y", "notion-mcp"],
    "env": {
      "NOTION_API_KEY": "your-key"
    }
  }
}

20. Google Sheets MCP

Best for: Reading from and writing to Google Sheets.

21. Google Calendar MCP

Best for: Calendar management and scheduling.

Best Specialized MCP Servers

22. Stripe MCP

Best for: Payment and subscription management.

{
  "stripe": {
    "command": "npx",
    "args": ["-y", "@stripe/mcp-server"],
    "env": {
      "STRIPE_SECRET_KEY": "sk-your-key"
    }
  }
}

23. Sentry MCP

Best for: Error monitoring and debugging.

24. Cloudflare MCP

Best for: Managing Cloudflare Workers, DNS, and CDN.

25. Playwright MCP

Best for: Advanced browser testing and automation.

{
  "playwright": {
    "command": "npx",
    "args": ["-y", "@anthropic/mcp-playwright"]
  }
}

Building Your Own MCP Server

If no existing server fits your needs, building one is straightforward.

TypeScript MCP Server

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "my-custom-server",
  version: "1.0.0",
}, {
  capabilities: { tools: {} }
});

// Define a tool
server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "my_tool",
    description: "Does something useful",
    inputSchema: {
      type: "object",
      properties: {
        query: { type: "string", description: "The search query" }
      },
      required: ["query"]
    }
  }]
}));

// Handle tool calls
server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "my_tool") {
    const query = request.params.arguments.query;
    // Your custom logic here
    return {
      content: [{ type: "text", text: `Result for: ${query}` }]
    };
  }
});

// Start the server
const transport = new StdioServerTransport();
await server.connect(transport);

Python MCP Server

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent

server = Server("my-custom-server")

@server.list_tools()
async def list_tools():
    return [
        Tool(
            name="my_tool",
            description="Does something useful",
            inputSchema={
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"}
                },
                "required": ["query"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "my_tool":
        query = arguments["query"]
        result = f"Result for: {query}"
        return [TextContent(type="text", text=result)]

async def main():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream)

import asyncio
asyncio.run(main())

When to Build vs Buy

Build your own when:

You need to connect to a proprietary internal service
Existing servers don’t expose the tools you need
You need custom security or access controls
You want to wrap a specific API for your team

Use existing servers when:

A maintained server exists for your service
You don’t want to maintain the server yourself
The existing server covers your use cases

How to Choose MCP Servers

Recommended Starter Stack

For most developers, start with this combination:

Server	Purpose
Firecrawl	Web scraping and documentation reading
GitHub	Repository management
Filesystem	File operations
PostgreSQL/SQLite	Database access

For Web Scraping Projects

Server	Use Case
Firecrawl	Clean markdown from any website
Puppeteer	Free local browser automation
Fetch	Quick HTTP requests

For proxy integration with these tools, see our web scraping proxy guide.

For Data Engineering

Server	Use Case
PostgreSQL	Query production databases
Redis	Cache operations
AWS	Cloud resource management
Firecrawl	External data ingestion

Performance Considerations

Each MCP server runs as a separate process
Running many servers increases memory usage
Only enable servers you actively use
Some servers (Puppeteer, Playwright) are resource-intensive due to browser instances

FAQ

How many MCP servers can I run simultaneously?

There is no hard limit, but each server is a separate process. Running 5-10 servers is typical and works well. Beyond that, monitor your system’s memory usage. Most lightweight servers (Fetch, GitHub, database) use minimal resources.

Are MCP servers secure?

MCP servers run locally and connect to external services using credentials you provide. Treat your MCP config file like any other credential file — don’t commit it to public repositories. Some servers support read-only modes for added safety.

Do MCP servers cost money?

Many MCP servers are free and open source (Fetch, Filesystem, Git, Puppeteer). Servers that connect to paid services (Firecrawl, Browserbase, Stripe) depend on those services’ pricing. The MCP protocol itself is free.

Can I build my own MCP server?

Yes. The MCP SDK is available for TypeScript and Python. Building a custom MCP server is straightforward — define your tools, implement handlers, and connect them to your service. See the MCP documentation for details.

Which AI tool has the best MCP support?

Cursor and Claude Desktop both have excellent MCP support. Cursor is best for coding workflows, while Claude Desktop is better for general-purpose tasks. Windsurf and Cline are strong alternatives. All support the same MCP servers — the choice depends on your preferred editor and workflow.