MCP Ecosystem Overview

+15 Mana ✨
MCP Quickstart Guide(DOCUMENTATION)Example MCP Servers(DOCUMENTATION)TypeScript SDK Documentation(DOCUMENTATION)

Introduction

MCP is more than a specification — it is an ecosystem of hosts, clients, servers, SDKs, and community resources. Understanding the landscape helps you know what already exists, what you can use out of the box, and where you might contribute. This lesson maps out the key players, popular servers, registries, and the versioning model that keeps everything compatible.

Key Concepts

  • Hosts: Applications that run LLMs and manage MCP connections. Claude Desktop, Claude Code, VS Code (GitHub Copilot), Cursor, Windsurf, and Cline are all MCP hosts.
  • Servers: Programs that expose tools, resources, and prompts through the MCP protocol. The community has built servers for file systems, GitHub, PostgreSQL, Slack, Google Drive, and many more.
  • SDKs: Official libraries for building MCP servers and clients. The TypeScript SDK and Python SDK are the most widely used.
  • Registries: Directories where developers discover and share MCP servers, similar to npm for Node packages.
  • Spec Versioning: The MCP specification is versioned by date. The current version is 2025-11-25. Clients and servers negotiate versions during the initialization handshake.

Real World Context

A developer using Claude Code wants to give the AI access to their PostgreSQL database and GitHub repositories. Instead of writing custom code, they configure two existing MCP servers: the PostgreSQL server and the GitHub server. Claude Code connects to both through MCP, discovers the available tools, and can now query the database and create pull requests — all through the standard protocol. This took configuration, not code.

Similarly, a team building an internal chatbot uses the TypeScript SDK to create a custom MCP server that wraps their internal APIs. Any MCP-compatible host — Claude Desktop, Cursor, or their own application — can now use those internal tools without additional integration work.

Deep Dive

Popular MCP Servers

The community has built MCP servers for a wide range of tools and services:

text
Category          Server Examples
─────────────────────────────────────────────
File System       @modelcontextprotocol/server-filesystem
Version Control   @modelcontextprotocol/server-github
Databases         @modelcontextprotocol/server-postgres
Messaging         @modelcontextprotocol/server-slack
Cloud Storage     @modelcontextprotocol/server-gdrive
Search            @modelcontextprotocol/server-brave-search
Memory            @modelcontextprotocol/server-memory

Each of these servers exposes tools through MCP. The filesystem server provides tools like read_file, write_file, and list_directory. The GitHub server provides tools for creating issues, opening pull requests, and searching repositories.

MCP Hosts in the Wild

Different hosts integrate MCP in different ways:

text
Host              How MCP is Used
─────────────────────────────────────────────
Claude Desktop    Configure servers in settings JSON file
Claude Code       Configure via CLI or project config
VS Code           GitHub Copilot integrates MCP servers
Cursor            Built-in MCP support in settings
Windsurf          MCP server configuration in workspace
Cline             VS Code extension with MCP support

The pattern is consistent: you configure which MCP servers to connect to, and the host handles discovery, connection, and tool invocation.

The TypeScript SDK

The official TypeScript SDK provides everything needed to build MCP servers and clients:

typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "my-server",
  version: "1.0.0",
});

server.tool(
  "greet",
  "Greet a user by name",
  { name: z.string() },
  async ({ name }) => ({
    content: [
      { type: "text", text: `Hello, ${name}!` }
    ],
  })
);

const transport = new StdioServerTransport();
await server.connect(transport);

This minimal server exposes a single "greet" tool. Any MCP host can discover and call it.

Spec Versioning

The MCP specification uses date-based versioning (for example, 2025-11-25). During the initialization handshake, the client sends the protocol version it supports, and the server responds with the version it will use. This ensures backward compatibility as the spec evolves.

json
{
  "protocolVersion": "2025-11-25"
}

Both client and server must agree on the protocol version before communication can proceed. If they cannot agree, the connection fails gracefully.

MCP Registries and Discovery

MCP servers can be discovered through several channels: the official MCP servers repository on GitHub, npm packages with the @modelcontextprotocol scope, and community-maintained registries. As the ecosystem matures, automated discovery mechanisms are being developed to make it easier to find and install servers.

Common Pitfalls

  1. Building a server that already exists — Before writing a custom MCP server, check the official repository and npm for existing implementations. The community has already built servers for the most common tools and services.
  2. Ignoring spec versions — The MCP specification evolves. Servers built against older spec versions may not support newer features. Always check the protocol version your host supports and build against a compatible spec version.

Best Practices

  1. Use official SDKs — The TypeScript and Python SDKs handle protocol details, serialization, and transport layers for you. Building directly on the raw JSON-RPC specification is error-prone and unnecessary.
  2. Keep servers focused — Each MCP server should expose a cohesive set of tools around a single domain (file system, database, messaging). Avoid building monolithic servers that try to do everything.
  3. Pin your spec version — Declare which MCP specification version your server targets. This helps hosts negotiate compatibility during the initialization handshake.

Summary

  • The MCP ecosystem consists of hosts (Claude Desktop, VS Code, Cursor), servers (filesystem, GitHub, PostgreSQL), and SDKs (TypeScript, Python).
  • Popular MCP servers already exist for file systems, version control, databases, messaging, and more.
  • The TypeScript SDK makes it straightforward to build custom MCP servers with just a few lines of code.
  • The specification is versioned by date (current: 2025-11-25), and clients and servers negotiate versions during connection.
  • Developers use MCP day-to-day by configuring pre-built servers in their AI hosts, and building custom servers with the SDK when needed.

Code Examples

typescript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "weather-server",
  version: "1.0.0",
});

server.tool(
  "get_weather",
  "Get the current weather for a city",
  { city: z.string().describe("City name") },
  async ({ city }) => ({
    content: [
      { type: "text", text: `Weather in ${city}: 22°C, sunny` }
    ],
  })
);

const transport = new StdioServerTransport();
await server.connect(transport);
✓ Completed