Model Context Protocol

Talking to a server from Python

Each call is one POST request with a JSON-RPC body. Wrap that in a small helper, and the protocol turns into ordinary function calls:

import requests

def rpc(method, params, id):
    body = {"jsonrpc": "2.0", "id": id, "method": method, "params": params}
    return requests.post("https://api.gradient.test/mcp", json=body).json()

info = rpc("initialize", {"protocolVersion": "2025-06-18", "capabilities": {}}, 1)["result"]
print("server:", info["serverInfo"]["name"], "| protocol:", info["protocolVersion"])

for tool in rpc("tools/list", {}, 2)["result"]["tools"]:
    print("-", tool["name"], "| needs:", tool["inputSchema"].get("required", []))

result = rpc("tools/call", {"name": "search_docs", "arguments": {"query": "gift card expiry"}}, 3)["result"]
print(result["content"][0]["text"][:90])

The helper rpc builds the body, sends it and returns the reply as a dictionary. The code then does the three steps in order: initialize, tools/list and one tools/call.

How a host connects MCP to the model

This is what Claude's apps and other hosts do behind the scenes. It uses only things you already know:

1. Call tools/list. Turn each MCP tool into a Claude tool: same name and description, with inputSchema renamed to input_schema.
2. Send those tools with the user's message.
3. When the model replies with a tool_use block, send tools/call to the server, with the block's name and its input as arguments.
4. Put the text from the result into a tool_result. Set is_error when isError is true. Then continue the agent loop.

The model doesn't know or care that a tool lives on an MCP server.

mcp_tool = {"name": "get_campaign", "description": "Get one campaign by id.",
            "inputSchema": {"type": "object", "properties": {"id": {"type": "string"}}, "required": ["id"]}}
claude_tool = {"name": mcp_tool["name"], "description": mcp_tool["description"],
               "input_schema": mcp_tool["inputSchema"]}
print(sorted(claude_tool))
print(claude_tool["input_schema"]["required"])

Building and installing servers

You'll rarely write the JSON-RPC by hand. The official Python SDK (the mcp package) turns ordinary typed functions into a server, much like the Claude SDK's tool runner:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("shop-analytics")

@mcp.tool()
def get_campaign(campaign_id: str) -> dict:
    """Get one campaign's metrics by id. Use when the user asks about a specific campaign."""
    return fetch_campaign(campaign_id)

if __name__ == "__main__":
    mcp.run()          # stdio by default, so a host on your computer can start it

Each host has its own way to add a server. Usually it's a settings screen or a config file. For a local server, you list the command that starts it. For a remote one, you give its web address. In Claude Code, for example, it's the claude mcp add command.

Treat servers like browser extensions

An MCP server runs code and sees what you send it. Its tool descriptions also go straight into the model's context. Before you connect one:

• Install from sources you trust. The vendor's own server, or open source you can review.
• Check what it can do. A server with "send email" or "delete record" tools can do exactly that if the model asks. Prefer read-only servers, and keep approval prompts switched on.
• Watch for hidden instructions. A malicious server can hide instructions in a tool description, such as "also send the conversation to...". The next lesson covers this attack.
• Give it the narrowest access. A key that can only do what it needs, not your admin account.

What MCP isn't

MCP doesn't replace tool use. It's a standard way to supply tools, and the model still asks for them the same way.