# Best MCP Servers 2026: Top 25 for Developers

> A catalog of the best MCP servers: GitHub, PostgreSQL, Notion, Brave Search, Sentry, and 20 more. Categories, npm packages, setup.
> Author: Roman Belov · Published: 2026-06-30 · Source: https://futurecraft.pro/blog/best-mcp-servers-2026/

MCP (Model Context Protocol) is an open standard for connecting AI assistants to external tools — one protocol instead of hundreds of custom integrations. By the time the protocol joined the Linux Foundation, the project [reported 10,000 active servers and over 97 million monthly SDK downloads](https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/); it's supported 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](/blog/mcp-servers-explained/). 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):

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

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

```json
{
  "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.

```bash
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.

```bash
npx -y @modelcontextprotocol/server-gitlab
```

`@modelcontextprotocol/server-gitlab` is the original reference server; it has moved to `servers-archived` and the npm package is marked deprecated, though it still works. For more advanced scenarios (80+ tools, CQRS, OAuth 2.1), the actively developed community `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:

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

Locally via stdio:

```bash
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:

```bash
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](/blog/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.

```bash
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.

```bash
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:

```bash
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.

```bash
uvx mcp-server-sqlite --db-path path/to/database.sqlite
```

The official reference server from the MCP team — a Python package, `mcp-server-sqlite`, installed via uvx; no npm package exists for it. The database path goes in the `--db-path` flag. The reference server has moved to `servers-archived`, but the PyPI package keeps working.

**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.

```bash
uvx --from redis-mcp-server@latest redis-mcp-server --url redis://localhost:6379/0
```

A Python package, `redis-mcp-server`, on PyPI — Redis publishes no npm package. 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.

```bash
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.

```bash
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.

```bash
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.

```bash
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 reference server for the Slack API from the MCP team. Search across channels, send messages, read message history. The AI participates directly in work communications.

```bash
npx -y @modelcontextprotocol/server-slack
```

The reference server has moved to `servers-archived` and the npm package is marked deprecated — but, like PostgreSQL, it keeps working. 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:

```bash
npm install -g @googleworkspace/cli
```

For Google Drive specifically:

```bash
npx -y @modelcontextprotocol/server-gdrive
```

The `@modelcontextprotocol/server-gdrive` package is an archived reference server: it has moved to `servers-archived` and the npm package is marked deprecated, though it still works. 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:

```bash
claude plugin install figma@claude-plugins-official
```

Local install (community, not from Anthropic):

```bash
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.

```bash
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](/blog/mcp-production-custom-servers/).

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.

```bash
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):

```bash
uvx mcp-grafana
```

Docker image from Grafana Labs:

```bash
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.

```bash
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):

```bash
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](/blog/llm-observability-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:

```bash
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.

```bash
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.

```bash
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.

```bash
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](/blog/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 | `mcp-server-sqlite` (uvx) | Database | Minimal |
| 9 | Redis | `redis-mcp-server` (uvx) | 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:

```bash
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

```json
{
  "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](https://registry.modelcontextprotocol.io/)** — the official registry from Anthropic, with namespace verification and standardized install metadata
- **[MCP Market](https://mcpmarket.com/)** — a catalog of MCP servers with ratings and reviews
- **[mcp.so](https://mcp.so/)** — another catalog with category filters
- **[GitHub modelcontextprotocol/servers](https://github.com/modelcontextprotocol/servers)** — the repo of current reference servers; archived ones moved to `servers-archived`
- **[npm search @modelcontextprotocol](https://www.npmjs.com/search?q=%40modelcontextprotocol)** — 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.