What is Model Context Protocol (MCP)?

Model Context Protocol (MCP) represents a groundbreaking standardization effort in the AI ecosystem, primarily championed by Anthropic. It defines a universal interface for large language models (LLMs) and AI applications—known as MCP clients—to interact with external services and resources through MCP servers. Think of it as a bridge that extends the capabilities of AI beyond their training data, allowing real-time access to files, databases, web searches, and custom tools without custom integrations for each model.

Unlike traditional tool-calling mechanisms, which often require model-specific prompts or APIs, MCP operates on a protocol level. It uses JSON-RPC 2.0 over standard input/output (stdio) or HTTP transports, making it interoperable across different AI providers. This means a single MCP server can serve multiple clients, from Claude Desktop to custom Python scripts, fostering a growing ecosystem of reusable components.

For beginners, imagine MCP as USB for AI: plug in a server for file access, and your AI can read/write documents just like plugging in a flash drive. As we progress, you'll see how this scales to enterprise-grade workflows.

Why MCP Matters: Key Benefits and Use Cases

MCP addresses core limitations in AI deployments:

• Scalability: No more reinventing tool integrations for each LLM.
• Security: Servers control access, enforcing permissions independently of the model.
• Modularity: Build once, use everywhere—servers expose capabilities via a consistent API.
• Real-World Applications:
  • Data Analysis: Connect to PostgreSQL for querying live databases.
  • Research: Use Brave Search server for up-to-date web info.
  • Development: Fileserver for editing codebases during agentic workflows.
  • Enterprise: Custom servers for CRM, Git repos, or internal APIs.

Early adopters report 5-10x faster prototyping for AI agents, as servers handle stateful interactions that stateless LLMs struggle with.

Anatomy of an MCP System

An MCP setup involves three core pieces:

1. MCP Client: The AI side (e.g., Claude Desktop, a Python client library). It discovers server capabilities and sends requests.
2. MCP Server: The service provider (e.g., fileserver, postgres). Implements the protocol to expose tools, resources, and notifications.
3. Transport Layer: Stdio for local (fast, secure) or HTTP/Streamable HTTP for remote (scalable).

Protocol Basics

MCP leverages JSON-RPC 2.0:

• Methods: tools/list, tools/call, resources/list, resources/read, notifications/publish.
• Capabilities Announcement: Servers declare what they offer via initialize response.
• Sessions: Stateful connections with session IDs for context persistence.

Here's a simplified JSON-RPC request example for listing tools:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {}
}

Response:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "read_file",
        "description": "Reads file content",
        "inputSchema": { "type": "object", "properties": { "path": { "type": "string" } } }
      }
    ]
  }
}

Getting Started: Setting Up Your First MCP Server

Prerequisites

• Python 3.10+
• Install the reference SDKs from the official repositories:
  • Servers: modelcontextprotocol/servers
  • Clients: modelcontextprotocol/clients
  • Specs: modelcontextprotocol/specifications

Run pip install mcp[cli] mcp-server-filesystem for basics.

Launch a Fileserver

The fileserver is perfect for beginners, granting safe file I/O.

1. Create a server config (fileserver.json):

{
  "root": "/path/to/your/workspace",
  "permissions": ["read", "write"]
}

1. Start the server:

mcp-server-filesystem --config fileserver.json

It listens on stdio. Pipe input/output for testing:

echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{"tools":{}}}' | mcp-server-filesystem

Connect with a Client

Use Claude Desktop (beta supports MCP natively) or a Python client.

Python example using the client SDK:

import asyncio
from mcp.client.stdio import stdio_client
from mcp.client.types import InitializeParams, ClientCapabilities

async def main():
    async with stdio_client() as (read, write):
        await write.Initialize(
            protocolVersion="2024-11-05",
            capabilities=ClientCapabilities(tools={})
        )
        result = await read.expect("initialized")
        print(result)

asyncio.run(main())

Pipe it to your server: python client.py | mcp-server-filesystem.

Exploring Pre-Built Servers

The ecosystem ships with production-ready servers:

• Filesystem Server (src/fileserver): Secure directory access with glob patterns, MIME detection.
• PostgreSQL Server (src/postgres): SQL execution, schema introspection. Conn string via env vars.
• Brave Search Server (src/brave-search): Real-time web queries with API key.
• Git Server: Repo cloning, diffing, committing.
• Memory Server: Persistent key-value store for agent state.

Each supports sampling (e.g., top-N resources) and pagination for large datasets.

Advanced Server Development

Build custom servers by subclassing FastMCP:

from mcp.server.fastmcp import FastMCP
from mcp.types import Tool

server = FastMCP("my-server")

@server.tool()
def custom_tool(input: str) -> str:
    return f"Processed: {input}"

server.run(transport="stdio")

Handle resources (blobs) and notifications (e.g., progress updates) similarly. For HTTP, use --transport http --port 8080.

MCP Clients in Action

Claude Desktop Integration

Download from Anthropic, add servers via settings: mcp add --transport stdio mcp-server-filesystem. In chat: @fileserver read /path/to/file.txt—Claude handles the protocol transparently.

Programmatic Clients

For agents, use libraries like mcp-client-claude or raw JSON-RPC loops. Maintain session state across calls for multi-turn interactions.

Example agent loop:

1. Initialize and list capabilities.
2. Prompt LLM with available tools/resources.
3. Parse tool calls, invoke server.
4. Feed results back to LLM.

Security and Best Practices

• Sandbox Servers: Run in containers; limit root paths.
• Capability Negotiation: Clients request only needed features.
• Authentication: HTTP servers support OAuth/JWT.
• Rate Limiting: Built-in for tools/resources.
• Debugging: --log-level debug; inspect JSON-RPC traces.

Common Pitfalls:

• Mismatched protocol versions (use "2024-11-05").
• Stdio buffering—use unbuffered pipes.
• Resource URIs: Prefix with scheme like filesystem:///path.

Scaling to Production

• Remote Servers: Deploy via Docker: modelcontextprotocol/servers images available.
• Orchestration: Kubernetes for multi-tenant servers.
• Federation: Clients connect to server registries.
• Monitoring: Prometheus endpoints in HTTP mode.

Future directions include WebSocket transport, richer schemas (Pydantic v2), and community servers for Slack, Notion, etc.

Hands-On Project: AI Code Editor

1. Start fileserver + git server.
2. Claude client: "Refactor main.py using git diff tools."
3. Watch MCP in action: list tools → call write_file → notify commit.

This workflow rivals Cursor/Continue.dev but is model-agnostic.

MCP is still evolving (spec v0.1), but its momentum promises to redefine AI extensibility. Dive into the servers repo and clients repo to contribute or experiment today.