Model Context Protocol

Model-Context-Protocol (MCP) rethinks how AI agents integrate with external systems. Instead of having developers write bespoke API integrations for every use case, MCP lets services register as callable tools that agents can invoke. This shifts the integration burden from application code to the agent, enabling more flexible, composable workflows. In practice, an MCP server exposes one or more well-defined functions (endpoints) with explicit input and output schemas. When an agent runs, it discovers and calls these functions to query or mutate external state. That makes it straightforward to extend an assistant’s capabilities—plug in an MCP server for a system and the agent can use it without additional glue code. For example, a TechDocs assistant could query customer, order, inventory, or ticketing systems via MCP endpoints. If a user asks, “What’s the status of order 1234?”, the agent can call an MCP that queries the order-management system, receive the structured response, and compose a natural-language reply that includes the order state.

A hand-drawn system diagram showing a user asking "What's the status of order #1234" to Tech Corp's AI chat assistant and agent. The agent connects to internal knowledge (a vector DB) and external systems (customer database, inventory/support) via an MCP/API to fetch the information.

Minimal FastAPI MCP server example

Below is a concise, practical example: a FastAPI-based MCP that exposes a simple customer lookup function. It demonstrates the typical pieces of an MCP server:

A web app that exposes a function endpoint the agent can call.
Typed request/response models so agents know how to call the function.
A persistence layer (here, an in-memory dict) — replace with your production DB.

Use this as a template for a real integration (SQL, MongoDB, or any service).

# server.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional, Dict

app = FastAPI(title="customer-db-mcp", version="0.1.0")


# Request schema: what the MCP client (the AI agent) will send
class GetCustomerRequest(BaseModel):
    customer_id: str


# Response schema: what the MCP server returns
class Customer(BaseModel):
    customer_id: str
    name: str
    email: Optional[str] = None
    status: str  # e.g., 'shipped', 'processing', 'closed' (use values appropriate for your domain)


# Fake in-memory database (replace with real DB in production)
customers: Dict[str, Customer] = {
    "1234": Customer(customer_id="1234", name="Alice Johnson", email="alice@example.com", status="shipped"),
    "2345": Customer(customer_id="2345", name="Bob Smith", email="bob@example.com", status="processing"),
}


@app.post("/mcp/get_customer", response_model=Customer)
async def get_customer(req: GetCustomerRequest):
    """
    MCP function: returns customer information by customer_id.
    The agent can call this endpoint to retrieve customer state.
    """
    cust = customers.get(req.customer_id)
    if not cust:
        raise HTTPException(status_code=404, detail="customer not found")
    return cust

Run the server with uvicorn:

uvicorn server:app --host 0.0.0.0 --port 8000 --reload

Example MCP client request (what an agent or other client would send):

curl -X POST "http://localhost:8000/mcp/get_customer" \
  -H "Content-Type: application/json" \
  -d '{"customer_id": "1234"}'

Example JSON response:

{
  "customer_id": "1234",
  "name": "Alice Johnson",
  "email": "alice@example.com",
  "status": "shipped"
}

Key components and best practices

Component	Purpose	Example / Notes
Endpoint (function surface)	Defines callable operations for agents	POST /mcp/get_customer
Typed schemas	Makes discovery and validation reliable	Pydantic models, OpenAPI schemas
Persistence	Store and retrieve real-world state	SQL, MongoDB, managed services
Security	Protect data and control access	API keys, OAuth, RBAC, rate limits
Agent discovery	How agents find and interpret functions	OpenAPI, function registry, metadata

This structure—define endpoints and schemas once—lets any compatible agent call your MCP server to fetch or modify external state. Many ecosystems publish reusable MCP adapters for common services (e.g., source control, databases, productivity tools), letting you plug them into agents without custom integration work.

MCP servers should clearly define input and output schemas (e.g., via OpenAPI / Pydantic). This makes it easy for agents to discover and call them reliably. In production, secure these endpoints (authentication, authorization, rate-limiting) before exposing them to agents.

Links and references

FastAPI: https://fastapi.tiangolo.com
uvicorn: https://www.uvicorn.org
Pydantic: https://docs.pydantic.dev
OpenAPI: https://www.openapis.org
SQL: https://en.wikipedia.org/wiki/SQL
MongoDB: https://www.mongodb.com
Example repositories and community MCP adapters: search GitHub for “MCP” and “agent tooling” for community-provided integrations

Use this pattern to make your AI assistants actionable: define function surfaces, provide strict schemas, and secure endpoints—then let the agent do the integration work.

AI Agents - Part 1

AI Agents - Part 2

Introduction

Model Context Protocol

Minimal FastAPI MCP server example

Key components and best practices

Links and references

Watch Video

​Minimal FastAPI MCP server example

​Key components and best practices

​Links and references

Watch Video

Minimal FastAPI MCP server example

Key components and best practices

Links and references