Infrastructure Lab - Chapter 11

Build Your First MCP Server

The Model Context Protocol (MCP) is becoming the "HTTP of AI" - a standard way for AI systems to access tools and data. Learn how to build your own MCP server.

What is MCP?

The Model Context Protocol standardizes how AI assistants connect to external tools, data sources, and services. Think of it as giving your AI superpowers.

Connect AI to your databases & APIs
Create reusable tools across projects
Build enterprise-grade AI infrastructure

MCP Architecture (Model Agnostic)

┌─────────────┐     ┌─────────────┐
│   AI Host   │────▶│ MCP Server  │
│  (Any LLM)  │◀────│  (Your App) │
└─────────────┘     └─────────────┘
       │                   │
       │    JSON-RPC       │
       │    Protocol       │
       ▼                   ▼
  ┌─────────┐       ┌───────────┐
  │ Tools   │       │ Resources │
  │ Prompts │       │ Data      │
  └─────────┘       └───────────┘

When to Choose Each Technology

Choose TypeScript when:

- Your team already uses Node.js/JavaScript
- Building web-integrated MCP servers
- Need strong typing for large codebases
- Want excellent IDE support & tooling
- Deploying to serverless (Vercel, AWS Lambda)

Choose Python when:

- Working with data science / ML pipelines
- Integrating with existing Python services
- Need rich ecosystem (pandas, numpy, etc.)
- Rapid prototyping is priority
- Team is more comfortable with Python

TypeScript MCP Server

Initialize Your Project

# Create project directory
mkdir my-mcp-server && cd my-mcp-server

# Initialize with npm
npm init -y

# Install MCP SDK and TypeScript
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node tsx

# Initialize TypeScript
npx tsc --init

Create Your MCP Server

Create src/index.ts:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// Create the MCP server instance
const server = new McpServer({
  name: "my-first-mcp-server",
  version: "1.0.0",
});

// Define a simple tool: get current time
server.tool(
  "get_current_time",
  "Returns the current date and time",
  {
    timezone: z.string().optional().describe("Timezone (e.g., 'UTC', 'America/New_York')"),
  },
  async ({ timezone }) => {
    const now = new Date();
    const options: Intl.DateTimeFormatOptions = {
      timeZone: timezone || "UTC",
      dateStyle: "full",
      timeStyle: "long",
    };
    return {
      content: [{
        type: "text",
        text: now.toLocaleString("en-US", options)
      }],
    };
  }
);

// Define a tool: simple calculator
server.tool(
  "calculate",
  "Performs basic arithmetic operations",
  {
    operation: z.enum(["add", "subtract", "multiply", "divide"]),
    a: z.number().describe("First number"),
    b: z.number().describe("Second number"),
  },
  async ({ operation, a, b }) => {
    let result: number;
    switch (operation) {
      case "add": result = a + b; break;
      case "subtract": result = a - b; break;
      case "multiply": result = a * b; break;
      case "divide":
        if (b === 0) throw new Error("Division by zero");
        result = a / b;
        break;
    }
    return {
      content: [{ type: "text", text: `Result: ${result}` }],
    };
  }
);

// Start the server
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("MCP Server running...");
}

main().catch(console.error);

Configure & Run

Add to your package.json:

{
  "scripts": {
    "start": "tsx src/index.ts",
    "build": "tsc"
  }
}

Run your server:

npm start

Python MCP Server

Set Up Your Environment

# Create project directory
mkdir my-mcp-server && cd my-mcp-server

# Create virtual environment (recommended)
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install MCP SDK
pip install mcp

Create Your MCP Server

Create server.py:

from datetime import datetime
from zoneinfo import ZoneInfo
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent

# Create the MCP server instance
server = Server("my-first-mcp-server")

# Define available tools
@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="get_current_time",
            description="Returns the current date and time",
            inputSchema={
                "type": "object",
                "properties": {
                    "timezone": {
                        "type": "string",
                        "description": "Timezone (e.g., 'UTC', 'America/New_York')"
                    }
                }
            }
        ),
        Tool(
            name="calculate",
            description="Performs basic arithmetic operations",
            inputSchema={
                "type": "object",
                "properties": {
                    "operation": {
                        "type": "string",
                        "enum": ["add", "subtract", "multiply", "divide"]
                    },
                    "a": {"type": "number", "description": "First number"},
                    "b": {"type": "number", "description": "Second number"}
                },
                "required": ["operation", "a", "b"]
            }
        )
    ]

# Handle tool calls
@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "get_current_time":
        tz = arguments.get("timezone", "UTC")
        try:
            now = datetime.now(ZoneInfo(tz))
            return [TextContent(
                type="text",
                text=now.strftime("%A, %B %d, %Y at %I:%M:%S %p %Z")
            )]
        except Exception as e:
            return [TextContent(type="text", text=f"Error: {e}")]

    elif name == "calculate":
        op = arguments["operation"]
        a, b = arguments["a"], arguments["b"]

        if op == "add": result = a + b
        elif op == "subtract": result = a - b
        elif op == "multiply": result = a * b
        elif op == "divide":
            if b == 0:
                return [TextContent(type="text", text="Error: Division by zero")]
            result = a / b

        return [TextContent(type="text", text=f"Result: {result}")]

    return [TextContent(type="text", text=f"Unknown tool: {name}")]

# Run the server
async def main():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            server.create_initialization_options()
        )

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

Run Your Server

python server.py

MCP is AI Model Agnostic

Important: The Model Context Protocol is an open standard - not tied to any specific AI provider. Your MCP server works with any AI host that implements the protocol:

Currently Supported:

- Claude Desktop & Claude Code
- Cursor IDE
- Zed Editor
- Continue (VS Code)

Growing Ecosystem:

- OpenAI integration (coming)
- Custom AI applications
- Enterprise AI platforms
- Your own AI hosts

Build once, connect to any MCP-compatible AI system. That's the power of an open protocol.

Example: Connect to Claude Desktop

Optional - One of Many Hosts

This shows how to connect to Claude Desktop as an example. Each MCP-compatible host has its own configuration method.

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "my-mcp-server": {
      "command": "npx",
      "args": ["tsx", "/path/to/your/src/index.ts"]
    }
  }
}

For Python, use: "command": "python", "args": ["/path/to/server.py"]

What You've Built

A working MCP server with 2 tools
Input validation with schemas
Error handling patterns
Foundation for enterprise tools

Go Deeper in Chapter 11

This lab covers the basics. The book teaches you:

- Resources & dynamic data exposure
- Prompt templates as MCP services
- Authentication & security patterns
- Enterprise deployment strategies
- Multi-server orchestration

Get the Full Guide

"Just as HTTP standardized web communication, MCP standardizes AI-to-system communication. Early adopters gain years of advantage."

- From Blueprint to Application, Chapter 11