Stage 11 — Model Context Protocol (MCP)

Model Context Protocol (MCP)  ·  Comprehensive Technical Training  ·  ⏱ 6–8 hours

Learning Objectives

By the end of this stage you will be able to:

• Understand MCP (Model Context Protocol) architecture
• Use MCP servers with OpenAI Agents SDK
• Build custom MCP servers for your tools
• Integrate multiple MCP servers in a single agent
• Deploy MCP servers for production use

Section 1: MCP Fundamentals

MCP is a protocol for standardized tool/resource communication between AI models and external services. Think of it as "USB-C for AI."

MCP Architecture

• Host: The LLM or agent using tools (your app)
• Client: Communicates with servers (embedded in host)
• Server: Provides tools/resources (separate process or remote)

Using MCP with OpenAI Agents SDK

from openai import OpenAI
from mcp import MCPClient

client = OpenAI()

# Connect to MCP server
mcp = MCPClient(server_url="http://localhost:3000")

# Discover tools from MCP server
tools = mcp.list_tools()

# Use tools in agent
agent = client.agents.create(
    model="gpt-4o",
    tools=tools,
)

# Execute
result = client.agents.execute(agent_id=agent.id, task="Use MCP tools to accomplish X")

Section 2: Building Custom MCP Servers

Define tools your agents can use by creating an MCP server:

from mcp.server import Server
from mcp.types import Tool, Resource

class MyMCPServer(Server):
    async def on_initialize(self):
        """Register tools when server starts"""
        pass

    def list_tools(self):
        """Advertise available tools"""
        return [
            Tool(
                name="fetch_user_data",
                description="Get user information from database",
                parameters={
                    "type": "object",
                    "properties": {
                        "user_id": {"type": "string", "description": "User ID"},
                    },
                    "required": ["user_id"],
                },
            ),
            Tool(
                name="update_user_data",
                description="Update user information",
                parameters={
                    "type": "object",
                    "properties": {
                        "user_id": {"type": "string"},
                        "data": {"type": "object"},
                    },
                    "required": ["user_id", "data"],
                },
            ),
        ]

    async def call_tool(self, name: str, args: dict):
        """Execute tool"""
        if name == "fetch_user_data":
            return fetch_from_db(args["user_id"])
        elif name == "update_user_data":
            return update_in_db(args["user_id"], args["data"])

# Run server
server = MyMCPServer()
server.run(host="127.0.0.1", port=3000)

Section 3: Multiple MCP Servers

Connect agents to multiple MCP servers for rich tool ecosystems:

# Connect to multiple servers
servers = [
    MCPClient(url="http://localhost:3000"),  # User database
    MCPClient(url="http://localhost:3001"),  # Billing system
    MCPClient(url="http://localhost:3002"),  # Email service
]

# Aggregate all tools
all_tools = []
for server in servers:
    all_tools.extend(server.list_tools())

# Agent can use any tool from any server
agent = create_agent_with_tools(all_tools)

Section 4: Security and Trust

• Verify server signatures to ensure authenticity
• Rate limit tool calls to prevent abuse
• Audit tool execution for compliance
• Use authentication tokens for remote servers

What's Next

Stage 12, the final stage, brings everything together: building production agentic systems with monitoring, deployment, and real-world considerations.