MCP (Model Context Protocol)

What is MCP

MCP is a standardized protocol that enables AI models to securely connect to external data sources and tools through a client-server architecture.

It is an open standard created by Anthropic, but it's not specific to Claude at all. Developers can build MCP servers (tools) once, and those tools can then work with any AI that supports the protocol.

Below is a diagram showing how MCP fits in the AI system architecture (e.g. Claude):

┌─────────────────────────────────────────────────────┐
│                    YOU (Human)                      │
└────────────────────┬────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────┐
│              Claude (AI Assistant)                  │
│  ┌───────────────────────────────────────────────┐  │
│  │   Claude Sonnet 4.5 Model (The Brain)         │  │
│  │   • Thinks and reasons                        │  │
│  │   • Generates responses                       │  │
│  └───────────────────────────────────────────────┘  │
└────────────────────┬────────────────────────────────┘
                     │
                     │ Uses tools via...
                     ▼
┌─────────────────────────────────────────────────────┐
│            MCP (Model Context Protocol)             │
│         (The "Connector" / "App Store")             │
└────┬────────────┬────────────┬───────────┬──────────┘
     │            │            │           │
     ▼            ▼            ▼           ▼
┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐
│ Dropbox │  │  Local  │  │Database │  │ Custom  │
│ Server  │  │  Files  │  │ Server  │  │  APIs   │
│         │  │ Server  │  │         │  │         │
└─────────┘  └─────────┘  └─────────┘  └─────────┘
   (Tool)       (Tool)       (Tool)       (Tool)

MCP Architecture

Visual

                    ┌─────────────────┐
                    │      USER       │
                    └────────┬────────┘
                             │
                             ▼
    ┌────────────────────────────────────────────────┐
    │              MCP HOST                          │
    │  (Claude Desktop, IDEs, Custom Apps)           │
    │                                                │
    │  ┌──────────────────────────────────────────┐  │
    │  │        AI MODEL (Claude, GPT, etc)       │  │
    │  └──────────────────────────────────────────┘  │
    │                                                │
    │  ┌──────────────────────────────────────────┐  │
    │  │         MCP CLIENT                       │  │
    │  │  • Sends requests                        │  │
    │  │  • Receives responses                    │  │
    │  └──────────────────────────────────────────┘  │
    └────────────────┬───────────────────────────────┘
                     │
                     │ MCP Protocol
                     │ (JSON-RPC over stdio/HTTP)
                     │
         ┌───────────┼───────────┬──────────────┐
         │           │           │              │
         ▼           ▼           ▼              ▼
    ┌─────────┐ ┌─────────┐ ┌─────────┐  ┌─────────┐
    │   MCP   │ │   MCP   │ │   MCP   │  │   MCP   │
    │ SERVER  │ │ SERVER  │ │ SERVER  │  │ SERVER  │
    │    1    │ │    2    │ │    3    │  │    N    │
    └────┬────┘ └────┬────┘ └────┬────┘  └────┬────┘
         │           │           │              │
         ▼           ▼           ▼              ▼
    ┌─────────┐ ┌─────────┐ ┌─────────┐  ┌─────────┐
    │Dropbox  │ │  Local  │ │Database │  │ Custom  │
    │   API   │ │  Files  │ │         │  │   Tool  │
    └─────────┘ └─────────┘ └─────────┘  └─────────┘

Flow

User: "Add 5 and 3"
↓
Client → Model: "User wants to add 5 and 3"
↓
Model → Client: "I need to call the add tool"
↓
Client → Server:
  {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "add",
      "arguments": {
        "a": 5,
        "b": 3
      }
    }
  }
↓
Server → Client:
  {
    "jsonrpc": "2.0",
    "id": 1,
    "result": {
      "content": [
        {
          "type": "text",
          "text": "8"
        }
      ],
      "structuredContent": 8,
      "isError": false
    }
  }
↓
Client → User: "5 + 3 = 8"

Manual Implementation

code-examples/mcp/ - Educational example showing how MCP uses JSON-RPC protocol from scratch

FastMCP

FastMCP is a convenience wrapper that makes it easier to create MCP servers.

Code

class FastMCP(Generic[LifespanResultT]):
    def __init__(self, ...):
        # Creates a low-level MCPServer
        self._mcp_server = MCPServer(...)
        
    def _setup_handlers(self) -> None:
        """Set up core MCP protocol handlers."""
        self._mcp_server.list_tools()(self.list_tools)
        self._mcp_server.call_tool(validate_input=False)(self.call_tool)  # ← Key!

Flow

1. Client sends: {"method": "tools/list"}
   ↓
2. MCPServer receives the MCP protocol message
   ↓
3. MCPServer looks up: "What handler is registered for tools/list?"
   ↓
4. MCPServer finds: "Oh, it's FastMCP.list_tools"
   ↓
5. MCPServer calls: FastMCP.list_tools()
   ↓
6. FastMCP.list_tools() returns the tools
   ↓
7. MCPServer formats the response and sends it back

Example Usage

code-examples/fastmcp/ - Real MCP server using FastMCP framework

References

• Cursor with Claude Model
• MCP Python SDK https://github.com/modelcontextprotocol/python-sdk