MCP Server Development Framework

- MCP Tool Standardization: Automatically convert traditional FastAPI endpoints into AI model-callable MCP tools
- Interface-Implementation Separation: Support clear separation between interface definitions and implementations, facilitating testing and environment switching
- Dependency Injection Design: Leverage FastAPI's dependency injection mechanism for flexible component composition and decoupling
- Complete Development Pipeline: Provide comprehensive toolchain support from development to testing and deployment
- Example-Driven Documentation: Demonstrate best practices through practical examples to accelerate onboarding

This framework is particularly suitable for:
- AI tool development teams
- Developers looking to transform existing APIs into AI tools
- Organizations implementing standardized microservice architectures

This framework uses uv as its package manager, providing faster dependency resolution and virtual environment management. For installation instructions, see the uv official documentation.

make install

class DataServiceImpl(DataService):
def __init__(self, database_url: str):
self.db = Database(database_url)

def get_data(self, id: str) -> Dict[str, Any]:
return self.db.query("SELECT * FROM data WHERE id = :id", {"id": id})

def get_data_service() -> DataService:

return DataServiceMockImpl() # or return DataServiceImpl(settings.DATABASE_URL)
```

from fastapi import FastAPI, Depends
from fastapi_mcp import FastApiMCP
from pydantic import BaseModel, Field
app = FastAPI()
@app.post("/items/search", operation_id="search_items")

async def search_items(

    request: ItemRequest,

    service: DataService = Depends(get_data_service)

):

    result = service.search_items(request.query, request.limit)

    return {"items": result["items"], "total": len(result["items"])}
In this framework, dependency injection is primarily used for:
1. Service Instance Management: Injecting service implementations into API endpoints

2. Environment Adaptation: Selecting different service implementations based on runtime environment

3. Resource Lifecycle Management: Managing the creation and release of resources like database connections
FastAPI-MCP can automatically convert FastAPI endpoints into MCP tools:

app = FastAPI()

mcp = FastApiMCP(
app,
name="sentiment-analysis",
description="Sentiment analysis service",
base_url="http://localhost:5000",
include_operations=["predict_sentiment"]
)

MCP tool names default to the API endpoint's operation_id. We recommend following these naming conventions:

- Use clear, descriptive names
- Adopt a verb_noun format (e.g., predict_sentiment, find_nearby_parking)
- Explicitly set operation_id rather than relying on auto-generation

```python