Awesome MCP Fastapi

🚀 Awesome MCP FastAPI Project

A powerful implementation of the Model Context Protocol (MCP) based on FastAPI, integrating an enhanced tool registry and leveraging the mature FastAPI ecosystem.

📋 Overview

Awesome MCP FastAPI is a production-ready implementation of MCP that enhances the standard MCP functionality by integrating the mature FastAPI ecosystem. This project provides an improved tool registry system, making it easier to create, manage, and document tools for large language models (LLMs).

🌟 Why It's Better Than Standard MCP

Although the Model Context Protocol provides a good foundation for connecting AI models with tools and data sources, our implementation offers several significant advantages:

🌐 FastAPI's Mature Ecosystem

• Production-Ready Web Framework: Built on FastAPI, a high-performance, modern web framework with automatic OpenAPI documentation generation.
• Dependency Injection Support: Utilize FastAPI's powerful dependency injection system for more maintainable and testable code.
• Middleware Support: Easily integrate authentication, monitoring, and other middleware components.
• Built-in Validation: Implement strong request/response validation and data modeling through Pydantic.
• Asynchronous Support: Top-level support for the async/await pattern, suitable for high-concurrency applications.

💪 Enhanced Tool Registry

Our implementation improves the standard MCP tool registry in the following ways:

• Automatic Documentation Generation: Tools automatically generate documentation in MCP format and OpenAPI specifications.
• Improved Type Hints: Enhanced type information extraction for better tool support and IDE experience.
• Rich Schema Definitions: More expressive JSON Schema to define tool inputs and outputs.
• Better Error Handling: Structured error responses with detailed information.
• Enhanced Docstring Support: Better extraction of information from Python docstrings.

🛠️ Additional Features

• CORS Support: Ready to support cross-origin requests, facilitating integration with web applications.
• Lifecycle Management: Implement resource initialization and cleanup through FastAPI's lifecycle API.

🚀 Quick Start

📋 Prerequisites

• Python 3.10+

📦 Installation

# Clone the repository
git clone https://github.com/yourusername/awesome-mcp-fastapi.git
cd awesome-mcp-fastapi

# Create a virtual environment
python -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install dependencies
pip install -e .

▶️ Run the Server

uvicorn src.main:app --reload

Visit http://localhost:8000/docs to view the OpenAPI documentation.

💻 Usage Examples

🔨 Create a Tool

from fastapi import FastAPI
from src.utils.tools import create_tool

app = FastAPI()
my_tool = create_tool(...)
app.include_router(my_tool.router)

📤 Request Format

Send a POST request to /tools/your-tool-id with the following request body:

{
  "inputs": {
    "param1": "value1",
    "param2": "value2"
  },
  "options": {
    "timeout": 3000,
    "some_option": true
  }
}

🏗️ Architecture

The project uses a modular architecture:

• app: The main application entry point.
• tools: Tool definition and registration.
• routers: Routing configuration.
• models: Data models and validation.

awesome-mcp-fastapi/
├── app.py
├── models/
│   └── __init__.py
├── routers/
│   └── __init__.py
└── tools/
    └── __init__.py

🐳 Docker Support

Build and run:

docker build -t awesome-mcp-fastapi .
docker run -p 8000:8000 --env-file .env awesome-mcp-fastapi

🤝 Contribution

Contributions are welcome! Please feel free to submit a Pull Request.

📄 License

This project is licensed under the MIT License. See the LICENSE file for details.