Which MCP Servers Are Available and How Do You Choose One?
MCP servers are programs that expose external tools and data sources to any AI application that speaks the Model Context Protocol (MCP). Anthropic created MCP and open-sourced it in November 2024. Since December 2025, MCP has been governed by the Agentic AI Foundation under the Linux Foundation, co-founded by Anthropic, Block, and OpenAI (Linux Foundation, “Agentic AI Foundation Launch,” December 9, 2025).
The official MCP Registry lists over 9,600 server records as of mid-2026. PulseMCP indexes over 15,900. Smithery catalogs over 7,300 with install guides. Client support exists in Claude Desktop, ChatGPT, Cursor, VS Code, Windsurf, and Gemini CLI.
This directory covers what an MCP server is and how to evaluate one before installing it. It organizes every significant server by what you are connecting to, with editorial picks, authentication requirements, and token cost ranges for each category.
What Is an MCP Server?
An MCP server is a program that exposes one tool or data source to any MCP-compatible AI application through the Model Context Protocol, translating between structured JSON-RPC calls from the client and the underlying system’s API.
MCP servers expose three kinds of capability. Tools are actions the model can execute: creating an issue, running a query, posting a message. Resources are data the model can read: a file, a table schema, a design token set. Prompts are reusable templates the server provides: “summarise this PR” or “review this diff for security issues.” A server that exposes only tools is less capable than one that also surfaces resources and provides prompts.
MCP servers fall into three tiers. Reference servers are maintained by the MCP project under the Linux Foundation. Seven are currently active: Everything, Fetch, Filesystem, Git, Memory, Sequential Thinking, and Time (modelcontextprotocol/servers, June 2026). Vendor-maintained servers are built by the tool’s own company. GitHub, Stripe, Figma, Supabase, Linear, and Slack each maintain their own MCP server. At least 50 vendor-maintained servers exist as of mid-2026. Community servers are built by independent developers. Quality ranges from production-grade to abandoned. The quality signal is commit recency, not star count.
Thirteen former Anthropic reference servers (GitHub, GitLab, Slack, Google Drive, Postgres, Puppeteer, Brave Search, and others) were archived in 2025 and 2026. Vendor-maintained replacements exist for each. Install the current vendor version, not the archived reference. The archived versions still appear in tutorials and registry listings without warnings.
How Do You Evaluate an MCP Server Before Installing It?
Evaluate an MCP server on five criteria: maintenance recency, client compatibility, authentication model, transport support, and token cost per call.
1. Maintenance recency. Check the commit history and issue response time. A server last updated eight months ago has not kept up with the November 2025 specification changes. It may lack OAuth 2.1 support, streamable HTTP, or compatibility with current clients. Look for commits in the last 60 days and issues answered within a week. A concrete test: open the server’s GitHub repository. Check the date of the most recent commit. Check the open issues tab for unanswered questions older than 30 days. A server with 3 open issues and 0 maintainer responses is a server with no maintainer.
2. Client compatibility. Confirm the server runs in the client you use. A server tested only on Claude Desktop may not work in Cursor if it uses a transport Cursor does not support. Stdio servers work in Claude Desktop, Cursor, VS Code, and Windsurf. Streamable HTTP servers work in remote deployments and web-based clients. SSE-only servers are being deprecated and may fail in clients that have dropped SSE support. Check the README for a compatibility matrix. Test it yourself when there is no matrix.
3. Authentication model. OAuth 2.1 tokens are scoped, time-limited, and revocable. API keys sit in the config file in plain text and last until manually revoked. Personal access tokens fall between the two: they can be scoped to specific permissions but do not expire automatically unless configured to. Prefer OAuth where supported. When OAuth is not available, scope every token to the minimum permissions the server needs. A read-only GitHub token for a server that only lists issues. A read-only database role for a server that only runs SELECT queries. The over-scoping mistake is common: a developer creates a token with full repo access for a server that only needs public_repo read access.
4. Transport support. Stdio is the standard for local servers. The client launches the server as a process on your machine. No network involved. No authentication needed beyond what the server’s own API requires. Streamable HTTP is the current standard for remote and hosted servers. It requires a URL, authentication (OAuth or API key), and TLS configuration. SSE (Server-Sent Events) is the legacy remote transport, being replaced by streamable HTTP in the 2025 and 2026 specification updates. The transport determines setup complexity and latency. Stdio is simpler but means the server runs on your laptop. HTTP means you can host it centrally but you manage auth and TLS.
5. Token cost per call. Every connected server’s tool definitions consume 500 to 2,000 tokens of context window space before any calls happen. Responses vary by server type. Database queries return 500 to 5,000 tokens. Search APIs return 1,000 to 3,000 tokens. Browser page snapshots consume 15,000 to 30,000 tokens. Three to five simultaneous servers is practical. Beyond that, tool definitions crowd out the conversation and degrade model performance.
Why Does Maintenance Recency Matter More Than Star Count?
A server’s star count measures initial attention. Maintenance recency measures ongoing reliability. The MCP specification has shipped updates in November 2024, November 2025, and July 2026. Each update introduces capabilities that newer clients expect. A server frozen at the November 2024 spec will not offer OAuth 2.1, streamable HTTP, or the extensions framework. It may connect but fail on specific calls without a clear error message. The Postgres reference server, for example, was archived and replaced by a vendor-maintained version. Tutorials written in early 2025 still link to the archived version. The archived server connects. Its tool calls return errors that do not explain the version mismatch.
How Much Context Window Do Server Tool Definitions Consume?
Each connected server’s tool definitions consume 500 to 2,000 tokens before any calls happen. The math is direct. Five servers at 1,500 tokens each is 7,500 tokens consumed before the user types a word. A model with a 200,000-token context window absorbs this easily. A model with a 32,000-token context window loses 23% of its capacity to tool definitions alone, before any conversation or tool responses enter the window. Connect 10 servers and the definitions consume 15,000 tokens. Add a browser snapshot response at 25,000 tokens and over half the 32,000-token window is gone. Connect only the servers the current task needs. Remove servers between tasks when the workflow changes.
The evaluation rubric above applies to individual servers. The broader question of which servers to combine into a workflow depends on the client you choose and the context window you have available.
Which MCP Servers Are Available by Category?
Over 10,000 MCP servers are published across registries as of mid-2026. The directory below organizes the most significant servers into 14 categories by what you are connecting to, with editorial picks and token cost ranges for each.
Each category lists servers by tier. T1 servers have dedicated guides on this site with full install walkthroughs. T2 servers have single-page guides. Directory-row servers are listed in the category hub with a capsule and a link to the source repository.
Code and Version Control
- GitHub MCP server exposes issues, pull requests, repo files, branches, and commits. Auth: personal access token. Scope to
repofor private repos. Scope topublic_repofor open source. Transport: stdio. Token cost: 1,500 to 3,000 per call. Use when your workflow involves code review, issue tracking, or repository search. The GitHub server is vendor-maintained. Install the current version, not the archived Anthropic reference. The gotcha most people hit first: the token’s scope. A token scoped torepocan push code, delete branches, and merge pull requests. A server that only reads issues does not need that scope. - GitLab exposes similar capabilities for GitLab-hosted repositories. Auth: personal access token. Use when your organization runs on GitLab.
- Jira exposes issues, boards, and sprints. Auth: API token plus Atlassian domain. Use when project management lives in Jira.
- Linear exposes issues and projects. Auth: API key. Use when your team tracks work in Linear.
Databases and Storage
- Postgres MCP server runs SQL queries, inspects table schemas, and returns structured results. Auth: connection string. Use a read-only database role unless writes are genuinely needed. An agent with a read-write connection string can drop a table without asking. Transport: stdio. Token cost: 500 to 5,000 per query depending on result set size. Use when you need natural-language database access. The specific failure mode: the server connects with a connection string pasted in the config file in plain text. Protect that file. Anyone who can read the config can read the connection string.
- Supabase MCP server provides auth, realtime, and storage in one server. Higher-level abstraction than raw Postgres. Use when your backend is Supabase. Use Postgres directly when you need raw SQL control or connect to a database Supabase does not host.
- MySQL provides relational database access. Auth: connection string.
- Redis provides in-memory data store access. Auth: connection string.
- MongoDB provides document database access. Auth: connection string.
- Snowflake provides cloud data warehouse access. Auth: account credentials.
- Firebase provides Google app platform access. Auth: service account.
Browser Automation and Testing
- Playwright MCP server drives a real browser: navigate, click, fill forms, extract page content. Auth: none (local process). Transport: stdio. Token cost: 15,000 to 30,000 tokens per page snapshot. This is the highest token cost of any common server type. Point at specific selectors, not whole pages. Requires Playwright browser binaries installed locally. The first-time failure: the server starts but every tool call fails because the browser binaries are not installed. Run
npx playwright installbefore adding the server to the config. The second failure: a full-page snapshot of a complex site returns 30,000 tokens and fills the context window before the model can reason over the content. Target specific elements. - Puppeteer provides alternative browser automation. Lighter and less capable than Playwright. The Anthropic reference version is archived. Use the community-maintained replacement.
- Chrome DevTools provides Chrome inspection and debugging. Auth: none (local). Google-maintained.
Search and Data Retrieval
- Brave Search MCP server provides web search through Brave’s API. Auth: API key. Transport: stdio. Token cost: 1,000 to 3,000 per search. Use when the model needs current web information beyond its training data. The Anthropic reference version is archived. Install the current Brave-maintained server.
- Tavily provides AI-optimized search returning clean extracted content, not raw links. Auth: API key. Use when you need summarized search results the model can act on directly.
- Exa provides semantic search returning passages, not pages. Auth: API key. Use when passage-level precision matters for research or retrieval tasks.
- Firecrawl converts any URL or website into clean markdown. Auth: API key. Use when you need to turn web pages into structured text the model can process.
Communication and Messaging
- Slack MCP server exposes channel reading, message posting, and message history search. Auth: OAuth with workspace-level permissions. Transport: stdio. Token cost: 1,000 to 2,000 per call. The Anthropic reference version is archived. Slack now ships its own server. The gotcha: workspace admin approval may be required before the OAuth flow completes. Enterprise Slack workspaces enforce this. Personal workspaces do not.
- Gmail provides email reading and sending. Auth: OAuth (Google Workspace).
- Discord provides server message and channel access. Auth: bot token.
File Systems and Cloud Storage
- Filesystem MCP server reads and writes local files and directories. Auth: none (inherits machine permissions). Transport: stdio. Token cost: 500 to 2,000 per call. This is most users’ first MCP server. The simplest to install. The easiest to verify. Scope it to a specific project folder. It accesses anything in the directories you configure. The common mistake: configuring it with your home directory. Scope it to a single project root. An agent pointed at your entire home directory can read SSH keys, environment files, and credentials stored anywhere in the tree.
- Google Drive provides cloud file reading and writing. Auth: OAuth (Google Workspace). Google now ships its own server. The Anthropic reference version is archived.
AI and Reasoning Enhancement
- Sequential Thinking provides structured multi-step reasoning through tool call chains. Breaks complex problems into reasoning steps the model processes sequentially. One of 7 active Anthropic reference servers. Use when single-shot reasoning is insufficient.
- Context7 pulls current library documentation into model context before code generation. Use for React, Next.js, or any framework with frequent breaking changes. The model generates code against current API signatures instead of stale training data.
- Serena provides coding agent capabilities with codebase-aware context.
Productivity and CMS
- Notion MCP server exposes Notion pages, databases, and blocks for reading and writing. Auth: integration token. Token cost: 1,000 to 3,000 per call. Use when your knowledge base or project documentation lives in Notion.
- WordPress provides CMS content reading and writing. Auth: application password.
- Confluence provides Atlassian wiki access. Auth: API token plus domain.
DevOps and Infrastructure
- Docker provides container and image management. Auth: Docker socket.
- Cloudflare provides Workers, DNS, and configuration management. Auth: API token.
- Vercel provides deployment and project management. Auth: API token.
- AWS provides AWS service interaction. Auth: IAM credentials.
- Azure provides Azure service interaction. Auth: service principal.
Automation and Integration
- n8n provides workflow automation with an MCP bridge to 400+ integrations. Auth: API key.
- Zapier provides access to over 6,000 external applications through a single server. Auth: API key.
Design and Creative
- Figma MCP server exposes design tokens, frame hierarchy, and component structure from Figma files. Auth: personal access token. Token cost: 2,000 to 5,000 per call. Reads structure, not pixels. Works best with clean, well-named Figma layers. The limitation: the server reads frame names and component metadata. Poorly named frames (“Frame 47,” “Group 12”) return data the model cannot interpret meaningfully.
CRM and Marketing
- HubSpot provides access to contacts, deals, companies, and marketing data. Auth: private app token.
- Salesforce provides CRM record and report access. Auth: OAuth (connected app).
Monitoring and Observability
- Datadog provides access to metrics, logs, and traces. Auth: API key plus app key.
- Sentry provides error tracking and issue management. Auth: auth token. The Anthropic reference version is archived. Sentry maintains its own.
Finance and Payments
- Stripe MCP server exposes payments, customers, subscriptions, and invoices. Auth: restricted API key. Scope to read-only where possible. Use when your product uses Stripe and you want to query payment data from your AI assistant.
- Plaid provides banking data and financial connections. Auth: client credentials.
Which MCP Servers Are Most Used Right Now?
The most-installed MCP servers by search demand in mid-2026 are GitHub, Playwright, Figma, Chrome DevTools, Context7, Jira, Slack, Notion, Supabase, and Postgres.
The pattern shows what developers actually connect. Code and version control servers dominate because most MCP users are developers building in an IDE. Database servers are second because natural-language SQL is one of the clearest productivity gains MCP delivers. Browser automation is third because it replaces manual testing and scraping workflows.
The ecosystem grew from roughly 500 public servers at launch in November 2024 to over 10,000 by December 2025. Monthly SDK downloads across Python and TypeScript reached 97 million by March 2026 (Anthropic, AAIF donation announcement, December 2025). The growth is concentrated in vendor-maintained servers. Vendors who ship their own MCP server (GitHub, Stripe, Figma, Cloudflare, Supabase) gain distribution across every MCP client without building separate integrations for each one.
“Most used” describes what people install. For editorial ranked picks with stated criteria, see the ranked shortlist with selection criteria.
You have identified which server connects the tool you need. The next decisions are where to get it, how to install it, and what to check before trusting it with your credentials.
Where Do You Find MCP Servers?
MCP servers are listed on the official MCP Registry (over 9,600 records), PulseMCP (15,900+), Smithery (7,300+), and the modelcontextprotocol GitHub repository.
No single registry indexes all servers. The official registry is in preview and focuses on public metadata. PulseMCP indexes the most by raw count but does not verify maintainer activity. Smithery provides install commands and compatibility notes but lists servers without checking whether they still work against the current specification. The registries list servers. This guide evaluates them. A server with 500 GitHub stars and no commits in six months is less reliable than one with 50 stars and weekly updates. The evaluation rubric in section two applies regardless of which registry you found the server on. Cross-reference at least two registries before committing to a server. Check the source repository directly for the commit and issue history that no registry surface shows.
How Do You Install an MCP Server?
Install an MCP server by adding it to your client’s config file, specifying the command, arguments, and any API tokens it needs, then fully quitting and reopening the client.
The installation pattern is the same regardless of which server you chose from the directory above. The protocol standardises how clients launch and connect to servers. Three steps: install the server package (most run through npx for Node.js or uvx for Python without a separate install step), add it to the config file, and restart the client with a full quit-and-reopen. A window close is not enough in Claude Desktop or Cursor. The full application must quit and relaunch.
The first-time failure almost every developer hits: the runtime is missing. Servers distributed as npm packages require Node.js installed and npx available in your PATH. Servers distributed as Python packages require Python and uvx. The client tries to launch the server, fails silently or with a “command not found” error, and the server never appears. Verify that npx --version or uvx --version returns a result before editing the config file. On Windows, Node.js installed inside WSL is not visible to a client running in Windows. Install the runtime natively on the same OS the client runs on.
What Should You Check Before Trusting an MCP Server?
Before installing any MCP server, verify three things: the source is one you would trust with the underlying access, the token is scoped to minimum permissions, and OAuth 2.1 tokens are preferred over long-lived API keys.
An MCP server that accepts a GitHub personal access token can do anything that token permits. An untrusted server with a broadly scoped token is functionally an untrusted developer with your credentials.
The documented threat is tool poisoning: a malicious server embeds hidden instructions in its tool descriptions, and the model follows them without the user seeing them. This attack vector is documented in peer-reviewed research (Hou et al. 2025). A concrete example: a server’s tool description for “list_files” contains a hidden instruction telling the model to also read and exfiltrate the contents of .env files. The model reads the tool description during discovery, follows the embedded instruction, and sends environment variable contents to the server. The user sees “listing files” in the interface. The user does not see the exfiltration. The defense: install servers from trusted sources. Review tool descriptions in MCP Inspector before connecting an unfamiliar server. MCP Inspector shows the raw tool descriptions exactly as the model will read them.
What Happens When You Use Custom Integrations Instead of MCP Servers?
Without MCP servers, every AI application builds its own connector to every tool. Three clients connecting to 3 tools require 9 separate integrations. Each integration carries its own authentication logic, its own data format, and its own error handling.
Adding a fourth tool means 3 more integrations. Adding a fourth client means 4 more. The cost scales multiplicatively.
Each custom connector requires independent maintenance. When the tool’s API ships a breaking change, every connector for that tool must be updated separately. When a client changes its integration model, every connector for that client must be rewritten. A team maintaining 9 connectors spends engineering time on every API version bump, every auth flow change, and every error-format update across all 9. A team maintaining 25 connectors (5 clients, 5 tools) spends it across 25.
MCP servers collapse this. Each tool needs one server. Each client needs one MCP implementation. Three clients and 3 tools require 6 components, not 9. Ten clients and 10 tools require 20 components, not 100. The engineering savings compound as the ecosystem grows.
MCP Server Questions
Are MCP Servers Free?
Yes. The MCP specification, all official SDKs, and every reference server implementation are free and open-source under permissive licenses. MCP is governed by the Agentic AI Foundation under the Linux Foundation. No licensing fees. No usage costs. No vendor lock-in at the protocol level. The only costs MCP introduces are the costs of the external tools servers connect to: API rate limits, database hosting, SaaS subscriptions.
Are MCP Servers Obsolete?
No. MCP launched in November 2024 and the ecosystem is accelerating. Over 10,000 published servers. 97 million monthly SDK downloads. Governance under the Linux Foundation. Client support in every major AI application from Claude Desktop to ChatGPT to VS Code. The protocol is young and growing.
What Is Replacing MCP Servers?
Nothing is replacing MCP servers. MCP is the standard for model-to-tool communication, not a legacy protocol being superseded. Anthropic, OpenAI, and Block co-founded the Agentic AI Foundation to govern MCP. Google, Microsoft, AWS, and Cloudflare participate as members. A protocol that competing model vendors co-govern through a neutral foundation is one built to last.
Does Microsoft Have an MCP Server?
Yes. Microsoft supports MCP through VS Code and GitHub Copilot, and co-maintains the C# SDK. Multiple servers connect to Microsoft services including Azure, SharePoint, and Outlook. GitHub’s vendor-maintained MCP server is one of the most-installed servers in the ecosystem.
How Many MCP Servers Are There?
Seven active reference servers maintained by the MCP project under the Linux Foundation. At least 50 vendor-maintained servers built by tool companies (GitHub, Stripe, Figma, Supabase, and others). Over 10,000 community and vendor servers listed across registries. The count grows weekly as developers and vendors publish servers for additional tools and services.