4 / 5

Lesson 4 of 5 · MCP Builder Track

The MCP Ecosystem Today

reading

MCP went from an Anthropic research project to an industry-wide standard in less than a year. The adoption curve has been remarkable -- and understanding the current ecosystem is essential before you start building. This lesson gives you a comprehensive tour of who is using MCP, what servers are available, and where the community is heading.

The Adoption Timeline

Let us trace how MCP went mainstream:

November 2024   Anthropic open-sources MCP specification
                 Claude Desktop ships with MCP support
                 ~20 reference servers available

January 2025    Cursor IDE adds MCP support
                 Community servers hit 100+

March 2025      OpenAI announces MCP support in ChatGPT
                 VS Code Copilot adds MCP support
                 Specification moves toward Linux Foundation

April 2025      Windsurf, Zed, and other IDEs add MCP support
                 Community servers exceed 1,000
                 Enterprise adoption begins

Mid 2025        Google ADK supports MCP
                 Microsoft Copilot Studio supports MCP
                 MCP servers exceed 5,000+
                 Major cloud providers offer hosted MCP servers

2026            MCP is the de facto standard
                 Every major AI application supports it
                 Commercial MCP server marketplaces launch
Info

The speed of MCP adoption is unprecedented in developer tooling. It took REST APIs years to become standardized via OpenAPI. MCP achieved broad industry support in months -- largely because every AI company was independently solving the same integration problem and recognized the value of a shared standard.

Major Hosts: Who Supports MCP

A "host" in MCP terminology is the AI application that manages connections to MCP servers. Here are the major ones:

20+

MCP-Compatible Hosts

From Claude Desktop to ChatGPT, VS Code, Cursor, Windsurf, and JetBrains -- every major AI platform now supports MCP

Claude Desktop

The original MCP host and still the most feature-complete implementation.

JSON
// Configuration file location:
// macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
// Windows: %APPDATA%/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/projects"],
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Supported primitives: Tools, Resources, Prompts, Sampling Transport: stdio (local servers) Notable feature: Full prompt template UI integration -- prompts appear as selectable templates in the chat interface

Cursor IDE

The AI-powered code editor was one of the earliest MCP adopters after Claude Desktop.

Concept Card
JSON
// .cursor/mcp.json in your project root
{
  "mcpServers": {
    "database": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_URL": "postgresql://localhost/mydb"
      }
    },
    "docs": {
      "command": "python",
      "args": ["-m", "my_docs_server"]
    }
  }
}

Supported primitives: Tools (primary), Resources (limited) Transport: stdio Notable feature: MCP tools integrate directly into the AI coding assistant, letting the AI query databases, read documentation, and interact with external services while helping you code.

VS Code with GitHub Copilot

Microsoft added MCP support to VS Code through the GitHub Copilot extension.

JSON
// .vscode/mcp.json
{
  "servers": {
    "my-server": {
      "type": "stdio",
      "command": "node",
      "args": ["./my-mcp-server/index.js"]
    }
  }
}

Supported primitives: Tools, Resources Transport: stdio, Streamable HTTP Notable feature: MCP servers can be configured per-workspace, making it easy to have project-specific tool sets.

Windsurf (Codeium)

Windsurf's Cascade AI agent supports MCP for extending its coding capabilities.

JSON
// ~/.codeium/windsurf/mcp_config.json
{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "some-mcp-server"],
      "env": {}
    }
  }
}

Supported primitives: Tools Transport: stdio Notable feature: Deep integration with Windsurf's agentic coding flows.

Other Notable Hosts

| Host                | Type           | MCP Support Level  |
|---------------------|----------------|--------------------|
| Zed Editor          | Code Editor    | Tools, Resources   |
| Cline (VS Code ext) | Coding Agent  | Full               |
| Continue (VS Code)  | AI Assistant   | Tools              |
| Sourcegraph Cody   | Code Search    | Tools              |
| JetBrains IDEs     | Code Editor    | Tools (plugin)     |
| ChatGPT Desktop    | AI Chat        | Tools              |
| Raycast AI         | Launcher       | Tools              |
| LibreChat          | Open-source UI | Tools, Resources   |
Tip

When choosing a host for development and testing, Claude Desktop remains the best option because it supports all MCP primitives (tools, resources, and prompts) and provides the most mature developer experience. Use it as your primary testing environment even if your production target is a different host.

The MCP Server Landscape

The real power of MCP lies in its server ecosystem. Thousands of servers are available, ranging from official reference implementations to community-built integrations for nearly every service you can imagine.

Official Reference Servers

Anthropic maintains a set of reference servers that demonstrate best practices:

Tip

Use MCP Ecosystem Today in a low-risk branch or scratch project first. That keeps the lesson concrete without making your first attempt carry production pressure.

@modelcontextprotocol/server-filesystem
  Read, write, and manage local files
  Tools: read_file, write_file, list_directory, search_files, move_file

@modelcontextprotocol/server-github
  Full GitHub API access
  Tools: create_repository, search_repositories, create_issue,
         create_pull_request, get_file_contents, push_files

@modelcontextprotocol/server-postgres
  PostgreSQL database access
  Tools: query (read-only SQL execution)
  Resources: schema information for each table

@modelcontextprotocol/server-slack
  Slack workspace integration
  Tools: send_message, list_channels, search_messages, get_thread

@modelcontextprotocol/server-memory
  Knowledge graph-based persistent memory
  Tools: create_entities, create_relations, search_nodes, open_nodes

@modelcontextprotocol/server-puppeteer
  Browser automation
  Tools: navigate, screenshot, click, fill, evaluate

@modelcontextprotocol/server-fetch
  HTTP fetching with content extraction
  Tools: fetch (retrieves and converts web pages to markdown)

@modelcontextprotocol/server-sqlite
  SQLite database access
  Tools: read_query, write_query, create_table, list_tables, describe_table

Installing a Reference Server

Every reference server can be run instantly with npx (no installation needed):

Bash
# Test the filesystem server
npx -y @modelcontextprotocol/server-filesystem /path/to/directory

# Test the GitHub server (needs token)
GITHUB_TOKEN=ghp_xxx npx -y @modelcontextprotocol/server-github

# Test the PostgreSQL server
POSTGRES_URL=postgresql://localhost/mydb npx -y @modelcontextprotocol/server-postgres

Community Server Highlights

The community has built MCP servers for virtually every popular service and use case. Here are some standout categories:

Developer Tools

Server                          What It Does
--------------------------------------------------------------------
@anthropic/server-linear        Linear issue tracking (create, search, update issues)
docker-mcp                      Manage Docker containers and images
server-kubernetes               Kubernetes cluster management
mcp-server-git                  Git operations (diff, log, commit, branch)
server-sentry                   Sentry error tracking integration
server-datadog                  Datadog monitoring and metrics

Databases and Data

Server                          What It Does
--------------------------------------------------------------------
server-mysql                    MySQL database queries
server-mongodb                  MongoDB document operations
server-redis                    Redis key-value operations
server-elasticsearch            Elasticsearch search and indexing
server-bigquery                 Google BigQuery analytics
server-snowflake                Snowflake data warehouse queries

Communication and Productivity

Server                          What It Does
--------------------------------------------------------------------
server-google-drive             Google Drive file management
server-notion                   Notion page and database operations
server-gmail                    Email reading and sending
server-calendar                 Google Calendar management
server-todoist                  Todoist task management
server-confluence               Confluence wiki operations
server-jira                     Jira issue tracking

Cloud Providers

Server                          What It Does
--------------------------------------------------------------------
server-aws                      AWS service management (S3, Lambda, EC2)
server-gcp                      Google Cloud Platform operations
server-azure                    Microsoft Azure resource management
server-vercel                   Vercel deployment management
server-cloudflare               Cloudflare Workers and DNS management
server-supabase                 Supabase database and auth management

AI and Machine Learning

Server                          What It Does
--------------------------------------------------------------------
server-huggingface              HuggingFace model and dataset search
server-wandb                    Weights & Biases experiment tracking
server-langchain                LangChain integration tools
server-pinecone                 Pinecone vector database operations
server-chromadb                 ChromaDB vector store management
Warning

Not all community MCP servers are production-ready. Before using a community server with sensitive data, review the source code, check the license, verify the maintainer's reputation, and understand what permissions it requires. MCP servers can execute code and access your systems -- treat them with the same caution you would give any third-party dependency.

Finding MCP Servers

Several directories and registries help you discover MCP servers:

MCP Server Directories

1. github.com/modelcontextprotocol/servers
   The official repository with reference servers and a
   curated list of community servers.

2. mcp.so
   Community directory with search, categories, and ratings.
   Lists thousands of servers with installation instructions.

3. glama.ai/mcp/servers
   Another popular directory with filtering and sorting.

4. smithery.ai
   MCP server registry with one-click installation support.

5. npm / PyPI search
   Search "mcp-server" on npm or "mcp" on PyPI for
   published packages.

How to Evaluate an MCP Server

Before adopting a server, check these criteria:

Python
# Your MCP server evaluation checklist

evaluation = {
    "maintenance": {
        "last_commit": "< 30 days ago?",
        "open_issues": "Are they being addressed?",
        "stars": "Community interest indicator",
        "contributors": "Bus factor > 1?",
    },
    "quality": {
        "readme": "Clear installation and usage docs?",
        "tests": "Does it have automated tests?",
        "error_handling": "Graceful failures?",
        "type_safety": "TypeScript or typed Python?",
    },
    "security": {
        "permissions": "What does it access?",
        "env_vars": "What secrets does it need?",
        "network": "Does it phone home?",
        "license": "Compatible with your use case?",
    },
    "compatibility": {
        "transport": "stdio? HTTP? Both?",
        "mcp_version": "Latest spec version?",
        "host_tested": "Tested with your host?",
    }
}

Ecosystem Growth Numbers

The MCP ecosystem has grown explosively. Here are some data points that illustrate the trajectory:

Metric                          Nov 2024    Mar 2025    Jan 2026
------------------------------------------------------------------
Official reference servers      ~20         ~30         ~40
Community servers (estimated)   ~50         ~1,000      ~10,000+
npm packages with "mcp"         ~30         ~500        ~3,000+
PyPI packages with "mcp"        ~10         ~200        ~1,500+
GitHub repos mentioning MCP     ~200        ~5,000      ~50,000+
MCP-compatible hosts            1           5           20+
Companies using MCP internally  ~10         ~100        ~1,000+

10,000+

Community MCP Servers

From 50 servers at launch to over 10,000 in just 14 months -- driven by network effects, low barriers to entry, and corporate backing

Why the Growth is Accelerating

Three factors drive the exponential adoption:

1. Network Effects Every new MCP server makes every MCP host more valuable (more tools to connect to). Every new host makes every server more valuable (more applications that can use it). This creates a classic platform flywheel.

More servers -> More useful hosts -> More users -> More servers
     ^                                                  |
     |__________________________________________________|

2. Low Barrier to Entry Building an MCP server is remarkably easy. With FastMCP in Python, you can go from zero to a working server in under 20 lines of code:

Add One MCP Ecosystem Today Connection

  1. Choose one external system that would genuinely improve this lesson's workflow.
  2. Configure an MCP server or inspect the one your team already uses.
  3. Ask Claude to call exactly one tool from that server and verify the result is useful.
Python
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("My First Server")

@mcp.tool()
def greet(name: str) -> str:
    """Say hello to someone."""
    return f"Hello, {name}!"

if __name__ == "__main__":
    mcp.run()

Compare this to building a REST API (routing, middleware, serialization, documentation, authentication) and you see why adoption is fast.

3. Corporate Backing When Anthropic, OpenAI, Google, and Microsoft all support the same protocol, it sends a clear signal to the industry. Enterprises that were hesitant to adopt a "single-vendor" protocol now see MCP as a safe, multi-vendor standard.

Enterprise Adoption Patterns

Enterprises are adopting MCP in several distinct patterns:

Pattern 1: Internal Tool Standardization

Large companies are building internal MCP servers to expose their proprietary systems to AI assistants:

Company's Internal MCP Servers:
  - mcp-server-internal-wiki      (Confluence/Notion wrapper)
  - mcp-server-deploy-pipeline    (CI/CD integration)
  - mcp-server-oncall             (PagerDuty + runbooks)
  - mcp-server-customer-data      (CRM access with PII controls)
  - mcp-server-analytics          (Internal dashboards and metrics)

This lets employees use Claude, Copilot, or any MCP-compatible AI to interact with all internal systems through a single, standardized interface.

Pattern 2: Customer-Facing AI

Companies are building MCP servers that their customers can connect to:

Quick Check

What is the main benefit of using MCP Ecosystem Today well in Claude Code?

SaaS Company exposes:
  - Tools: create_ticket, update_status, run_report
  - Resources: api-docs://endpoints, schema://data-model
  - Prompts: troubleshoot, generate-report, onboard-user

Customer connects in Claude Desktop and says:
  "Show me all critical tickets from the last week
   and draft a status update for leadership."

The AI uses the MCP tools to fetch tickets and
generate the report -- no custom integration needed.

Pattern 3: AI Agent Infrastructure

Companies building AI agents use MCP as the standard tool interface:

Python
# An AI agent framework using MCP for tool access
class AIAgent:
    def __init__(self):
        self.mcp_clients = {
            "code": MCPClient("server-github"),
            "deploy": MCPClient("server-kubernetes"),
            "monitor": MCPClient("server-datadog"),
            "notify": MCPClient("server-slack"),
        }

    async def handle_incident(self, alert):
        # Agent uses MCP tools across multiple servers
        # to investigate and resolve incidents autonomously
        logs = await self.mcp_clients["monitor"].call_tool(
            "get_logs", {"service": alert.service, "timeframe": "1h"}
        )
        # ... agent reasons and takes action

The Specification and Governance

Current Spec Version

The MCP specification is versioned and actively evolving:

Spec version: 2025-03-26 (latest stable)

Core features:
  - JSON-RPC 2.0 message format
  - stdio and Streamable HTTP transports
  - Tools, Resources, Prompts primitives
  - Sampling (server-initiated LLM calls)
  - Roots (filesystem access boundaries)
  - Logging and progress notifications
  - Capability negotiation
  - Tool annotations (readOnly, destructive, etc.)

Governance: The Linux Foundation

MCP is governed as an open standard. The specification, SDKs, and reference servers are all open source. The move toward Linux Foundation governance ensures no single company controls the protocol's direction.

Key repositories:
  github.com/modelcontextprotocol/specification  (The spec itself)
  github.com/modelcontextprotocol/python-sdk     (Python SDK)
  github.com/modelcontextprotocol/typescript-sdk  (TypeScript SDK)
  github.com/modelcontextprotocol/servers         (Reference servers)
  github.com/modelcontextprotocol/inspector       (Testing tool)

SDKs and Developer Tools

Official SDKs

Python SDK (mcp)
  pip install mcp
  Includes FastMCP high-level framework
  Async-first design with full type hints

TypeScript SDK (@modelcontextprotocol/sdk)
  npm install @modelcontextprotocol/sdk
  Full protocol implementation
  Works in Node.js and Deno

Kotlin SDK
  For JVM-based server implementations

C# SDK
  For .NET ecosystem integration

MCP Inspector

The Inspector is an essential development tool -- a web-based interface for testing MCP servers:

Bash
# Launch the Inspector
npx @modelcontextprotocol/inspector

# Connect to a running server
npx @modelcontextprotocol/inspector npx -y @modelcontextprotocol/server-filesystem /tmp

The Inspector lets you:

  • See all tools, resources, and prompts a server exposes
  • Call tools with custom arguments and see results
  • Browse resources and their contents
  • Test prompt templates with different arguments
  • View raw JSON-RPC messages for debugging
Tip

Make the MCP Inspector your best friend during development. It is far faster to test tools in the Inspector than to restart Claude Desktop every time you make a change. We will set it up in the next lesson.

What is Coming Next

The MCP ecosystem is evolving rapidly. Here are trends to watch:

Adopting Community Servers

Do

Evaluate community servers for maintenance, security, and compatibility before using them in production

Don't

Blindly install community MCP servers with sensitive data access without reviewing source code and permissions

Remote Servers and Authentication

The Streamable HTTP transport enables remote MCP servers with OAuth 2.0 authentication. This opens the door to hosted MCP server marketplaces where you can subscribe to servers as services.

MCP Registries

Standardized server registries will make discovering and installing MCP servers as easy as npm install. Think of it as a package manager for AI capabilities.

Agent-to-Agent Communication

MCP is being extended to support AI agents communicating with each other through MCP servers, enabling multi-agent workflows where specialized agents collaborate on complex tasks.

Streaming and Real-Time Data

Enhanced support for streaming responses and real-time data feeds through MCP, enabling use cases like live monitoring dashboards and event-driven AI responses.

Try This Now

Browse the MCP server directory at mcp.so and find three servers that would be useful for your work. For each one, write down: (1) what tools it exposes, (2) what host you would use it with, and (3) what workflow it would improve. Then install one of them in Claude Desktop and try using it in a real conversation. There is no better way to understand the ecosystem than to experience it firsthand.

Key Takeaways

  • MCP has been adopted by every major AI platform: Claude, ChatGPT, VS Code Copilot, Cursor, Windsurf, and more
  • Thousands of MCP servers exist for databases, cloud providers, developer tools, communication platforms, and more
  • Official reference servers from Anthropic cover common use cases like filesystem, GitHub, PostgreSQL, and Slack
  • The ecosystem benefits from strong network effects: more servers make hosts more valuable and vice versa
  • Enterprise adoption follows three patterns: internal tool standardization, customer-facing AI, and agent infrastructure
  • The MCP specification is open source and governed through the Linux Foundation
  • Always evaluate community servers for quality, security, and maintenance before using them in production
PreviousMCP vs REST APIs vs Function CallingNextSetting Up Your MCP Development Environment