Comment utiliser le serveur FastAPI MCP

FastAPI MCP Server est un outil révolutionnaire qui comble le fossé entre vos applications FastAPI et les agents d'IA en utilisant le Model Context Protocol (MCP). À une époque où l'intégration de l'IA devient de plus en plus importante, cette solution sans configuration vous permet d'exposer vos points de terminaison FastAPI existants en tant qu'outils qui peuvent être découverts et utilisés par les modèles et agents d'IA avec un minimum d'effort.

Introduction à FastAPI MCP

Le Model Context Protocol (MCP) est une norme émergente qui permet aux modèles d'IA d'interagir avec des outils et des ressources externes. FastAPI MCP Server sert de pont entre vos applications FastAPI existantes et les agents d'IA compatibles MCP comme Claude d'Anthropic, Cursor IDE, et autres, sans que vous ayez besoin de réécrire votre API ou d'apprendre de nouveaux frameworks complexes.

Ce qui rend FastAPI MCP vraiment remarquable, c'est son approche sans configuration. Il convertit automatiquement vos points de terminaison FastAPI existants en outils compatibles MCP, en préservant vos schémas de points de terminaison, votre documentation et vos fonctionnalités. Cela signifie que les agents d'IA peuvent découvrir et interagir avec vos API avec une configuration minimale requise de votre part.

Vous pouvez trouver le référentiel du serveur FastAPI MCP à l'adresse suivante : https://github.com/tadata-org/fastapi_mcp

Démarrer avec FastAPI MCP

Installation

Avant de pouvoir utiliser FastAPI MCP, vous devrez l'installer. Les développeurs recommandent d'utiliser uv, un installateur de paquets Python rapide, mais vous pouvez également utiliser la méthode traditionnelle pip :

En utilisant uv :

uv add fastapi-mcp

En utilisant pip :

pip install fastapi-mcp

Implémentation de base

L'intégration de FastAPI MCP à votre application FastAPI existante ne pourrait pas être plus simple. Voici l'implémentation la plus basique :

from fastapi import FastAPI
from fastapi_mcp import FastApiMCP

# Votre application FastAPI existante
app = FastAPI()

# Créer le serveur MCP
mcp = FastApiMCP(
    app,
    name="My API MCP",
    description="My API description",
    base_url="http://localhost:8000"  # Important pour le routage des requêtes
)

# Monter le serveur MCP sur votre application FastAPI
mcp.mount()

C'est tout ! Avec ce code simple, votre serveur MCP est désormais disponible à l'adresse https://app.base.url/mcp. Lorsqu'un client compatible MCP se connecte à ce point de terminaison, il découvrira automatiquement toutes vos routes FastAPI en tant qu'outils disponibles.

Comprendre les noms d'outils MCP et les ID d'opération

Lorsque FastAPI MCP expose vos points de terminaison en tant qu'outils, il utilise l'operation_id de vos routes FastAPI comme noms d'outils MCP. FastAPI génère automatiquement ces ID lorsqu'ils ne sont pas explicitement fournis, mais ils peuvent être cryptiques et moins conviviaux.

Comparez ces deux approches :

# operation_id généré automatiquement (moins convivial)
@app.get("/users/{user_id}")
async def read_user(user_id: int):
    return {"user_id": user_id}

# operation_id explicite (plus convivial)
@app.get("/users/{user_id}", operation_id="get_user_info")
async def read_user(user_id: int):
    return {"user_id": user_id}

Dans le premier exemple, l'outil pourrait être nommé quelque chose comme "read_user_users__user_id__get", tandis que le second exemple serait simplement "get_user_info". Pour une meilleure convivialité, en particulier lorsque les agents d'IA interagissent avec vos outils, il est recommandé de définir explicitement des ID d'opération clairs et descriptifs.

Options de configuration avancées

FastAPI MCP fournit plusieurs options de personnalisation pour adapter la façon dont votre API est exposée aux clients MCP.

Personnalisation de la description du schéma

Vous pouvez contrôler la quantité d'informations incluses dans les descriptions des outils :

mcp = FastApiMCP(
    app,
    name="My API MCP",
    base_url="http://localhost:8000",
    describe_all_responses=True,  # Inclure tous les schémas de réponse possibles
    describe_full_response_schema=True  # Inclure tous les détails du schéma JSON complet
)

Filtrage des points de terminaison

Vous souhaiterez peut-être contrôler quels points de terminaison sont exposés en tant qu'outils MCP. FastAPI MCP propose plusieurs mécanismes de filtrage :

# Inclure uniquement des opérations spécifiques par ID d'opération
mcp = FastApiMCP(
    app,
    include_operations=["get_user", "create_user"]
)

# Exclure des opérations spécifiques
mcp = FastApiMCP(
    app,
    exclude_operations=["delete_user"]
)

# Filtrer par balises
mcp = FastApiMCP(
    app,
    include_tags=["users", "public"]
)

# Exclure par balises
mcp = FastApiMCP(
    app,
    exclude_tags=["admin", "internal"]
)

# Combiner les stratégies de filtrage
mcp = FastApiMCP(
    app,
    include_operations=["user_login"],
    include_tags=["public"]
)

Notez que vous ne pouvez pas combiner les filtres d'inclusion et d'exclusion du même type (opérations ou balises), mais vous pouvez utiliser des filtres d'opération avec des filtres de balises.

Stratégies de déploiement

FastAPI MCP offre une flexibilité dans la façon dont vous déployez votre serveur MCP.

Montage sur l'application d'origine

L'approche la plus simple consiste à monter le serveur MCP directement sur votre application FastAPI d'origine, comme indiqué dans l'exemple de base. Cela crée un point de terminaison à /mcp dans votre application existante.

Déploiement en tant que service distinct

Vous pouvez également créer un serveur MCP à partir d'une application FastAPI et le monter sur une autre application, ce qui vous permet de déployer votre API et son interface MCP séparément :

from fastapi import FastAPI
from fastapi_mcp import FastApiMCP

# Votre application API d'origine
api_app = FastAPI()
# Définissez vos points de terminaison ici...

# Une application distincte pour le serveur MCP
mcp_app = FastAPI()

# Créer le serveur MCP à partir de l'application API
mcp = FastApiMCP(
    api_app,
    base_url="http://api-host:8001"  # URL où l'application API sera exécutée
)

# Monter le serveur MCP sur l'application distincte
mcp.mount(mcp_app)

# Maintenant, exécutez les deux applications séparément :
# uvicorn main:api_app --host api-host --port 8001
# uvicorn main:mcp_app --host mcp-host --port 8000

Cette séparation peut être bénéfique pour la gestion des ressources, la sécurité et la mise à l'échelle.

Mise à jour de MCP après l'ajout de nouveaux points de terminaison

Si vous ajoutez des points de terminaison à votre application FastAPI après avoir créé le serveur MCP, vous devrez actualiser le serveur pour les inclure :

# Configuration initiale
app = FastAPI()
mcp = FastApiMCP(app)
mcp.mount()

# Plus tard, ajoutez un nouveau point de terminaison
@app.get("/new/endpoint/", operation_id="new_endpoint")
async def new_endpoint():
    return {"message": "Hello, world!"}

# Actualisez le serveur MCP pour inclure le nouveau point de terminaison
mcp.setup_server()

Connexion à votre serveur MCP

Une fois que votre application FastAPI avec intégration MCP est en cours d'exécution, les clients peuvent s'y connecter de différentes manières.

Utilisation des événements envoyés par le serveur (SSE)

De nombreux clients MCP, comme Cursor IDE, prennent en charge les connexions SSE :

1. Exécutez votre application
2. Dans Cursor → Settings → MCP, utilisez l'URL de votre point de terminaison de serveur MCP (par exemple, http://localhost:8000/mcp) comme URL SSE
3. Cursor découvrira automatiquement tous les outils et ressources disponibles

Utilisation du proxy MCP pour les clients sans prise en charge de SSE

Pour les clients qui ne prennent pas directement en charge SSE (comme Claude Desktop) :

1. Exécutez votre application
2. Installez l'outil de proxy MCP : uv tool install mcp-proxy
3. Configurez votre client pour utiliser mcp-proxy

Pour Claude Desktop sur Windows, créez un fichier de configuration (claude_desktop_config.json) :

{
  "mcpServers": {
    "my-api-mcp-proxy": {
      "command": "mcp-proxy",
      "args": ["http://127.0.0.1:8000/mcp"]
    }
  }
}

Pour macOS, vous devrez spécifier le chemin complet de l'exécutable mcp-proxy, que vous pouvez trouver en utilisant which mcp-proxy.

Cas d'utilisation concrets

FastAPI MCP ouvre de nombreuses possibilités pour les applications basées sur l'IA :

1. Outils d'analyse de données : exposez des points de terminaison de traitement de données que les agents d'IA peuvent utiliser pour analyser les données utilisateur sans nécessiter d'intégrations personnalisées pour chaque modèle d'IA.
2. Systèmes de gestion de contenu : autorisez les outils d'IA à extraire et à mettre à jour du contenu via votre API CMS existante, ce qui rend la création et la gestion de contenu plus efficaces.
3. Moteurs de recherche personnalisés : permettez aux assistants d'IA de rechercher dans vos bases de données spécialisées ou vos référentiels de contenu via une simple interface API.
4. Opérations de commerce électronique : permettez aux agents d'IA de vérifier l'inventaire, les informations sur les produits ou de passer des commandes via vos points de terminaison d'API de commerce électronique existants.
5. Traitement de documents : fournissez aux outils d'IA la possibilité de créer, de convertir ou d'analyser des documents en utilisant vos capacités de traitement de documents backend.

Meilleures pratiques

Pour tirer le meilleur parti de FastAPI MCP, tenez compte de ces bonnes pratiques :

1. Utilisez des ID d'opération explicites : définissez des ID d'opération clairs et descriptifs pour tous vos points de terminaison afin de les rendre plus utilisables par les agents d'IA.
2. Fournissez une documentation complète : incluez des descriptions détaillées pour chaque point de terminaison et paramètre afin d'aider les modèles d'IA à comprendre comment utiliser vos outils efficacement.
3. Utilisez une nomenclature cohérente des paramètres : adoptez des conventions de dénomination cohérentes pour les paramètres similaires sur différents points de terminaison.
4. Tenez compte des implications en matière de sécurité : soyez conscient des points de terminaison que vous exposez via MCP et mettez en œuvre une authentification appropriée si nécessaire.
5. Surveillez l'utilisation : suivez la façon dont les agents d'IA utilisent vos outils MCP pour identifier les modèles, les erreurs ou les domaines à améliorer.

Conclusion

FastAPI MCP Server représente une avancée significative pour rendre les services backend accessibles aux agents d'IA. En convertissant automatiquement vos points de terminaison FastAPI existants en outils compatibles MCP sans aucune configuration, il élimine le besoin d'intégrations personnalisées ou d'ajustements complexes à la conception de votre API.

Au fur et à mesure que l'écosystème MCP continue de croître et que de plus en plus de modèles d'IA adoptent cette norme, le fait d'exposer vos API via FastAPI MCP permettra à vos services d'être facilement accessibles à un large éventail d'agents et d'outils d'IA. Que vous construisiez des outils internes, des services aux développeurs ou des API publiques, FastAPI MCP offre un moyen simple de rendre vos services accessibles à l'IA.

En suivant les conseils de cet article, vous pouvez rapidement intégrer FastAPI MCP dans vos applications FastAPI existantes et commencer à explorer les possibilités d'automatisation et d'interaction basées sur l'IA avec vos services.