Model Context Protocol (MCP)

MCP defines three primitive types that a server can expose to a client (the AI application):

The protocol lifecycle follows a simple handshake-then-operate pattern:

Explanation: This ratio measures how well a given MCP server satisfies an agent's tool requirements — a score of 1.0 means full coverage, 0 means the server provides nothing useful.

Explanation: End-to-end response time in an MCP system is the sum of model inference time, the protocol round-trip overhead, and the actual tool execution time — the last term often dominates for database or API calls.

The Message Flow

Every MCP interaction uses JSON-RPC 2.0 as its wire format. Here is a minimal real exchange: ```python

# What the MCP client sends to the server (JSON-RPC request) request = { "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": "read_file", "arguments": {"path": "/data/report.txt"} } }

# What the MCP server sends back response = { "jsonrpc": "2.0", "id": 1, "result": { "content": [ {"type": "text", "text": "Q3 revenue was $4.2M..."} ] } } ```

Building a Minimal MCP Server in Python

```python

# pip install mcp from mcp.server import Server from mcp.server.stdio import stdio_server from mcp import types

# 1. Create the server app = Server("my-first-mcp-server")

# 2. Declare a tool @app.list_tools() async def list_tools() -> list[types.Tool]: return [ types.Tool( name="add_numbers", description="Adds two integers and returns the result.", inputSchema={ "type": "object", "properties": { "a": {"type": "number"}, "b": {"type": "number"} }, "required": ["a", "b"] } ) ]

# 3. Implement the tool @app.call_tool() async def call_tool(name: str, arguments: dict): if name == "add_numbers": result = arguments["a"] + arguments["b"] return [types.TextContent(type="text", text=str(result))] raise ValueError(f"Unknown tool: {name}")

# 4. Run over stdio transport (Claude Desktop uses this) async def main(): async with stdio_server() as (read_stream, write_stream): await app.run(read_stream, write_stream, app.create_initialization_options()) import asyncio asyncio.run(main()) ```

Connecting a Client (e.g., with the Python SDK)

```python import asyncio from mcp import ClientSession, StdioServerParameters from mcp.client.stdio import stdio_client async def run(): server_params = StdioServerParameters( command="python", args=["my_server.py"] ) async with stdio_client(server_params) as (read, write): async with ClientSession(read, write) as session:

# Initialize handshake await session.initialize()

# Discover what tools are available tools = await session.list_tools() print("Available tools:", [t.name for t in tools.tools])

# Call a tool result = await session.call_tool("add_numbers", {"a": 3, "b": 4}) print("Result:", result.content[0].text) # "7" asyncio.run(run()) ```

Transport Layers

MCP supports two transports, each suited to different deployment scenarios: ``` stdio → Local servers (same machine, subprocess) Claude Desktop, local dev tools HTTP/SSE → Remote servers (networked services) Cloud APIs, shared enterprise tools ```

Function Calling and Tool Use · Retrieval-Augmented Generation · AI Agents and Agentic Systems · LangChain Framework · Multi-Agent Systems