┌─────────────────────────────────────────────────────────────┐
│                        USER INPUT                            │
│                 "What's the weather in Mumbai?"              │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│                   LANGGRAPH AGENT                            │
│  ┌──────────────┐         ┌──────────────┐                  │
│  │   Routing    │────────▶│   Response   │                  │
│  │     Node     │         │    Node      │                  │
│  └──────┬───────┘         └──────────────┘                  │
│         │                                                     │
│         │ Uses OpenAI to determine:                          │
│         │ - Which tool to use                                │
│         │ - Extract parameters                               │
└─────────┼─────────────────────────────────────────────────────┘
          │
          ▼
┌─────────────────────────────────────────────────────────────┐
│                    MCP CLIENT                                │
│  - Manages connection to MCP server                          │
│  - Sends JSON-RPC requests                                   │
│  - Receives and processes responses                          │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       │ JSON-RPC over STDIO
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│                    MCP SERVER                                │
│  ┌──────────────┐         ┌──────────────┐                  │
│  │ get_weather  │         │  web_search  │                  │
│  │    Tool      │         │     Tool     │                  │
│  └──────────────┘         └──────────────┘                  │
│                                                               │
│  Built with FastMCP framework                                │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
┌─────────────────────────────────────────────────────────────┐
│                   EXTERNAL APIs                              │
│  • wttr.in (Weather API)                                     │
│  • Serper API (Web Search)                                   │
└─────────────────────────────────────────────────────────────┘

# mcp_client.py starts the MCP server as a subprocess
server = subprocess.Popen(
    [sys.executable, "mcp_server.py"],
    stdin=subprocess.PIPE,    # For sending requests
    stdout=subprocess.PIPE,   # For receiving responses
    stderr=subprocess.PIPE,   # For server logs
    text=True
)

# Client sends initialization request
send_request("initialize", {
    "protocolVersion": "2024-11-05",
    "capabilities": {},
    "clientInfo": {"name": "mcp-client", "version": "1.0.0"}
})

# Client sends initialized notification
send_notification("initialized")

User: "What's the weather in Mumbai?"

def route_request(state):
    # LLM analyzes the user request
    # Determines: tool="get_weather", parameters={"city": "Mumbai"}
    result = call_mcp_tool("get_weather", {"city": "Mumbai"})
    return {"tool_result": result}

# Client sends JSON-RPC request to server
{
    "jsonrpc": "2.0",
    "id": "1",
    "method": "tools/call",
    "params": {
        "name": "get_weather",
        "arguments": {"input": {"city": "Mumbai"}}
    }
}

@mcp.tool()
def get_weather(input: WeatherInput):
    url = f"https://wttr.in/{input.city}?format=j1"
    response = requests.get(url)
    # Process and return weather data

def generate_response(state):
    # Uses OpenAI to convert tool data into natural language
    # Input: Raw weather data
    # Output: "The current weather in Mumbai is 28°C with clear skies..."

Input:  {"city": "Mumbai"}
Output: {
    "location": "Mumbai, India",
    "temperature": "28°C / 82°F",
    "condition": "Partly cloudy",
    "humidity": "70%",
    "wind": "15 km/h"
}

Input:  {"query": "latest news about AI"}
Output: {
    "query": "latest news about AI",
    "results": [
        {
            "title": "AI Breakthrough...",
            "link": "https://...",
            "snippet": "..."
        }
    ]
}

mcp-server/
├── mcp_server.py           # MCP server implementation (FastMCP)
├── mcp_client.py           # MCP client + LangGraph agent
├── mcp-server.ipynb        # Jupyter notebook for testing
├── requirements.txt        # Python dependencies
├── .env                    # Environment variables (API keys)
└── README.md              # This file

git clone <repository-url>
cd mcp-server

pip install -r requirements.txt

# OpenAI API Key (required)
OPEN_AI_KEY=your_openai_api_key_here

# Serper API Key (required for web search)
SERPER_API_KEY=your_serper_api_key_here

# OpenWeather API Key (optional, using free wttr.in instead)
OPENWEATHER_API_KEY=

python mcp_client.py

User enters: "What's the weather in Mumbai?"

LLM analyzes → Determines tool: get_weather
             → Extracts parameter: city = "Mumbai"

Client → Server: {
    "method": "tools/call",
    "params": {"name": "get_weather", "arguments": {"input": {"city": "Mumbai"}}}
}

Server calls wttr.in API → Gets weather data → Returns JSON response

LLM receives raw data → Generates natural response
Output: "The weather in Mumbai is currently 28°C with partly cloudy skies. 
         The humidity is at 70% with winds at 15 km/h."

tests = [
    "What's the weather in Mumbai?",      # Uses get_weather
    "Tell me about the weather in Delhi", # Uses get_weather
    "Search for latest news about AI",    # Uses web_search
    "What is Model Context Protocol?"     # Uses web_search
]

USER: What's the weather in Mumbai?
🤖 Routing decision: User is asking for weather information
AGENT: The current weather in Mumbai is 28°C (82°F) with partly cloudy 
       conditions. Humidity is at 70% with winds at 15 km/h.

class CalculatorInput(BaseModel):
    expression: str

@mcp.tool()
def calculate(input: CalculatorInput):
    """Evaluate mathematical expressions"""
    try:
        result = eval(input.expression)  # Use safe_eval in production
        return {"result": result}
    except Exception as e:
        return {"error": str(e)}

# Add to available tools in routing_prompt
# The LLM will automatically learn to use it

"What is 25 * 4 + 10?"  # Should use calculator tool

┌─────────┐
│  START  │
└────┬────┘
     │
     ▼
┌─────────┐
│  Route  │  ← Determines which tool to use
└────┬────┘
     │
     ▼
┌──────────┐
│ Respond  │  ← Generates natural language response
└────┬─────┘
     │
     ▼
┌─────────┐
│   END   │
└─────────┘