MCP: Model Context Protocol — Connecting AI to the Real World

1. The Problem Before MCP

Before MCP, every team connecting an LLM to external tools had to build their own integration layer. One team would write custom function-calling code to query a database; another would write a bespoke webhook to call a REST API; a third would build a file-reading adapter. None of these integrations were reusable across different LLMs or different clients.

The result was a fragmented ecosystem: N tools × M AI models = N×M custom integrations. Each integration was a custom piece of glue code with its own auth model, error handling, and schema format.

2. Architecture: Clients, Servers, and the Protocol

MCP has three key components: the Host (the application running the AI), the Client (an MCP client embedded in the host), and one or more MCP Servers (processes that expose tools, resources, and prompts).

3. The Three Primitives: Tools, Resources, and Prompts

MCP servers expose exactly three types of capabilities. Understanding the distinction is key to designing good MCP servers.

Tools (model-controlled actions)

Tools are functions the LLM can call. They have side effects — they read files, run queries, call APIs. The LLM decides when to call a tool based on the conversation. Each tool has a JSON Schema defining its inputs, which the client communicates to the LLM so it knows how to call it correctly.

{
  "name": "run_sql",
  "description": "Execute a read-only SQL query against the analytics database",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string", "description": "SQL SELECT statement" }
    },
    "required": ["query"]
  }
}

Resources (application-controlled data)

Resources are data that the host application (not the LLM) decides to include in context. Think file contents, database rows, a user's recent activity. Resources are URI-addressable: file:///path/to/doc.txt, database://mydb/users. The application pulls resources and stuffs them into the context window — the model doesn't trigger this, the app does.

Prompts (user-controlled templates)

Prompts are reusable, parameterised prompt templates stored on the server. They appear as slash commands or template options in the host UI. A "code review" prompt template could accept a diff as input and generate a structured review. Prompts are user-triggered, not LLM-triggered.

4. Transport: How Client and Server Communicate

MCP uses JSON-RPC 2.0 as its message format. Two transport layers are defined:

• stdio: The MCP server is a local process. The client communicates via standard input/output streams. Simplest to implement; used by most local MCP servers (filesystem, git, etc.). This is what Claude Desktop uses when you configure a local server.
• HTTP + Server-Sent Events (SSE): The server is a remote HTTP endpoint. The client sends requests as HTTP POST; the server pushes responses as SSE events. Used for cloud-hosted MCP servers that multiple clients share.

The message lifecycle follows three phases: initialize (client and server exchange capabilities), session (client calls tools, reads resources), and shutdown (clean disconnect).

5. Building Your First MCP Server

Here is a minimal MCP server in Python (using the official mcp SDK) that exposes one tool — a simple calculator:

from mcp.server import Server
from mcp.types import Tool, TextContent
import mcp.server.stdio as stdio_server

app = Server("my-calculator")

@app.list_tools()
async def list_tools():
    return [
        Tool(
            name="calculate",
            description="Evaluate a simple arithmetic expression",
            inputSchema={
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "e.g. '2 + 2', '100 * 0.18'"
                    }
                },
                "required": ["expression"]
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "calculate":
        # NEVER use eval() on untrusted input in production
        result = eval(arguments["expression"])
        return [TextContent(type="text", text=str(result))]
    raise ValueError(f"Unknown tool: {name}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(stdio_server.run(app))

Register this in Claude Desktop's config (claude_desktop_config.json) and Claude can use your calculator immediately, without any API key or cloud service:

{
  "mcpServers": {
    "my-calculator": {
      "command": "python",
      "args": ["/path/to/calculator_server.py"]
    }
  }
}

6. MCP vs Raw Function Calling: What's the Difference?

LLMs from OpenAI, Anthropic, and Google all support function calling — the ability to output structured JSON that invokes a developer-defined function. So why do we need MCP on top of that?

7. The Ecosystem in 2026

MCP has seen rapid adoption since its open-source release in late 2024. The official MCP servers registry now lists hundreds of community-maintained servers, covering:

• Developer tools: GitHub, GitLab, Jira, Linear, Sentry
• Databases: PostgreSQL, SQLite, MongoDB, Supabase
• Productivity: Google Drive, Notion, Slack, Calendar
• Infrastructure: Kubernetes, AWS, GCP, Terraform
• Data / analytics: BigQuery, dbt, Snowflake

MCP clients are now built into Claude Desktop, VS Code (via extensions), Cursor, and Zed. The pattern is consolidating: teams build MCP servers once and make them available to all AI tools their developers use.

8. Security Considerations

MCP's process isolation is a security feature, but it doesn't protect against all threats:

Additional security best practices:

• Least privilege per server — the GitHub MCP server should not have file system access
• No write access by default — require explicit user confirmation for destructive operations (delete, send, publish)
• Audit logging — log every tool call with timestamp, tool name, and arguments
• Rate limiting — prevent runaway agentic loops from hammering downstream APIs

9. Getting Started: The 15-Minute Path

1. Install Claude Desktop (free) — it ships with MCP client support built-in
2. Add the filesystem server — edit claude_desktop_config.json to point at a directory on your machine
3. Ask Claude: "Read the README.md file in my project directory and summarise the setup steps"
4. Build your first server — use the Python or TypeScript SDK, expose one tool, reload Claude Desktop

The SDK handles the JSON-RPC boilerplate. You only write the business logic: define the tool schema, implement the handler. Most simple MCP servers are under 100 lines of code.