FastMCP - Framework Python pour la construction rapide de serveurs et clients MCP

Aperçu du projet

FastMCP est un framework Python de haut niveau pour la construction de serveurs et de clients Model Context Protocol (MCP), conçu pour permettre aux développeurs de créer rapidement et simplement des outils, d'exposer des ressources, de définir des prompts et de connecter des composants. Ce projet, développé et maintenu par l'utilisateur GitHub jlowin, est devenu un élément important de l'écosystème MCP.

Pourquoi choisir FastMCP ?

Bien que le protocole MCP soit puissant, sa mise en œuvre nécessite beaucoup de code boilerplate - configuration du serveur, gestionnaires de protocoles, types de contenu, gestion des erreurs, etc. FastMCP gère tous les détails complexes du protocole et la gestion du serveur, vous permettant de vous concentrer sur la construction d'excellents outils.

Les objectifs de conception de FastMCP :

• 🚀 Rapide : Une interface de haut niveau signifie moins de code et un développement plus rapide
• 🍀 Simple : Construire des serveurs MCP avec un minimum de code boilerplate
• 🐍 Pythonique : Naturel pour les développeurs Python
• 🔍 Complet : Fournit une implémentation complète des spécifications de base de MCP, prenant en charge les serveurs et les clients

Caractéristiques principales

Fonctionnalités de base

• Création de serveurs à l'aide de décorateurs intuitifs, avec un minimum de code boilerplate
• Proxy de serveurs existants pour modifier la configuration ou les méthodes de transport
• Combinaison de serveurs en applications complexes
• Génération de serveurs à partir de spécifications OpenAPI ou d'objets FastAPI
• Interaction programmatique avec les serveurs MCP
• Connexion à n'importe quel serveur MCP en utilisant n'importe quel protocole de transport
• Test des serveurs sans intervention manuelle
• Utilisation des fonctionnalités de base de MCP, telles que l'échantillonnage LLM

Évolution des versions

FastMCP 1.0 a rendu la construction de serveurs MCP si simple qu'il fait désormais partie du SDK Python officiel du Model Context Protocol !

FastMCP 2.0 s'appuie sur cela en introduisant de nombreuses nouvelles fonctionnalités :

• Fonctionnalités avancées telles que le proxy et la combinaison de serveurs MCP
• Génération automatique de serveurs à partir de spécifications OpenAPI ou d'objets FastAPI
• Introduction de fonctionnalités client, telles que l'échantillonnage LLM

Installation

Il est recommandé d'utiliser uv pour installer FastMCP :

uv pip install fastmcp

Installation pour le développement :

git clone https://github.com/jlowin/fastmcp.git
cd fastmcp

uv sync

Exemple de démarrage rapide

Exemple de serveur basique

# server.py
from fastmcp import FastMCP


mcp = FastMCP("Demo")


@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b

@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
    """Get a personalized greeting"""
    return f"Hello, {name}!"

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

Installation sur Claude Desktop :

fastmcp install server.py

Explication des concepts clés

1. Instance FastMCP

Représente l'objet central de l'application MCP, gérant les connexions, les détails du protocole et le routage :

from fastmcp import FastMCP


mcp = FastMCP("My App")


mcp = FastMCP("My App", dependencies=["pandas", "numpy"])

2. Outils (Tools)

Permettent aux LLM d'effectuer des opérations en exécutant des fonctions Python, adaptées aux calculs, aux appels d'API externes ou aux effets secondaires :

import httpx
from pydantic import BaseModel

class UserInfo(BaseModel):
    user_id: int
    notify: bool = False

@mcp.tool()
async def send_notification(user: UserInfo, message: str) -> dict:
    """Sends a notification to a user if requested."""
    if user.notify:

        print(f"Notifying user {user.user_id}: {message}")
        return {"status": "sent", "user_id": user.user_id}
    return {"status": "skipped", "user_id": user.user_id}

@mcp.tool()
def get_stock_price(ticker: str) -> float:
    """Gets the current price for a stock ticker."""

    prices = {"AAPL": 180.50, "GOOG": 140.20}
    return prices.get(ticker.upper(), 0.0)

3. Ressources (Resources)

Exposent des données aux LLM, fournissant principalement des informations sans calculs importants ni effets secondaires :

@mcp.resource("config://app-version")
def get_app_version() -> str:
    """Returns the application version."""
    return "v2.1.0"


@mcp.resource("db://users/{user_id}/email")
async def get_user_email(user_id: str) -> str:
    """Retrieves the email address for a given user ID."""

    emails = {"123": "alice@example.com", "456": "bob@example.com"}
    return emails.get(user_id, "not_found@example.com")

4. Prompts

Définissent des modèles réutilisables ou des modes d'interaction :

from fastmcp.prompts.base import UserMessage, AssistantMessage

@mcp.prompt()
def ask_review(code_snippet: str) -> str:
    """Generates a standard code review request."""
    return f"Please review the following code snippet for potential bugs and style issues:\n```python\n{code_snippet}\n```"

@mcp.prompt()
def debug_session_start(error_message: str) -> list[Message]:
    """Initiates a debugging help session."""
    return [
        UserMessage(f"I encountered an error:\n{error_message}"),
        AssistantMessage("Okay, I can help with that. Can you provide the full traceback and tell me what you were trying to do?")
    ]

Fonctionnalités avancées

1. Serveurs proxy

Création de serveurs FastMCP qui servent d'intermédiaires, relayant les requêtes vers un autre point de terminaison MCP :

import asyncio
from fastmcp import FastMCP, Client
from fastmcp.client.transports import PythonStdioTransport


proxy_client = Client(
    transport=PythonStdioTransport('path/to/original_stdio_server.py'),
)


proxy = FastMCP.from_client(proxy_client, name="Stdio-to-SSE Proxy")

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

2. Combinaison de serveurs

Construction d'applications MCP de grande taille en créant des serveurs FastMCP modulaires et en les "montant" sur un serveur parent :

from fastmcp import FastMCP


weather_mcp = FastMCP("Weather Service")

@weather_mcp.tool()
def get_forecast(city: str):
    return f"Sunny in {city}"


news_mcp = FastMCP("News Service")

@news_mcp.tool()
def fetch_headlines():
    return ["Big news!", "Other news"]


mcp = FastMCP("Composite")
mcp.mount("weather", weather_mcp) 
mcp.mount("news", news_mcp)        

3. Génération de serveurs à partir d'API

Génération automatique de serveurs FastMCP à partir d'API Web existantes :

from fastapi import FastAPI
from fastmcp import FastMCP


fastapi_app = FastAPI(title="My Existing API")

@fastapi_app.get("/status")
def get_status():
    return {"status": "running"}


mcp_server = FastMCP.from_fastapi(fastapi_app)

4. Fonctionnalités client

Interaction avec n'importe quel serveur MCP :

from fastmcp import Client

async with Client("path/to/server") as client:

    result = await client.call_tool("weather", {"location": "San Francisco"})
    print(result)
    

    res = await client.read_resource("db://users/123/profile")
    print(res)

Exécution du serveur

Mode développement

fastmcp dev your_server_file.py

Installation en production

fastmcp install your_server_file.py

Exécution directe

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

Exemples de projets

Le projet contient plusieurs fichiers d'exemples :

• simple_echo.py: Outils, ressources et prompts de base
• complex_inputs.py: Utilisation de modèles Pydantic comme entrées d'outils
• mount_example.py: Montage de plusieurs serveurs FastMCP
• sampling.py: Utilisation de la complétion LLM dans un serveur MCP
• screenshot.py: Outil renvoyant un objet Image
• text_me.py: Outil interagissant avec une API externe
• memory.py: Exemple complexe avec interaction avec une base de données

Guide de contribution

FastMCP accueille les contributions de la communauté :

Prérequis environnementaux

• Python 3.10+
• Gestionnaire de paquets uv

Configuration du développement

git clone https://github.com/jlowin/fastmcp.git && cd fastmcp
uv venv && uv sync

Tests

uv run pytest -vv

Qualité du code

Utilisation de ruff et pre-commit :

pre-commit install
pre-commit run --all-files

Importance du projet

FastMCP comble le fossé entre l'implémentation du protocole MCP et le développement d'applications réelles, permettant aux développeurs de :

1. Prototyper et déployer rapidement des serveurs MCP
2. Intégrer facilement les API et les sources de données existantes
3. Construire une architecture d'application IA modulaire et extensible
4. Se concentrer sur la logique métier plutôt que sur les détails de l'implémentation du protocole