MCP Agentic AI Crash Course with Python

I'll create a comprehensive README.md file based on the MCP Agentic AI Crash Course content. This will serve as a guide for anyone following along with the tutorial.

# 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:

LLM/AI Assistant ↔ MCP Client ↔ MCP Protocol ↔ MCP Server ↔ External Services

## 📋 Prerequisites

- Python 3.11 or higher
- Basic understanding of Python and async programming
- Familiarity with APIs and HTTP requests
- Docker (for deployment)

## 🚀 Installation

### 1. Set up UV (Python Package Manager)
```bash
# Install UV if not already installed
curl -LsSf https://astral.sh/uv/install.sh | sh

2. Create Project Environment

# 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

3. Install Dependencies

# 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

📁 Project Structure

MCP-crash-course/
├── server/
│   ├── weather.py          # Main MCP server
│   ├── server.py           # Production server with SSE
│   └── client-sse.py       # SSE client example
├── client.py               # MCP client implementation
├── weather.json            # Server configuration
├── requirements.txt        # Dependencies
├── Dockerfile             # Docker configuration
└── README.md              # This file

🏗️ Building MCP Server from Scratch

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

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()

🚀 Running MCP Server

Method 1: MCP Inspector (Development)

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

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

Method 2: Claude Desktop Integration

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

# Configuration automatically added to Claude Desktop settings

Method 3: Cursor IDE Integration

1. Open Cursor IDE
2. Go to File → Preferences → Cursor Settings
3. Navigate to MCP section
4. Add server configuration:

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

🔗 Integration Methods

Configuration File (weather.json)

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

Transport Types :

• STDIO: For local development and same-machine communication
• SSE (Server-Sent Events): For production with separate client/server hosting

💻 Client Implementation

Basic Client (client.py)

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())

Running the Client

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

# Run client
uv run client.py

🐳 Docker Setup

Dockerfile

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"]

Building and Running

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

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

Production Server with SSE (server/server.py)

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()

🎓 Course Information

This tutorial is part of the 2.0 Agentic AI and GenAI with MCP course :

• Start Date: May 10th, 2025
• Schedule: Every Saturday and Sunday, 3 hours per session
• Focus: Complete coverage of Agentic AI and Generative AI with MCP

🔧 Development Tips

Environment Variables

Create a .env file:

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

Testing Your Server

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

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

Debugging

• Use MCP Inspector for development and testing
• Check server logs for connection issues
• Verify JSON configuration syntax
• Ensure proper port configuration for SSE transport

📚 Additional Resources

• MCP Documentation
• Python SDK Documentation
• FastMCP Documentation

🤝 Contributing

Feel free to submit issues and enhancement requests!

📄 License

This project is licensed under the MIT License.

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