Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Chapter 17: The Ecosystem

A Tour of What Exists

One of MCP’s greatest strengths is its ecosystem. In roughly eighteen months, thousands of MCP servers have been built—from official reference implementations to community-created integrations covering everything from databases to smart home devices.

This chapter surveys the landscape. We’re not going to list every server (that would be a phone book, not a chapter), but we’ll cover the major categories and highlight the servers you’re most likely to use.

Official Reference Servers

Anthropic and the MCP project maintain several reference servers that demonstrate best practices and cover common use cases.

Filesystem

Package: @modelcontextprotocol/server-filesystem

The filesystem server gives an LLM controlled access to the local filesystem. It can read files, list directories, search for files, and (optionally) write files.

{
  "filesystem": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/directory"]
  }
}

The directory argument scopes access—the server only serves files within that directory. This is your most basic “let the LLM see my code” server.

GitHub

Package: @modelcontextprotocol/server-github

Wraps the GitHub API. Create issues, read pull requests, search repositories, manage files. Requires a GitHub personal access token.

{
  "github": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-github"],
    "env": {
      "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
    }
  }
}

GitHub also released their own official MCP server (github/github-mcp-server) which offers broader API coverage.

Memory

Package: @modelcontextprotocol/server-memory

A knowledge graph server that gives the LLM persistent memory. It stores entities, relationships, and observations in a local file, letting the LLM remember things across conversations.

{
  "memory": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-memory"]
  }
}

Fetch

Package: @modelcontextprotocol/server-fetch

Fetches web pages, converts HTML to markdown, and returns the content. Essential for when the LLM needs to read web pages.

PostgreSQL

Package: @modelcontextprotocol/server-postgres

Connects to a PostgreSQL database. Exposes the schema as a resource and provides query tools with read-only access by default.

SQLite

Package: mcp-server-sqlite (Python)

Similar to PostgreSQL but for SQLite databases. Popular for development, prototyping, and small-scale data exploration.

Developer Tools

Git

Servers that wrap Git operations—view history, diff changes, create branches, manage commits. Useful for code review workflows and repository management.

Docker

Manage Docker containers, images, and compose stacks through natural language. “Stop all running containers” becomes a tool call.

Kubernetes

Query cluster state, manage deployments, read logs. Particularly useful when combined with an LLM that can help diagnose production issues.

Sentry

Connect your error tracking to your LLM. “What were the most common errors this week?” becomes a real-time query.

Data and Databases

BigQuery

Query Google BigQuery datasets. Expose schemas as resources, execute queries as tools.

MongoDB

CRUD operations on MongoDB collections. Schema discovery, document search, aggregation pipelines.

Redis

Key-value operations, pub/sub, cache management.

Elasticsearch

Full-text search, index management, query building.

Snowflake

Data warehouse queries for analytics and business intelligence.

Productivity and Communication

Slack

Read channels, send messages, search conversations. Turn Slack into a data source for your LLM.

Linear

Project management integration. Create issues, update statuses, query roadmaps.

Notion

Read and write Notion pages, databases, and blocks.

Google Drive

Search, read, and organize files in Google Drive.

Email (Gmail, Outlook)

Read emails, search mailboxes, draft responses.

Cloud Services

AWS

Interact with AWS services—S3, Lambda, DynamoDB, CloudWatch, and more.

Cloudflare

Manage Cloudflare Workers, KV stores, DNS records.

Vercel

Deploy, manage, and monitor Vercel projects.

Specialized Domains

Web search through the Brave Search API. A common choice for giving LLMs internet access.

Puppeteer / Playwright

Browser automation through MCP. The LLM can navigate pages, fill forms, take screenshots.

E-commerce

Shopify, Stripe, and other commerce platforms have community MCP servers for managing products, orders, and payments.

Smart Home

Home Assistant MCP servers let LLMs control smart home devices. “Turn off the living room lights” goes from voice command to tool call.

Discovery: Finding MCP Servers

mcp.run

A hosted registry and runtime for MCP servers. Browse available servers, configure them through a web UI, and connect them to your applications.

Smithery

Another MCP server registry with hosting capabilities. Provides one-click installation for popular servers.

Awesome MCP Servers

Community-curated lists on GitHub. Search for “awesome-mcp-servers” to find comprehensive listings.

npm and PyPI

Search for mcp-server on npm or mcp-server on PyPI to find published servers. Many follow the naming convention @scope/mcp-server-name or mcp-server-name.

The MCP Marketplace in VS Code

VS Code’s extension marketplace includes MCP servers. Search for @mcp in the Extensions view to browse and install.

Evaluating MCP Servers

Before adding a server to your workflow, consider:

1. Trust

Who built it? Is it open source? Can you review the code? An MCP server running via stdio has full access to your system—trust it like you’d trust any installed software.

2. Maintenance

Is it actively maintained? When was the last commit? Does it track the latest MCP spec version?

3. Quality

Does it have tests? Documentation? Example configurations? Is the tool schema well-designed with good descriptions?

4. Security

Does it follow security best practices? Does it validate inputs? Does it scope access appropriately?

5. License

Is the license compatible with your use case? Most MCP servers use MIT or Apache 2.0, but check.

Building for the Ecosystem

If you’re building an MCP server for others to use, here’s how to be a good ecosystem citizen:

1. Follow Naming Conventions

  • npm: @yourorg/mcp-server-name or mcp-server-name
  • PyPI: mcp-server-name
  • Binary name: mcp-server-name

2. Provide Good Documentation

Include:

  • What the server does
  • Prerequisites (API keys, databases, etc.)
  • Installation instructions
  • Configuration examples for major hosts
  • Tool descriptions and example outputs

3. Write Rich Schemas

Your schemas are your API documentation and your LLM instructions. Make them thorough:

{
  "name": "search_documents",
  "description": "Search for documents matching a query. Returns up to 10 results by default, sorted by relevance. Supports boolean operators (AND, OR, NOT) and phrase matching with double quotes.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Search query. Examples: 'quarterly report', 'budget AND 2025', '\"exact phrase\"'"
      },
      "limit": {
        "type": "number",
        "description": "Maximum results to return (1-100, default 10)",
        "minimum": 1,
        "maximum": 100,
        "default": 10
      }
    },
    "required": ["query"]
  }
}

4. Handle Errors Gracefully

Never crash. Never hang. Always return a useful error message.

5. Respect Rate Limits

If your server wraps an external API, respect its rate limits and pass helpful error messages when limits are hit.

6. Publish Configuration Examples

Show users how to configure your server in Claude Desktop, Claude Code, VS Code, and Cursor. Copy-paste-ready JSON is worth a thousand words.

The Network Effect

MCP’s ecosystem has a powerful network effect. Every new server makes every MCP host more capable. Every new host gives every server more users. The more servers exist, the more valuable it is to build a host. The more hosts exist, the more valuable it is to build a server.

We’re still in the early innings. The ecosystem today is roughly where npm was in 2012 or the Chrome extension store was in 2010—growing fast, full of interesting experiments, and just starting to figure out quality standards and best practices.

If you build a good MCP server for a problem people actually have, they will find you.

Summary

The MCP ecosystem spans developer tools, databases, cloud services, productivity apps, and specialized domains. Thousands of servers exist, with more appearing daily. Official reference servers cover common cases; community servers fill every niche imaginable.

Finding servers is getting easier through registries (mcp.run, Smithery), package managers (npm, PyPI), and IDE marketplaces (VS Code). When evaluating servers, prioritize trust, maintenance, quality, and security.

If you’re building for the ecosystem, invest in documentation, rich schemas, and error handling. The ecosystem rewards quality.

Next: where MCP is headed.