Model Context Protocol Tutorial: Build Your First AI Integration

Every AI application hits the same wall: isolation from external data. Your AI model is powerful, but it can’t access your databases, APIs, files, or calendars without custom integration code. For every data source—GitHub, Slack, Postgres, Google Drive—you build fragile connectors that break when APIs change. This approach doesn’t scale.

Model Context Protocol (MCP) from Anthropic solves this. Announced in November 2024, MCP provides a standardized protocol for connecting AI applications to external systems. Think USB-C for AI: one protocol, infinite connections. Instead of building custom connectors for each data source, you build MCP servers once and reuse them everywhere. One year in, MCP ships with official SDKs for Python, TypeScript, C#, Go, and Ruby. Microsoft released the Azure MCP Server. Google partnered on the Go SDK. Pre-built servers for GitHub, Slack, and Postgres are production-ready. This tutorial shows you how to build your first MCP server in Python and integrate it with AI applications.

MCP Architecture: Three Components, One Purpose

MCP uses a three-layer architecture that separates concerns for security and reusability: Host, Client, and Server. This isn’t over-engineering—the separation is MCP’s killer feature.

The MCP Host is your user-facing AI interface. Claude Desktop, an IDE plugin, or your custom AI assistant. It connects to multiple MCP servers simultaneously and manages user interaction. The MCP Client sits between Host and Server as a connection manager. Each server gets its own dedicated client for security isolation. The client handles protocol communication and message routing. The MCP Server provides capabilities: tools for actions (search, calculations, API calls), resources for data access (databases, files, cloud storage), and prompts for specialized workflows.

The data flow is straightforward: User → MCP Host (AI interface) → MCP Client (connection manager) → MCP Server (capabilities provider) → External Systems (databases, APIs, files). Moreover, each server’s client creates an isolated sandbox. Your GitHub server can’t access Slack data. Your Postgres server can’t read your file system. Security through architecture, not policy.

The USB-C Metaphor: Build Once, Use Everywhere

MCP solves the same problem for AI that USB-C solved for devices: standardized connections that work everywhere. Before USB-C, every device needed a proprietary cable. Similarly, before MCP, every AI integration needed custom code.

The old approach was brittle. You built a custom connector for GitHub integration. Different code for Slack. Another implementation for database access. Each new data source meant rebuilding authentication, error handling, and data transformation from scratch. Custom code that breaks when APIs change. Non-reusable implementations that can’t be shared across projects.

MCP changes this. Build one MCP server for GitHub, use it in any MCP-compatible AI tool. Pre-built servers exist for common services: GitHub, Slack, Postgres, Google Drive, Git, Puppeteer. Furthermore, learn the standard protocol once, integrate anything. Servers work with Claude Desktop, VS Code, Replit, Zed, and Codeium. Anthropic’s announcement states: “MCP replaces fragmented integrations with a universal standard.” The developer community agrees—”Like USB-C for AI” became the top comment on Hacker News. Pre-built servers gaining thousands of GitHub stars within weeks confirms developers want this standardization.

Build Your First Model Context Protocol Server in Python

The Python SDK makes building MCP servers straightforward. You need Python 3.10+, basic understanding of async/await, and pip or uv for package management. Install the SDK with pip install mcp or uv add mcp for faster installs.

Here’s a minimal MCP server that exposes a greeting prompt:

from mcp.server.lowlevel import Server
import mcp.server.stdio
import mcp.types as types

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

# Define a simple tool
@server.list_prompts()
async def handle_list_prompts() -> list[types.Prompt]:
    return [
        types.Prompt(
            name="greeting",
            description="Generates a greeting message",
            arguments=[]
        )
    ]

# Run the server with stdio transport
async def main():
    async with mcp.server.stdio.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())

This code creates a server instance with a name, defines available prompts using decorators, uses stdio transport for local development, and runs the async server loop. From here, you add tools (for actions), resources (for data), and prompts (for workflows). The pattern stays consistent: define capabilities using decorators, run with a transport layer.

Configuration is simple. Create an mcp.json file:

{
  "mcpServers": {
    "my-server": {
      "command": "python",
      "args": ["server.py"]
    }
  }
}

This tells the MCP client how to launch your server. Consequently, point it to your Python file, and the client handles the rest. Official Python SDK examples follow this exact pattern. DataCamp’s tutorial walks through this structure. Microsoft’s C# tutorial uses the same conceptual model with decorators for tool definitions.

Pre-Built Servers: Don’t Rebuild What Exists

You don’t need to build everything from scratch. However, Anthropic and the community provide pre-built servers for common integrations. Official servers include GitHub (repository management, file operations, search), Slack (channel management, messaging, DMs, history), Postgres (read-only database access, schema inspection), Google Drive (file access and management), Git (local repository operations), and Puppeteer (web browser automation).

Installing a pre-built server takes minutes. For GitHub integration, add this to your mcp.json:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": ""
      }
    }
  }
}

The community is building more. “awesome-mcp-servers” lists on GitHub curate 100+ servers. FastMCP framework simplifies Python server creation with decorators. Servers for Notion, Jira, AWS, Azure, and niche tools are emerging. Therefore, use pre-built servers for common integrations. Build custom servers for proprietary systems, specific business logic, or unique data sources. Pre-built servers reduce development time from weeks to minutes. Instead of building GitHub integration from scratch, you configure in 5 minutes and focus on unique value.

MCP and LangChain: Complementary, Not Competitive

Developers get confused thinking they must choose between MCP and LangChain. However, they solve different problems. LangChain is a framework for building AI applications—it provides the “brain.” MCP is a protocol for communication between AI and external systems—it provides the “phone line.”

LangChain manages orchestration, prompt management, memory, and workflow chains. It’s a comprehensive library for LLM-powered apps with a mature ecosystem including CrewAI, LangGraph, and LlamaIndex. In contrast, MCP provides standardized connections to data sources and tools with security and isolation built into the architecture. Its ecosystem of reusable servers is growing rapidly.

Use them together. Build an AI agent with LangChain for reasoning, memory, and decision-making. Then, connect that agent to tools exposed via MCP servers for standardized access to GitHub, Slack, and databases. The agent uses MCP servers as tools without custom integration code. Choose LangChain for building AI application logic, orchestrating workflows, and managing prompts. Choose MCP for connecting AI to external systems, standardizing integrations, and reusing servers across projects. Most enterprise AI apps will use LangChain for orchestration plus MCP for integrations.

Key Takeaways

• MCP standardizes AI-to-system connections like USB-C standardized device connections, eliminating fragile custom integrations
• The three-component architecture (Host, Client, Server) provides security through isolation—each server gets its own sandboxed client
• Python SDK makes building MCP servers simple with decorator patterns and async support, enabling rapid prototyping
• Pre-built servers for GitHub, Slack, Postgres, and Google Drive save development time—configure in minutes instead of building from scratch
• MCP and LangChain are complementary: use LangChain for orchestration and MCP for standardized integrations, not one or the other

Start with the Python SDK and pre-built servers. Build custom servers when you need proprietary system access or unique business logic. MCP is one year old with rapid ecosystem growth, official SDKs for five languages, and enterprise backing from Anthropic, Microsoft, and Google. The protocol is becoming the standard for AI integrations. Get ahead of the curve.