Part 1. Real-Time LangGraph Agent with MCP Tool Execution

This project demonstrates a decoupled real-time agent architecture that connects LangGraph agents to remote tools served by custom MCP (Modular Command Protocol) servers. The architecture enables a flexible and scalable multi-agent system where each tool can be hosted independently (via SSE or STDIO), offering modularity and cloud-deployable execution.

• Decoupled Architecture: Engineered a modular system where LangGraph-based agents orchestrate LLM workflows while delegating tool execution to remote MCP servers via both SSE and STDIO transports.
• Advanced Asynchronous Programming: Utilized Python’s async/await for non-blocking I/O, ensuring concurrent execution of multiple tools and scalable real-time communication.
• MCP & LangGraph Integration: Demonstrated deep expertise in integrating Modular Command Protocol (MCP) with LangGraph and LangChain, enabling seamless transformation and invocation of distributed tools.
• Flexible Multi-Server Connectivity: Designed a MultiServerMCPClient that supports 1:1 bindings to various tool servers, highlighting the system’s ability to integrate diverse environments (local, cloud, containerized).
• Robust Agent-to-Tool Communication: Implemented detailed client sessions, handshake protocols, and dynamic tool discovery, ensuring reliable execution and interaction between agents and MCP servers.
• Forward-Looking Interoperability: Laid the groundwork for an Agent2Agent protocol, aiming for an ecosystem where AI agents can share capabilities, coordinate actions, and securely exchange context and data.

🚀 Project Purpose

This project aims to:

• Decouple LLM-based agent orchestration (LangGraph) from tool execution (via MCP servers).
• Enable real-time, multi-server, and language-agnostic tool integration using the MCP protocol.
• Showcase how to:
  • Spin up LangChain-compatible MCP tool servers (e.g., math_server.py, weather_server.py)
  • Integrate them with LangGraph ReAct agents
  • Use async/await programming for non-blocking I/O across agents and tool servers

📦 Project Structure

.
├── servers/
│   ├── math_server.py         # STDIO-based MCP tool server
│   └── weather_server.py      # SSE-based MCP tool server
├── client/
│   ├── multiserver_client.py  # LangGraph agent using MultiServer MCP client
│   └── stdio_client.py        # LangGraph agent using STDIO transport

🔧 Technology Stack

• 🧠 LangGraph: ReAct agent orchestration
• 🔗 LangChain: LLM pipeline & tools abstraction
• 🧰 MCP (Modular Command Protocol):
  • FastMCP – FastAPI-based server abstraction
  • ClientSession, StdioServerParameters, MultiServerMCPClient
• 🌐 SSE & STDIO: Transport protocols
• 🔁 AsyncIO: Asynchronous concurrency
• ☁️ OpenAI: Backend LLM (via langchain_openai)
• 🧪 dotenv: API key management

📜 Source Code Breakdown

1. math_server.py and weather_server.py

Tool servers using FastMCP:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Weather")

@mcp.tool()
async def get_weather(location: str) -> str:
    return "Cold in Chicago"

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

✅ Highlights:

• Each server defines an async tool via @mcp.tool()
• Server is transport-agnostic: can run over SSE or STDIO
• Designed for modular deployment: local, cloud, containerized

2. multiserver_client.py

Agent that talks to multiple MCP servers concurrently:

async with MultiServerMCPClient({
    "math": {"command": "python", "args": ["math_server.py"]},
    "weather": {"url": "http://loca

... [View full README on GitHub](https://github.com/junfanz1/MCP-MultiServer-Interoperable-Agent2Agent-LangGraph-AI-System#readme)