MCP Track — Building with the Model Context Protocol

What is MCP?

MCP (Model Context Protocol) is an open standard that defines how AI applications connect to external tools and data sources. Instead of every app reinventing its own plugin API, any MCP client (Claude Desktop, Cursor, your custom agent) can connect to any MCP server (GitHub, Postgres, your own service) using the same protocol.

Your App / IDE

MCP Host

Claude Desktop, Cursor, VS Code, or your own agent

⇄MCP Protocol
(JSON-RPC 2.0)

Protocol Bridge

MCP Client

Manages the connection, capability negotiation, and message routing

⇄stdio or
HTTP/SSE

Your Service

MCP Server

Exposes tools, resources, and prompts — one server per capability domain

Three Primitives — Tools, Resources, Prompts

🔧

Tools

Functions the AI can call — search a database, run a calculation, trigger an API. Like function calling, but over the network.

📄

Resources

Read-only data sources — files, database rows, API responses. The AI reads them into context without triggering side effects.

💬

Prompts

Reusable prompt templates exposed by the server. The host can insert them into conversations — server-side prompt management.

Two Transports

stdio (local)

Server runs as a subprocess of the host
Messages over stdin/stdout
Best for local tools: file access, shell commands, local databases
Zero network overhead, simplest to build
Can't be shared across multiple clients

HTTP + SSE (remote)

Server runs as a standalone HTTP service
Host POSTs requests, server streams responses via SSE
Best for shared tools: APIs, cloud databases, team-wide resources
Requires auth (OAuth 2.0)
Deployable to any cloud or VPS

Quick Start — Minimal MCP Server

# Install the MCP Python SDK
pip install mcp

# minimal_server.py — a tool-only MCP server over stdio
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("My First Server")

@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two integers together."""
    return a + b

@mcp.tool()
def get_weather(city: str) -> dict:
    """Return mock weather for a city."""
    return {"city": city, "temp_c": 22, "condition": "sunny"}

if __name__ == "__main__":
    mcp.run()              # stdio transport by default

# Run it: python minimal_server.py
# Test it: mcp dev minimal_server.py  (opens MCP Inspector)

No API key. No cloud. No authentication needed. The mcp SDK handles all protocol framing, JSON-RPC serialization, and capability negotiation for you. You just write Python functions with type hints.

Track Modules — Learning Path

TRACK 1 — PROTOCOL FOUNDATIONS

MODULE 00 · FOUNDATIONS

What is MCP? Protocol Overview

The MCP architecture in full: hosts, clients, servers, capability negotiation. JSON-RPC 2.0 wire format. How MCP differs from REST, GraphQL, and direct function calling. Real-world deployments (Claude Desktop, Cursor, GitHub Copilot).

~45 min Conceptual Protocol spec

MODULE 01 · FIRST SERVER

Your First MCP Server — Tools

Build a working MCP server using the mcp Python SDK. @mcp.tool() decorator, type hints as schema, stdio transport. Test locally with MCP Inspector. Both Python and TypeScript.

~60 min Beginner → Intermediate mcp · Python/TS

MODULE 02 · RESOURCES & PROMPTS

Resources & Prompts Primitives

The other two MCP primitives. @mcp.resource() for read-only data access (files, database rows, API snapshots). @mcp.prompt() for server-side prompt templates. When to use each vs tools.

~55 min Intermediate mcp · Resources · Prompts

TRACK 2 — TRANSPORT & DEPLOYMENT

MODULE 03 · HTTP/SSE TRANSPORT

HTTP/SSE Transport

Convert a stdio server to HTTP. Server-Sent Events for streaming, OAuth 2.0 for authentication, CORS configuration. Deploy to any cloud VPS or containerize with Docker. Share one server across multiple clients.

~70 min Intermediate FastAPI · OAuth 2 · Docker

MODULE 04 · MCP CLIENTS (HOSTS)

Building MCP Clients & Hosts

Write a custom MCP client that connects to multiple servers, aggregates their capabilities, and routes LLM tool calls. The host-side architecture. Auto-discovery, capability merging, fallback handling.

~65 min Intermediate → Advanced mcp · Anthropic API

TRACK 3 — SECURITY & INTEGRATION

MODULE 05 · SECURITY

MCP Security

OAuth 2.0 scopes, capability negotiation, server sandboxing. Prompt injection via malicious resource content. Tool call authorization patterns. What to audit before exposing an MCP server to the internet.

~60 min Advanced OAuth 2 · Security

MODULE 06 · CLAUDE CODE & IDE

MCP with Claude Code & IDEs

Wire up your MCP server to Claude Code via .claude/settings.json. Claude Desktop config. VS Code extension integration. Debug with MCP Inspector. Build a personal productivity server.

~55 min Intermediate Claude Code · VS Code

MODULE 07 · MULTI-SERVER ORCHESTRATION

Multi-Server Orchestration

Route requests across a fleet of specialized MCP servers. Discovery, load balancing, health checks. Build an agent that transparently uses servers for data, compute, and storage as separate capability domains.

~70 min Advanced Multi-server · Routing

TRACK 4 — PRODUCTION

MODULE 08 · PRODUCTION PATTERNS

Production MCP Patterns

Error handling and graceful degradation. Rate limiting per-client. Health checks and readiness probes. Structured logging for tool calls. Packaging as a Docker image and deploying to Cloud Run or any container host.

~65 min Advanced Docker · Cloud Run

Capstone Project

CAPSTONE · After MCP-04 + MCP-05

Full MCP Ecosystem — Data Agent with 3 Servers

Build a production-grade MCP system: a data server (UCC filing lookup via resources + tools), a compute server (entity matching, risk scoring), and a storage server (ChromaDB vector store for memory). Orchestrate all three from a custom Claude-based host. OAuth 2.0 authentication between servers.

5–6 hours 3 MCP servers Domain C · Claude API

Prerequisites

This track builds on function calling and agent fundamentals. Before MCP-04 (clients), you should understand the ReAct loop and tool use. You don't need the full main course — just these:

M05 — Function Calling

M06 — Multi-Tool Orchestration

M12 — ReAct Agent Loop

Python/TS basics — async/await

Module links point to the main course. If you're on the OS track, the same modules are available using Ollama + OpenAI SDK — the MCP server/client code is identical regardless of which LLM you use.

Install the MCP SDK

# Python SDK
pip install mcp                          # core protocol + FastMCP helpers

# TypeScript SDK
npm install @modelcontextprotocol/sdk    # official TS SDK

# MCP Inspector (dev tool — test servers interactively)
npm install -g @modelcontextprotocol/inspector
mcp dev your_server.py                  # opens browser UI to call tools

# Add to Claude Code (after building a server)
# .claude/settings.json:
# { "mcpServers": { "my-server": { "command": "python", "args": ["your_server.py"] } } }

Building with theModel Context Protocol