Model Context Protocol (MCP)

The Model Context Protocol (MCP) is an open protocol for connecting AI clients to external tools and data sources. Use the current published specification and changelog rather than blog summaries when you need implementation detail.

Before MCP. Every AI app needed custom integrations with every tool. 10 apps x 100 tools = 1,000 integrations

With MCP. Each app implements MCP once, each tool implements MCP once. 10 apps + 100 tools = 110 implementations

What the current specification adds (2025-11-25)

The published specification and changelog matter more than ecosystem hype. By 2025-11-25, the protocol had formalised long-running operations, clearer transport guidance, stronger authentication expectations, and richer tool metadata. If you are about to build on MCP, read the current spec and the changelog before you assume a transport, auth flow, or client capability is stable.

Three core building blocks

MCP organises everything around three server-facing building blocks.

1. Resources provide data and context. Think of these as files, database records, or API responses that the AI can read.

2. Prompts are reusable templates. They help standardise how the AI interacts with specific tools or data.

3. Tools are executable functions. These are the actions the AI can take, from searching to writing to calculating.

Client support is expanding across desktop apps, IDEs, and custom agents, but availability is product-specific and changes quickly. Verify the current MCP support in each client's official documentation before you promise a workflow to users.

"""
Simple MCP Server
=================
An MCP server providing weather information.

Run with: python weather_mcp_server.py
Then connect from an MCP client.
"""

import asyncio
import json
from typing import Any, Dict
from dataclasses import dataclass


@dataclass
class Tool:
    """An MCP tool definition."""
    name: str
    description: str
    input_schema: Dict[str, Any]


class MCPServer:
    """Basic MCP Server implementation."""
    
    def __init__(self, name: str, version: str = "1.0.0"):
        self.name = name
        self.version = version
        self.tools: Dict[str, Tool] = {}
        self._tool_handlers: Dict[str, callable] = {}
    
    def register_tool(
        self,
        name: str,
        description: str,
        input_schema: Dict[str, Any],
        handler: callable
    ):
        """Register a tool with the server."""
        self.tools[name] = Tool(name, description, input_schema)
        self._tool_handlers[name] = handler
    
    async def handle_request(self, request: Dict) -> Dict:
        """Handle an incoming MCP request (JSON-RPC 2.0)."""
        method = request.get("method")
        params = request.get("params", {})
        request_id = request.get("id")
        
        if method == "tools/list":
            result = {
                "tools": [
                    {
                        "name": t.name,
                        "description": t.description,
                        "inputSchema": t.input_schema
                    }
                    for t in self.tools.values()
                ]
            }
        elif method == "tools/call":
            tool_name = params.get("name")
            arguments = params.get("arguments", {})
            
            if tool_name in self._tool_handlers:
                handler = self._tool_handlers[tool_name]
                result_data = handler(**arguments)
                result = {
                    "content": [{"type": "text", "text": json.dumps(result_data)}]
                }
            else:
                return {"error": {"code": -32601, "message": f"Unknown tool: {tool_name}"}}
        else:
            return {"error": {"code": -32601, "message": f"Unknown method: {method}"}}
        
        return {"jsonrpc": "2.0", "id": request_id, "result": result}


# Create server and register tools
server = MCPServer("weather-server")

WEATHER_DATA = {
    "london": {"temp": 12, "condition": "cloudy"},
    "paris": {"temp": 15, "condition": "sunny"},
    "tokyo": {"temp": 18, "condition": "clear"},
}

def get_weather(location: str) -> Dict:
    """Get weather for a location."""
    loc = location.lower()
    if loc in WEATHER_DATA:
        return {"location": location, **WEATHER_DATA[loc]}
    return {"error": f"No weather data for: {location}"}

server.register_tool(
    name="get_weather",
    description="Get current weather for a city",
    input_schema={
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City name"}
        },
        "required": ["location"]
    },
    handler=get_weather
)

Create a client-specific configuration file:

macOS: check the client documentation for the configuration path Windows: check the client documentation for the configuration path

{
  "mcpServers": {
    "weather": {
      "command": "python",
      "args": ["/path/to/weather_mcp_server.py"]
    }
  }
}

Restart the client. It now has access to your weather tools.