Best MCP Servers 2026: Top 25 for Developers

MCP (Model Context Protocol) is an open standard for connecting AI assistants to external tools — one protocol instead of hundreds of custom integrations. As of mid-2026: 10,000+ public servers, 97 million SDK installs a month, and support across Claude Code, Cursor, VS Code, ChatGPT, Gemini, and dozens of other clients.

The protocol is governed by the Linux Foundation through the Agentic AI Foundation (AAIF) — an open standard with no single-vendor lock-in. An MCP server written for one client works in any compatible client, as long as that client supports the required protocol version and transports. Write a server for GitHub, and it works in Claude Code, Cursor, and ChatGPT alike.

This article is a catalog of the 25 best MCP servers by category. Each entry includes the install command, a description of what it does, and a recommendation for when to use it. No filler, no ads.

If you’re not familiar with MCP yet, start with MCP servers: what they are, why you need them, and how to connect one. It covers the architecture, connection methods, and writing your own server.

How to connect an MCP server

Two ways to connect.

Via CLI (Claude Code):

claude mcp add server-name -- npx -y @scope/package

Via .mcp.json (Claude Code, Cursor, VS Code):

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    }
  }
}

The .mcp.json file lives in the project root (project-level) or in ~/.claude/ (globally). Project-level servers load only for that specific project — this is the recommended approach.

For remote MCP servers (Supabase, Figma, Linear), you just point to the endpoint URL. The client connects directly — no local install needed.

Code and Development

1. GitHub

The official MCP server from GitHub. Gives full API access: repositories, issues, pull requests, code search, files, branches, commits. Claude searches code across the whole org, opens PRs, comments on issues, and manages releases straight from the IDE.

docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN ghcr.io/github/github-mcp-server

Requires GITHUB_PERSONAL_ACCESS_TOKEN. The original npm package @modelcontextprotocol/server-github has been deprecated since April 2025 — development moved to github/github-mcp-server (a Go binary). The ghcr.io/github/github-mcp-server Docker image is the recommended path.

Scenario: “find all open issues labeled bug in repo X and open a PR fixing the oldest one.” The GitHub MCP server closes the whole loop — from finding the issue to opening the pull request.

Use it for: repository management, PR and issue automation, org-wide code search.

2. GitLab

An MCP server for GitLab — the GitHub server’s counterpart for teams on GitLab. Manages merge requests, issues, pipelines, wikis, releases. Supports self-hosted instances and gitlab.com.

npx -y @modelcontextprotocol/server-gitlab

@modelcontextprotocol/server-gitlab is the original package. For more advanced scenarios (80+ tools, CQRS, OAuth 2.1), the community’s gitlab-mcp is the option. Requires GITLAB_PERSONAL_ACCESS_TOKEN and GITLAB_API_URL for self-hosted setups.

Use it for: the same tasks as GitHub, but for GitLab infrastructure.

3. Sentry

The official MCP server from Sentry. Gives Claude access to errors, traces, and events. Analyzes stack traces, spots patterns, and suggests fixes based on real production data.

Remote endpoint (recommended):

https://mcp.sentry.dev/mcp

For Claude Code:

claude mcp add --transport http sentry https://mcp.sentry.dev/mcp

Locally via stdio:

npx -y @sentry/mcp-server

Works as a remote MCP with OAuth authentication — Sentry hosts and manages the server. Supports both Sentry Cloud and self-hosted.

Ask “show me the last 5 production errors and suggest a fix” — the AI sees the stack trace, finds the problematic code in your project, and proposes a fix right in the IDE.

Use it for: debugging production errors, stack trace analysis, catching regressions.

4. Linear

An MCP server for Linear — manage tasks, projects, cycles, and teams straight from an AI assistant. Create and update issues, search across projects, add comments.

Linear provides a centrally hosted MCP server — nothing to install. Connect via the remote endpoint.

For local use:

npx -y @tacticlaunch/mcp-linear

Scenario: “pick up the task from Linear, implement it, open a PR on GitHub, and update the task status.” With Linear + GitHub servers connected, the whole loop runs without switching context — the same kind of handoff chain described in a practical guide to multi-agent architecture.

Use it for: managing tasks from Claude Code/Cursor without switching over to Linear.

5. Context7

An MCP server from Upstash. Solves the biggest problem in AI coding — stale documentation — by pulling current, version-specific library docs straight into context.

npx -y @upstash/context7-mcp@latest

No API key needed. Supports thousands of libraries: React, Next.js, Prisma, Tailwind, Django, FastAPI. Add “use context7” to your prompt and the server pulls in the relevant docs.

Without Context7, the model might answer based on the Pages Router when you’re asking about the App Router. With Context7, you always get the current version.

Use it for: real-time, up-to-date library documentation and cutting down hallucinations when working with APIs.

---

Databases

6. PostgreSQL

The official MCP server for PostgreSQL. Claude runs SQL queries, inspects schemas, analyzes data. Read-only by default — safe for production.

npx -y @modelcontextprotocol/server-postgres postgresql://user:pass@localhost:5432/db

Accepts a standard PostgreSQL connection string. Works with AWS RDS, Supabase, Neon, Crunchy, or a local database. The official reference server has moved to servers-archived, but the package still works — and remains the most widely used option for PostgreSQL.

Scenario: “show me the top 10 customers by order count over the last month, and explain which indexes would speed up the query.” The AI runs the query, checks the execution plan, and gives recommendations.

Use it for: data analysis, query debugging, database schema inspection.

7. Supabase

The official Supabase MCP server. Full BaaS access: project management, creating tables and migrations, SQL queries, edge functions, logs, database branching. Hosted remotely — nothing to install.

Remote endpoint: https://mcp.supabase.com/mcp (OAuth, automatic browser login).

For Claude Code:

claude mcp add supabase --transport http https://mcp.supabase.com/mcp

Authenticates via OAuth: the MCP client automatically opens a browser to log in. Supports database branching — you can experiment with schema changes without risking production.

Use it for: managing Supabase projects from an AI assistant — migrations, queries, deploying edge functions, viewing logs.

8. SQLite

An MCP server for working with local SQLite databases. Creates tables, runs SQL queries, manages schema. Handy for prototyping and analysis — the AI creates a database, populates it with data, and runs analysis in a single session.

npx -y @modelcontextprotocol/server-sqlite path/to/database.sqlite

The official server from the MCP team. Takes the database file path as an argument. Supports both read-only and read-write modes.

Use it for: prototyping, local analytics, working with SQLite databases without a GUI.

9. Redis

The official MCP server from Redis. Manages keys, runs commands, works with hashes, lists, sets. A natural-language interface to Redis.

npx -y @redis/mcp-server

Two projects from Redis: mcp-redis (self-hosted) and mcp-redis-cloud (Redis Cloud). Supports all standard Redis operations.

Use it for: debugging cache behavior, analyzing data in Redis, managing a key-value store.

---

Search and Data

10. Brave Search

The official MCP server for the Brave Search API. Web search, local search, news — the AI gets access to current information from the internet.

npx -y @brave/brave-search-mcp-server

Requires BRAVE_API_KEY (free tier: 2,000 requests/month). Supports web search, image search, news, and local results. The @brave/brave-search-mcp-server package is the official one from Brave Software; the older @modelcontextprotocol/server-brave-search has been archived.

One of the most useful servers for everyday work. Without it, the AI only has its training data to go on. With Brave Search, it can check current documentation, find real examples, and learn about the latest API changes.

Use it for: web search from an AI assistant, researching technologies, verifying current information.

11. Exa

An MCP server from Exa — semantic search across the web. Unlike keyword search (Brave), Exa searches by meaning: it finds relevant articles, documents, and data even for fuzzy queries. It also extracts content from pages.

npx -y exa-mcp-server

Requires EXA_API_KEY (dashboard.exa.ai). Also available as a remote endpoint: https://mcp.exa.ai/mcp. Supports search across academic papers, companies, and content.

Use it for: deep research search, semantic search by meaning, competitor analysis.

12. Filesystem

The official MCP server for filesystem access. Reads, writes, searches files, browses directories. Works with configurable restrictions — you can limit access to specific folders only.

npx -y @modelcontextprotocol/server-filesystem /path/to/allowed/dir

Takes a list of allowed directories as arguments. Blocks access outside the specified paths — safe to use with AI.

Use it for: working with project files, analyzing logs, managing configuration.

---

Productivity

13. Notion

The official MCP server from Notion. Access to pages, databases, comments. Claude searches across the workspace, creates pages, updates database entries.

npx -y @notionhq/notion-mcp-server

The current version runs on Notion API 2026-03-11. Also available as a remote MCP (Notion hosts the server — https://mcp.notion.com/mcp, recommended for most clients). Requires a Notion Integration Token.

Notion has officially moved to supporting only the remote server and plans to sunset the local package. The AI searches the whole workspace, creates pages from templates, updates databases, and adds comments.

Use it for: managing documentation, updating knowledge bases, searching across a Notion workspace.

14. Slack

The official MCP server for the Slack API. Search across channels, send messages, read message history. The AI participates directly in work communications.

npx -y @modelcontextprotocol/server-slack

Requires SLACK_BOT_TOKEN (xoxb-…). Workspace admins control MCP client access through Slack settings.

Use it for: searching information in Slack, sending notifications, monitoring channels.

15. Google Workspace

MCP access to Google’s services: Gmail, Docs, Sheets, Drive, Calendar. Several connection options.

The official Google CLI with MCP:

npm install -g @googleworkspace/cli

For Google Drive specifically:

npx -y @modelcontextprotocol/server-gdrive

Google also offers fully managed remote MCP servers for its services — you can connect directly through an MCP client with no local install.

Use it for: working with documents, spreadsheets, email, and calendar from an AI assistant.

16. Figma

The official MCP server from Figma. Reads the structure of design files: components, tokens, properties, layers. The AI generates code from the actual design, not a screenshot.

Remote endpoint (recommended): https://mcp.figma.com/mcp

For Claude Code:

claude plugin install figma@claude-plugins-official

Local install (community, not from Anthropic):

npx -y figma-developer-mcp --figma-api-key=YOUR-KEY --stdio

Also available through Dev Mode in the Figma desktop app (Shift+D → Enable desktop MCP server).

The Figma MCP server reads the live structure of selected layers: components, auto-layout, tokens, spacing, colors. Code gets generated from real design data rather than a screenshot — the result is more accurate and needs less manual tweaking.

Use it for: design-to-code, extracting tokens and styles, generating UI components from a design.

---

DevOps

17. Docker

An MCP server for managing Docker: containers, images, volumes, networks. The AI starts and stops containers, inspects logs, manages a compose stack.

npx -y docker-mcp

docker-mcp is a community server (QuantGeekDev). Docker officially offers an MCP Catalog with 300+ verified images: docker run mcp/<server-name>. Supports Docker Compose, container inspection, and resource management. If you’d rather run something purpose-built for your own stack, see how to build and productionize a custom MCP server.

Useful for debugging: “show me the logs for the api container over the last 10 minutes and explain why it keeps restarting.” The AI reads the logs, spots OOM errors, and suggests configuration changes.

Use it for: container management, debugging Docker environments, deployment automation.

18. Cloudflare

The official Cloudflare MCP server. Covers the entire API: DNS, Workers, Pages, R2, KV, D1, Queues — 2,500 endpoints through two tools (search() and execute()). Token-efficient: roughly 1,000 tokens for the whole API surface.

npx -y @cloudflare/mcp-server-cloudflare

Also available as a remote MCP with OAuth. Cloudflare has shipped 13 specialized servers for individual services plus one universal server built around Code Mode.

Cloudflare’s architectural choice — Code Mode — is to skip a dedicated tool per API endpoint and instead expose two universal tools (search() and execute()) that cover all 2,500 endpoints. When Cloudflare ships a new product, the MCP server automatically gains access to it with no update required.

Use it for: managing Cloudflare infrastructure — DNS, Workers, Pages, storage.

19. Grafana

An MCP server for Grafana. Access to dashboards, datasources, alerts, incidents. Query Prometheus (PromQL) and Loki (LogQL) directly from an AI assistant.

Install via Python (uvx):

uvx mcp-grafana

Docker image from Grafana Labs:

docker run -i --rm -e GRAFANA_URL -e GRAFANA_SERVICE_ACCOUNT_TOKEN grafana/mcp-grafana

40+ tools: dashboards, datasources, alerts, incidents, OnCall, Pyroscope. Responses are tuned for minimal token usage.

Use it for: monitoring, metric and log analysis, managing alerts and incidents.

20. Kubernetes

An MCP server for managing Kubernetes clusters. A native Go implementation — talks to the Kubernetes API directly, not a wrapper around kubectl.

npx -y kubernetes-mcp-server

Also available as a Docker image: docker run mcp/kubernetes. Supports kubeconfig from multiple sources, works with pods, deployments, services, namespaces.

Alternative (CNCF Landscape):

npx -y kubectl-mcp-server

Use it for: managing clusters, debugging pods, inspecting Kubernetes resources.

---

AI and LLM

21. Langfuse

An MCP server for Langfuse — an observability platform for LLM applications. Manage prompts, access traces, analyze model performance.

Built into Langfuse — remote endpoint:

https://YOUR_LANGFUSE_HOST/api/public/mcp

Transport: Streamable HTTP. No separate install needed — the MCP server runs straight from your Langfuse instance. Requires LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY.

Use it for: prompt management, analyzing traces from LLM applications, monitoring quality. For a hands-on walkthrough of the setup, see LLM observability with Langfuse.

22. OpenAI

An MCP server for accessing OpenAI models from other AI assistants. Claude or Cursor can use GPT as a second opinion or for specific tasks.

Several community implementations:

npx -y @mzxrai/mcp-openai

Requires OPENAI_API_KEY. Supports chat completions, embeddings, image generation. Useful in multi-model setups where different models handle different tasks.

Example: Claude Code writes the code, then calls DALL-E through the OpenAI MCP server to generate OG images. Or it uses GPT as a “second opinion” when reviewing an architectural decision.

Use it for: multi-model workflows, using GPT from Claude Code, generating images via DALL-E.

23. Gemini

An MCP server for Google’s Gemini models. Gives access to Gemini 3.5 Flash and Gemini 3.1 Pro, thinking mode, vision, and embeddings.

npx -y @houtini/gemini-mcp

Requires GEMINI_API_KEY. Gemini 3.5 Flash has been the primary model since May 2026 (GA, the default in the Gemini App and AI Mode in Search); Gemini 3.1 Pro remains relevant for tasks that demand extreme reasoning. Community wrappers with vision analysis and multimodal input support are also available.

Use it for: multi-model scenarios, vision analysis, using Gemini from Claude Code.

---

Bonus: Two More Useful Servers

24. Playwright

An MCP server for browser automation. The AI opens pages, clicks elements, fills forms, takes screenshots. Essential for testing and scraping.

npx -y @playwright/mcp

The AI drives a real browser: navigates to URLs, clicks buttons, fills forms, takes screenshots. Especially useful for E2E tests — Claude sees the actual DOM and writes tests without guessing at page structure.

Use it for: E2E testing, browser automation, scraping data.

25. Memory

The official MCP server for persistent memory. The AI stores knowledge between sessions as a graph of entities and relations. Project knowledge, decisions, context — all of it persists.

npx -y @modelcontextprotocol/server-memory

Stores data locally in a JSON file. No external services required. The AI remembers architectural decisions, preferences, and project context, and uses that knowledge in later sessions.

Example: you talk through a project’s architecture with Claude. Memory saves the key decisions — stack, patterns, conventions. In the next session, the AI already knows the context and doesn’t ask the same questions twice — the same discipline covered in the context engineering guide.

Use it for: persistent AI memory, retaining context across sessions, a project knowledge base.

---

Comparison Table

#	Server	Package / endpoint	Category	Setup difficulty
1	GitHub	ghcr.io/github/github-mcp-server	Code	Low (needs a token)
2	GitLab	@modelcontextprotocol/server-gitlab	Code	Low (needs a token)
3	Sentry	https://mcp.sentry.dev/mcp (remote)	Code	Minimal (OAuth)
4	Linear	Remote MCP / @tacticlaunch/mcp-linear	Code	Minimal
5	Context7	@upstash/context7-mcp	Code	Minimal
6	PostgreSQL	@modelcontextprotocol/server-postgres	Database	Low (connection string)
7	Supabase	https://mcp.supabase.com/mcp	Database	Minimal (OAuth)
8	SQLite	@modelcontextprotocol/server-sqlite	Database	Minimal
9	Redis	@redis/mcp-server	Database	Low
10	Brave Search	@brave/brave-search-mcp-server	Search	Low (needs a key)
11	Exa	exa-mcp-server	Search	Low (needs a key)
12	Filesystem	@modelcontextprotocol/server-filesystem	Search	Minimal
13	Notion	@notionhq/notion-mcp-server	Productivity	Low (needs a token)
14	Slack	@modelcontextprotocol/server-slack	Productivity	Medium (Slack App)
15	Google Workspace	@googleworkspace/cli	Productivity	Medium (OAuth)
16	Figma	https://mcp.figma.com/mcp	Productivity	Minimal (remote)
17	Docker	docker-mcp (community) / Docker MCP Catalog	DevOps	Low
18	Cloudflare	@cloudflare/mcp-server-cloudflare	DevOps	Low (needs a token)
19	Grafana	uvx mcp-grafana / grafana/mcp-grafana (Docker)	DevOps	Medium
20	Kubernetes	kubernetes-mcp-server	DevOps	Medium (kubeconfig)
21	Langfuse	Remote (built into Langfuse)	AI/LLM	Low
22	OpenAI	@mzxrai/mcp-openai	AI/LLM	Low (needs a key)
23	Gemini	@houtini/gemini-mcp	AI/LLM	Low (needs a key)
24	Playwright	@playwright/mcp	Automation	Minimal
25	Memory	@modelcontextprotocol/server-memory	Utilities	Minimal

---

How to Choose: Starter and Advanced Sets

Starter set (5 servers)

The minimum for productive work with an AI assistant:

1. GitHub — code management, PRs, issues
2. Filesystem — access to project files
3. Brave Search — web search for current information
4. Context7 — up-to-date library documentation
5. PostgreSQL or Supabase — database access

This set covers 80% of an average developer’s tasks. Setup takes 5 minutes:

claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem ~/projects
claude mcp add brave-search -- npx -y @brave/brave-search-mcp-server
claude mcp add context7 -- npx -y @upstash/context7-mcp@latest
claude mcp add postgres -- npx -y @modelcontextprotocol/server-postgres postgresql://localhost:5432/mydb

For GitHub, use Docker (see the section above).

Advanced set (10+ servers)

The starter set, plus:

6. Sentry — production error monitoring
7. Notion or Linear — task and documentation management
8. Slack — work communications
9. Figma — design-to-code
10. Docker or Cloudflare — DevOps tasks

Depending on your stack, add:

• Grafana + Kubernetes — if you work with infrastructure
• Langfuse — if you build LLM applications
• OpenAI / Gemini — if you run multi-model workflows
• Memory — if you’re on a long-running project and want persistent context

Sample .mcp.json for the starter set

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@brave/brave-search-mcp-server"],
      "env": {
        "BRAVE_API_KEY": "${BRAVE_API_KEY}"
      }
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost:5432/mydb"]
    }
  }
}

Three rules for choosing servers

1. Don’t connect everything at once. Every server adds tool descriptions to the AI’s context window. That costs tokens and slows responses down. 5-7 servers is the sweet spot. Running 25 at once is a bad idea.
2. Connect per project. Use .mcp.json in the project root for project-specific servers. Reserve global config for what you always need (GitHub, Filesystem). A Supabase server has no place in a Firebase project, and vice versa.
3. Prefer remote over local, when available. Remote MCP servers (Supabase, Figma, Linear) need no install, update automatically, and run more reliably. Local ones (npx) are better for offline work and customization.

Servers by role

Frontend developer: Figma + Context7 + Brave Search + GitHub + Playwright. Figma for design-to-code, Context7 for current React/Vue/Angular docs, Playwright for E2E tests.

Backend developer: PostgreSQL + Redis + Sentry + GitHub + Docker. The full cycle: database, cache, error monitoring, code, containers.

DevOps engineer: Kubernetes + Docker + Cloudflare + Grafana + GitHub. Infrastructure management, monitoring, deployment — all from an AI assistant.

Full-stack + AI: all the basics plus Langfuse + OpenAI/Gemini + Memory. Multi-model workflows, LLM observability, persistent context.

---

Where to Find More Servers

The MCP ecosystem is growing fast. If the server you need isn’t in this catalog:

• MCP Registry — the official registry from Anthropic, with namespace verification and standardized install metadata
• MCP Market — a catalog of MCP servers with ratings and reviews
• mcp.so — another catalog with category filters
• GitHub modelcontextprotocol/servers — the repo of current reference servers; archived ones moved to servers-archived
• npm search @modelcontextprotocol — all the official packages

New servers show up daily. Big companies (Stripe, Datadog, Vercel, AWS) ship official servers for their APIs. The community builds servers for everything else — from Telegram to Home Assistant.

---

Conclusion

The MCP ecosystem has matured in 2026. For any tool in a developer’s stack, there’s an MCP server for it — GitHub, Kubernetes, PostgreSQL, Figma. The protocol is standardized by the Linux Foundation and supported across every major AI platform.

Start with the five servers in the starter set — GitHub, Filesystem, Brave Search, Context7, PostgreSQL. Setup takes 5 minutes, and the productivity gain shows up immediately: the AI gets access to real project data instead of working blind.

Add the rest as you need them. New servers ship every week from both big companies and the community. Keep an eye on MCP Market and mcp.so for fresh releases.

What matters isn’t how many servers you have connected — it’s how much they speed up your specific work.