MCP Basic Architecture

🚀 LangGraph MCP Server

A clean, modular implementation of the Model Context Protocol (MCP) server in LangGraph documentation.

🚀 Quick Start

To run the server:

python -m app.server

✨ Features

• Modularity: Each component has a single responsibility.
• Scalability: It's easy to add new tools and resources without modifying existing code.
• Maintainability: The well - organized structure makes debugging easier.
• Extensibility: It can handle growth as more features are added.
• Testability: Components can be tested in isolation.

📦 Installation

No installation steps are provided in the original document, so this section is skipped.

💻 Usage Examples

Adding New Tools

1. Create a new file in the app/tools/ directory (e.g., weather_tools.py).
2. Define your tool functions in this file.
3. Create a registration function (e.g., register_weather_tools).
4. Import and call this registration function in app/tools/__init__.py.

Example:

# app/tools/weather_tools.py
def register_weather_tools(mcp):
    mcp.tool()(get_weather)

def get_weather(city: str):
    """Get the weather of a certain city"""
    # Implementation details
    return f"The weather in {city}: Sunny, 75°F"

Adding New Resources

1. Create a new file in the app/resources/ directory (e.g., weather_resources.py).
2. Define your resource functions in this file.
3. Create a registration function (e.g., register_weather_resources).
4. Import and call this registration function in app/resources/__init__.py.

Example:

# app/resources/weather_resources.py
def register_weather_resources(mcp):
    mcp.resource("weather://forecast")(get_weather_forecast)

def get_weather_forecast():
    """Get the weather forecast"""
    # Implementation details
    return "5 - day weather forecast data"

📚 Documentation

Architecture

This project follows the clean architecture pattern to make the MCP server easier to maintain and debug as features are added.

Directory Structure

app/
├── config.py                  # Configuration settings
├── server.py                  # Main server entry point
├── resources/                 # Resources that clients can access
│   ├── __init__.py            # Resource registration
│   └── langgraph_resources.py # LangGraph - specific resources
├── tools/                     # Tools that clients can call
│   ├── __init__.py            # Tool registration
│   └── langgraph_tools.py     # LangGraph - specific tools
└── utils/                     # Utility functions used throughout the application
    ├── __init__.py
    └── logging_utils.py       # Logging utilities

Core Components

1. Server: The main entry point that initializes the MCP server and registers all tools and resources.
2. Configuration: A centralized location for all configuration settings.
3. Tools: Functional functions that clients can call to perform specific tasks.
4. Resources: Data sources that clients can access.
5. Utilities: Utility functions used in the application.

🔧 Technical Details

The project follows the clean architecture pattern, which helps in maintaining and debugging the MCP server as the functionality grows. The directory structure is well - organized, separating different types of components such as tools, resources, and utilities. Each component has a clear responsibility, which makes the codebase more modular and easier to manage.

📄 License

No license information is provided in the original document, so this section is skipped.