Langgraph MCP Integration

🚀 Understanding the MCP Architecture

The MCP (Multi-Computation Server) architecture is a revolutionary approach for integrating AI models with external computing services, enabling developers to build powerful applications.

🚀 Quick Start

What is the MCP Architecture?

The MCP architecture allows AI models to connect to multiple computing servers simultaneously through various transport protocols (such as stdio and sse). This enables the models to perform complex tasks, such as conducting mathematical operations in math_server.py or retrieving real-time weather information from weather_server.py.

✨ Features

Core Components of MCP

1. MCP Servers:

   • Math Server (math_server.py): Provides basic arithmetic operations.

   from mcp.server.fastmcp import FastMCP
   
   mcp = FastMCP("Math")
   
   @mcp.tool()
   def add(a: int, b: int) -> int:
       """Add two numbers."""
       return a + b
   
   if __name__ == "__main__":
       mcp.run(transport="stdio")
   

   • Weather Server (weather_server.py): Provides real-time weather data.

   from mcp.server.fastmcp import FastMCP
   
   mcp = FastMCP("Weather")
   
   @mcp.tool()
   async def get_weather(location: str) -> str:
       """Get weather for location."""
       return "It's always sunny in New York"
   
   if __name__ == "__main__":
       mcp.run(transport="sse")
   

2. MCP Clients:

   • Single-Server Client (single_server_client.py): Interacts with one MCP server.

   from mcp.client import Client
   
   client = Client(
       {
           "math": {
               "command": "python",
               "args": ["server/math_server.py"],
               "transport": "stdio",
           },
       }
   )
   

   • Multi-Server Client (multi_server_client.py): Interacts with multiple MCP servers simultaneously.

   from mcp.client import MultiServerMCPClient
   
   async with MultiServerMCPClient(
       {
           "math": {
               "command": "python",
               "args": ["server/math_server.py"],
               "transport": "stdio",
           },
           "weather": {
               "url": "http://localhost:8000/sse",
               "transport": "sse",
           },
       }
   ) as client:
       agent = create_react_agent(model, client.get_tools())
       math_response = await agent.ainvoke({"messages": "what's (3 + 5) x 12?"})
       weather_response = await agent.ainvoke({"messages": "what is the weather in nyc?"})
   

How MCP Works

The MCP architecture achieves its functionality through the following steps:

1. Server Initialization: Each MCP server defines its own tools (such as add and get_weather) and runs on a specified transport protocol.
2. Client Connection: Clients can be single-server or multi - server, depending on the requirements.
3. AI-Driven Interaction: Through a language model (such as GPT), clients can call tools on different servers to perform complex tasks.

Advantages of MCP

• Scalability: Easily add more services.
• Parallel Execution: Query multiple servers simultaneously.
• Flexible Communication: Supports multiple transport protocols.
• AI Integration: Seamlessly integrates language models with external services.

📦 Installation

To clone and run the code, follow these steps:

git clone https://github.com/commitbyrajat/langgraph-mcp-integration.git
cd langgraph-mcp-integration
rye sync  # Sync dependencies
rye run python server/weather_server.py &
rye run python client/single_server_client.py
rye run python client/multi_server_client.py

The MCP architecture enables developers to build powerful AI-driven applications. 🚀