MCP servers and the Model Context Protocol

Chapter 8 · one tool, any model

The hour

• The problem MCP solves: portable tools
• Client / server, JSON-RPC over stdio
• The three primitives: tools, resources, prompts
• Build both sides from scratch — no SDK

The problem

Every framework has its own tool format. OpenAI schemas, Gemini FunctionDeclarations, the next one, the next.

The tool underneath is identical every time. You keep rewriting the wiring.

MCP in one breath

• A server exposes tools / resources / prompts
• A client wraps the model, discovers + invokes them
• Transport is JSON-RPC — stdio (local) or HTTP (remote)
• The model never knows MCP is involved

Write the tool once; any client, any model, can reach it.

The server (no model in sight)

if method == "tools/list":
    result = {"tools": _TOOLS}
elif method == "tools/call":
    payload = call(params["name"], params["arguments"])
    result = {"content": [{"type": "text", "text": json.dumps(payload)}]}

Reads JSON-RPC from stdin, writes to stdout. That's the stdio transport.

The handshake

self._req("initialize", {"protocolVersion": "2025-06-18",
                         "capabilities": {}, "clientInfo": {...}})
self._send({"jsonrpc": "2.0", "method": "notifications/initialized"})

initialize → reply → initialized notification. Then you can call.

One server, any model

# OpenAI: MCP tool -> function tool (JSON Schema is already the right shape)
{"type": "function", "name": t["name"], "parameters": t["inputSchema"]}

# Gemini: MCP tool -> FunctionDeclaration
types.FunctionDeclaration(name=t["name"], parameters=to_schema(t["inputSchema"]))

Only the translation changes. The server doesn't move.

Three primitives

• tools — actions the model invokes (tools/call)
• resources — read-only context pulled in (resources/read)
• prompts — server-owned templates (prompts/get)

Actions, context, instructions. A server's whole vocabulary.

Put it to work — three apps

• MCP tools — a weather-station server the model calls
• MCP resources — a support KB grounded from doc:// URIs
• MCP prompts — code review, where the server owns the prompt

One shared mcp_client.py. The servers are the interesting part.

Function calling vs MCP

Function calling: the format of a single tool call.

MCP: the whole lifecycle — discovery, invocation, results, errors — across many tools and many servers, model-agnostic.

Complementary, not competing.

Takeaway

MCP is JSON-RPC with a handshake and three verbs. Build a tool once, publish it as a server, and every MCP client — Claude Desktop, your IDE, this blog's /mcp — can reach it. Next: embeddings, and the road to retrieval.