MCP Agentic AI Crash Course with Python

# MCP Agentic AI Crash Course with Python

A comprehensive crash course on Model Context Protocol (MCP) covering everything from basic concepts to building production-ready MCP servers and clients.

## 📋 Table of Contents

- [Overview](#overview)
- [What is MCP?](#what-is-mcp)
- [Prerequisites](#prerequisites)
- [Installation](#installation)
- [Project Structure](#project-structure)
- [Building MCP Server from Scratch](#building-mcp-server-from-scratch)
- [Running MCP Server](#running-mcp-server)
- [Integration Methods](#integration-methods)
- [Client Implementation](#client-implementation)
- [Docker Setup](#docker-setup)
- [Course Information](#course-information)

## 🎯 Overview

This crash course covers:
- **MCP Fundamentals**: Understanding Model Context Protocol architecture   
- **Server Development**: Building MCP servers from scratch   
- **Multiple Integration Methods**: MCP Inspector, Claude Desktop, Cursor IDE   
- **Client Implementation**: Creating MCP clients with LLM integration   
- **Production Deployment**: Docker setup for deployment

## 🔧 What is MCP?

**Model Context Protocol (MCP)** is a standardized way for AI assistants to connect with external services and data sources   . 

### Key Benefits:
- **Unified Protocol**: Like a USB-C cable for AI services - one protocol for multiple connections   
- **Service Provider Managed**: Updates and maintenance handled by service providers   
- **Reduced Code Complexity**: No need to write wrapper code for each service   

### Architecture:

## 📁 Project Structure

## 🏗️ Building MCP Server from Scratch

### 1. Create Weather Service Server (`server/weather.py`)

```python
from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP

# Initialize MCP server
mcp = FastMCP("weather")

# Weather API configuration
WEATHER_API_BASE = "https://api.weather.gov"
USER_AGENT = "MCP-Weather-Server/1.0"

async def make_weather_request(url: str) -> dict[str, Any]:
    """Make request to weather API with proper error handling"""
    headers = {
        "User-Agent": USER_AGENT,
        "Accept": "application/json"
    }
    
    async with httpx.AsyncClient() as client:
        response = await client.get(url, headers=headers, timeout=30)
        response.raise_for_status()
        return response.json()

def format_alerts(response: dict[str, Any]) -> str:
    """Format weather alerts response"""
    if not response.get("features"):
        return "No weather alerts found for this state."
    
    alerts = []
    for feature in response["features"]:
        properties = feature.get("properties", {})
        alerts.append(f"Alert: {properties.get('headline', 'N/A')}")
    
    return "\n".join(alerts)

@mcp.tool()
async def get_alerts(state: str) -> str:
    """Get weather alerts for a US state (provide 2-character state code)"""
    url = f"{WEATHER_API_BASE}/alerts?area={state.upper()}"
    
    try:
        response = await make_weather_request(url)
        return format_alerts(response)
    except Exception as e:
        return f"Error fetching weather alerts: {str(e)}"

# Resource example
@mcp.resource("config://app")
async def get_app_config() -> str:
    """Get application configuration"""
    return "MCP Weather Server v1.0 - Provides weather alerts for US states"

if __name__ == "__main__":
    mcp.run()

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": ["run", "server/weather.py"],
      "cwd": "/path/to/your/project"
    }
  }
}

import asyncio
from langchain_groq import ChatGroq
from mcpus import MCPAgent, MCPClient

async def main():
    # Load configuration
    client = MCPClient("weather.json")
    
    # Initialize LLM
    llm = ChatGroq(
        model="llama-3.1-70b-versatile",
        api_key="your-groq-api-key"
    )
    
    # Create MCP Agent
    agent = MCPAgent(llm=llm, client=client)
    
    # Interactive loop
    while True:
        query = input("Ask about weather: ")
        if query.lower() in ['quit', 'exit']:
            break
            
        response = await agent.run(query)
        print(f"Response: {response}")

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

# Set your Groq API key
export GROQ_API_KEY="your-api-key-here"

# Run client
uv run client.py

GROQ_API_KEY=your-groq-api-key
WEATHER_API_KEY=your-weather-api-key  # if needed

# Test with MCP Inspector
uv run mcp dev server/weather.py

# Test specific tool
# In MCP Inspector: get_alerts("CA")

This README provides a comprehensive guide covering all the major topics from the video, including setup instructions, code examples, and deployment options. It's structured to help users follow along with the tutorial and implement their own MCP servers and clients   .# mcpcrashcourse

# Install UV if not already installed
curl -LsSf https://astral.sh/uv/install.sh | sh

# Initialize project
uv init MCP-crash-course
cd MCP-crash-course

# Create virtual environment
uv venv

# Activate environment (Windows)
.venv\Scripts\activate
# Activate environment (macOS/Linux)
source .venv/bin/activate

# Core MCP dependencies
uv add mcp-cli
uv add httpx
uv add mcpus

# For LLM integration
uv add langchain-groq

# For development
uv add fastapi uvicorn

# Start MCP Inspector
uv run mcp dev server/weather.py

# Access at http://localhost:3000
# Select STDIO transport and connect

# Install server to Claude Desktop
uv run mcp install server/weather.py

# Configuration automatically added to Claude Desktop settings

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": ["run", "server/weather.py"],
      "cwd": "/path/to/your/project"
    }
  }
}

FROM python:3.11-slim

WORKDIR /app

# Install UV
RUN pip install uv

# Copy requirements and install dependencies
COPY requirements.txt .
RUN uv venv && uv pip install -r requirements.txt

# Copy application files
COPY server/ ./server/
COPY *.py ./
COPY *.json ./

# Expose port
EXPOSE 8000

# Run server
CMD ["uv", "run", "server/server.py"]

# Build Docker image
docker build -t mcp-server .

# Run container
docker run -p 8000:8000 mcp-server

import asyncio
from mcp.server.fastmcp import FastMCP
from mcp.server.stdio import stdio_server
from mcp.server.sse import sse_server

# Your weather server code here...

if __name__ == "__main__":
    import sys
    
    if "--sse" in sys.argv:
        # Run with SSE transport
        mcp.run_sse(host="0.0.0.0", port=8000)
    else:
        # Run with STDIO transport
        mcp.run()