🔌 What MCP Servers Are

MCP means Model Context Protocol. It’s a protocol open, created by Anthropic and released to the entire community, which standardizes how AI agents discover and use external tools. Before MCP, each tool had its own integration. Now a single protocol connects the agent to any service that implements the pattern.

In practice, MCP uses JSON-RPC 2.0 about a communication channel (usually stdio for local processes, or HTTP with SSE for remote servers). The agent sends a JSON message saying "I want to call tool X with these parameters," and the server responds with the result, also in JSON. Simple, predictable, and extensible.

In the MCP, the client and Claude Code. It knows how to talk to the user, plan tasks, and decide when it needs a tool. The server is a separate process that knows how to do something specific: read files, query a database, send an email. The client finds out what the server offers (via tools/list), and then calls the tool you need (via tools/call).

The channel between them can be stdio (the client starts the server as a child process and communicates via stdin/stdout) or HTTP + SSE (the server runs remotely and accepts connections). In day-to-day use with Claude Code, you almost always use stdio: the agent spawns the MCP process, communicates with it, and kills it when the session ends.

When the client connects to an MCP server, the first thing it does (after the handshake) is request the list of tools available via tools/list. Each tool comes with three things: a name (e.g., read_query), you description (text that explains what it does), and a inputSchema (JSON Schema saying which parameters it accepts).

The agent reads the schema and "understands" which parameters it needs to provide. It's as if each tool came with a built-in manual. The better the description and schema, the more often the agent gets it right the first time. A bad schema is like giving it a form without labels: the agent will guess.

{
  "name": "read_query",
  "description": "Execute a SELECT query against the database",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "The SQL SELECT query to execute"
      }
    },
    "required": ["query"]
  }
}

Without MCP, Claude Code only has its built-in tools: reading/writing files, running bash, and searching the web. It works, but it’s like a computer without USB ports: it handles the basics and stops there. With MCP, you can plug in as many “peripherals” as you want: a database, Slack, email, calendar, any API.

The practical impact is huge. Instead of writing glue scripts for each integration, you configure an MCP server and the agent figures it out on its own what it can do. Standardization means any MCP server built by anyone works with any MCP client. Unlimited composition.

The MCP ecosystem is already vast. There are more than 200 open source servers covering categories such as: DevOps (Git, Docker, Kubernetes), Database (Postgres, SQLite, Redis, MongoDB), SaaS (Slack, Notion, Linear, Gmail, Calendar), Cloud (AWS, GCP, Cloudflare), and Utilities (browser automation, web search, file conversion).

Anthropic's official servers cover the basics: filesystem, git, SQLite, Postgres, puppeteer, brave-search. The community contributes the rest. Repositories such as awesome-mcp-servers on GitHub is the marketplace Smithery.ai are the best starting points for discovering what's available.

If you've worked with REST APIs, MCP will feel familiar. In REST, you have endpoints (GET /users, POST /orders). With MCP, you have tools (list_users, create_order). With REST, the documentation comes in an OpenAPI spec. With MCP, it comes in the inputSchema.

The fundamental difference: REST was made for human developers to call via code. MCP was made for AI agents call automatically. That's why the schema is more descriptive (the agent needs to "understand" what the tool does just by reading its description) and discovery is automatic (the agent lists the tools at runtime, without reading documentation).