Outils & Modèles Par
Dernière mise à jour :

FastMCP : créer un serveur MCP en Python et le mettre en production

FastMCP permet de créer un serveur MCP en Python en quelques lignes : une fonction typée devient un outil, le schéma est généré et le serveur se lance en stdio ou en HTTP. Ce qui sépare ce prototype d'un serveur de production, ce sont les choix qu'aucun framework ne fait à votre place : quels outils exposer, comment les décrire au modèle, qui a le droit de faire quoi, comment valider les écritures et comment mesurer que le modèle appelle le bon outil.

Cet article s'adresse aux responsables techniques et aux développeurs de PME et d'éditeurs qui doivent décider comment construire leur serveur, et aux dirigeants qui veulent comprendre ce que cela implique. Il contient un exemple de code court, puis la liste de ce qui reste à faire pour passer en production.

Points clés à retenir

  • FastMCP génère le schéma des outils à partir des fonctions Python typées et gère les transports ; les outils, les droits, les écritures et les tests restent à votre charge
  • Peu d'outils bien décrits, orientés tâche et aux résultats bornés, valent mieux qu'un outil par endpoint de l'API
  • Le serveur HTTP authentifie chaque requête et appelle l'API avec le jeton de l'utilisateur ; les annotations d'outils sont des indications pour le client, pas des protections
  • Une écriture se fait en deux temps : un outil prépare et montre un aperçu, l'utilisateur confirme, un second outil exécute
  • MCP Inspector sert à contrôler ce que voit le modèle ; un jeu de requêtes de tool calling mesure le taux de bon outil choisi et se rejoue à chaque changement
  • Le serveur est un client de votre API : sa maintenance (dépendances, descriptions, tests) fait partie du projet

Ce que FastMCP prend en charge, et ce qui reste à votre charge

FastMCP est un framework Python qui transforme des fonctions typées en outils d'un serveur MCP : il génère le schéma des paramètres, gère les transports (stdio et HTTP) et fournit des briques d'authentification. Il ne choisit pas vos outils, n'écrit pas leurs descriptions, ne décide pas des droits et ne teste pas le comportement du modèle. Un serveur de démonstration tient en dix lignes ; un serveur de production se joue sur tout le reste.

Sujet Ce que FastMCP fait Ce qu'il reste à faire
Outils Schéma généré depuis les types et la docstring Choisir les outils, les regrouper, rédiger leurs descriptions
Authentification Vérification de jetons, fournisseurs OAuth intégrés Droits par utilisateur et par client, appel de l'API au nom de l'utilisateur
Écritures Annotations (indications pour le client) Validation humaine, journalisation
Transport stdio, HTTP, application ASGI Reverse proxy, TLS, mises à l'échelle, déploiement
Qualité Client de test en mémoire Jeu de requêtes de tool calling, observabilité

Pour la décision côté éditeur (faut-il ouvrir son logiciel à Claude et ChatGPT, et dans quel ordre), voyez notre article sur le serveur MCP d'un éditeur de logiciel. Celui-ci traite la construction en Python. Une fois publié, le serveur s'utilise dans Claude avec un connecteur MCP personnalisé et dans ChatGPT avec les apps dans ChatGPT. Le fonctionnement du protocole lui-même est expliqué sur le blog technique d'Anas, dans Le Model Context Protocol expliqué.

Créer un serveur MCP en Python avec FastMCP

Avec FastMCP, un serveur MCP en Python se réduit à une instance FastMCP, un décorateur @mcp.tool sur chaque fonction et un appel à mcp.run(). L'installation passe par pip install fastmcp. L'exemple ci-dessous est celui d'un support client qui consulte des commandes, avec un outil de lecture et un outil qui prépare un remboursement sans l'exécuter. L'objet api représente votre couche d'accès à l'API existante.

from typing import Annotated, Literal

from fastmcp import FastMCP
from mcp.types import ToolAnnotations
from pydantic import Field

mcp = FastMCP("support-commandes")

@mcp.tool(annotations=ToolAnnotations(readOnlyHint=True))
async def lister_commandes_client(
    client_id: Annotated[str, Field(description="Identifiant renvoyé par rechercher_client")],
    statut: Annotated[
        Literal["en_cours", "livree", "litige"] | None,
        Field(description="Filtre facultatif sur le statut"),
    ] = None,
) -> list[dict]:
    """Liste les 20 dernières commandes d'un client, de la plus récente à la plus
    ancienne. À utiliser pour toute question sur l'état d'une commande. Pour une
    facture ou un avoir, utiliser un autre outil."""
    return await api.commandes(client_id, statut, limite=20)

@mcp.tool(annotations=ToolAnnotations(readOnlyHint=True))
async def preparer_remboursement(commande_id: str, motif: str) -> dict:
    """Vérifie qu'une commande est remboursable et renvoie un aperçu avec un
    identifiant d'opération. N'écrit rien dans le logiciel."""
    return await api.apercu_remboursement(commande_id, motif)

if __name__ == "__main__":
    mcp.run(transport="http", host="127.0.0.1", port=8000)

Trois choses se lisent dans ce code. Le nom de la fonction devient le nom de l'outil, et la docstring devient sa description. Les paramètres sont décrits par Annotated et Field, ce qui alimente le schéma que le modèle verra. Et le transport http expose le serveur sur une URL, par défaut le chemin /mcp. Sans argument, mcp.run() utilise stdio.

Pour regarder ce que le modèle verra, MCP Inspector se lance avec npx @modelcontextprotocol/inspector et se connecte au serveur, en HTTP ou en stdio. Il liste les outils avec leurs descriptions et permet de les appeler à la main. C'est le premier contrôle à faire, avant même de brancher un assistant.

L'API de FastMCP a évolué au fil des versions. Les exemples de cet article suivent la documentation actuelle de gofastmcp.com ; si vous reprenez du code trouvé en ligne, comparez-le à cette documentation, surtout pour les transports et l'authentification. Pour comprendre où ce serveur s'insère dans une architecture, le guide du serveur MCP pose les notions de base.

Découper les outils et écrire des descriptions que le modèle lit

Le modèle choisit un outil à partir de son nom, de sa description et du schéma de ses paramètres, rien d'autre. Un serveur avec peu d'outils bien décrits est choisi plus justement qu'un serveur qui reproduit l'API endpoint par endpoint. Le travail commence donc hors du code, par la liste des tâches que vos utilisateurs demandent réellement.

Peu d'outils, bornés, orientés tâche

Un outil par endpoint donne vite une longue liste d'outils voisins. Plus ils se ressemblent, plus le modèle hésite ou enchaîne trois appels là où un seul suffisait. On part des tickets de support, des questions posées aux équipes, des exports faits à la main, et chaque tâche fréquente donne un outil. Cet outil peut appeler plusieurs routes en interne et renvoyer un résultat déjà filtré.

Les résultats sont bornés (nombre de lignes maximum, champs utiles seulement). Un outil qui renvoie des milliers de lignes remplit le contexte et ralentit la réponse sans l'améliorer.

La description est du texte de production

La description se rédige comme une documentation pour un lecteur pressé. Elle dit ce que fait l'outil, quand l'utiliser, quand ne pas l'utiliser (en nommant l'outil voisin), et ce qu'il renvoie. Dans l'exemple plus haut, la phrase « pour une facture ou un avoir, utiliser un autre outil » évite que le modèle confonde deux outils proches. Les erreurs sont écrites pour être comprises par le modèle. FastMCP fournit ToolError (dans fastmcp.exceptions), dont le message est renvoyé tel quel, avec un état d'erreur, au lieu d'une trace technique.

Une description se modifie comme du code

Changer une phrase de description change le comportement du serveur. Elle se versionne, se relit et se teste comme une fonction (voir la section sur le tool calling plus bas).

Authentification, droits par utilisateur et écritures validées

Un serveur MCP exposé en HTTP authentifie chaque requête et appelle votre API avec le jeton de l'utilisateur, jamais avec un compte de service qui voit tout. L'assistant ne peut alors rien faire que l'utilisateur ne pourrait faire lui-même dans votre logiciel. FastMCP vérifie les jetons ; l'attribution des droits, elle, reste dans votre API.

La brique la plus simple est un vérificateur de jetons JWT, qui contrôle la signature, l'émetteur et l'audience d'un jeton délivré par votre serveur d'autorisation existant.

from fastmcp import FastMCP
from fastmcp.server.auth.providers.jwt import JWTVerifier

auth = JWTVerifier(
    jwks_uri="https://auth.exemple.fr/.well-known/jwks.json",
    issuer="https://auth.exemple.fr",
    audience="mcp-support-commandes",
)

mcp = FastMCP("support-commandes", auth=auth)

Ce vérificateur valide des jetons ; il ne remplace pas le serveur d'autorisation. Pour que Claude ou ChatGPT guident l'utilisateur dans une connexion OAuth complète, il faut un fournisseur d'identité côté vôtre, et FastMCP propose des fournisseurs intégrés et une classe de proxy OAuth pour les cas où le fournisseur ne gère pas l'enregistrement dynamique des clients. Le détail dépend de votre fournisseur d'identité, et c'est l'un des premiers sujets à clarifier avant d'écrire le moindre outil.

Deux règles tiennent en toute circonstance. Le compte client (tenant) se lit dans le jeton, jamais dans un paramètre que le modèle remplit, car un texte malveillant glissé dans une donnée lue par le modèle peut l'inciter à essayer un autre identifiant. Et les contrôles de droits sont refaits par l'API à chaque appel. Les annotations comme readOnlyHint ou destructiveHint informent le client, la documentation les présente comme des indications, pas comme des protections.

Écrire en deux temps, avec validation humaine

Une écriture ne doit pas partir directement. L'outil de l'exemple, preparer_remboursement, vérifie les règles et renvoie un aperçu avec un identifiant d'opération, sans rien écrire. Un second outil, confirmer_operation, exécute l'opération préparée, après accord explicite de l'utilisateur. Le modèle ne transmet que l'identifiant : il ne peut pas modifier le montant entre les deux étapes. Claude demande une approbation avant l'appel d'un outil, que l'utilisateur peut passer en « Always allow », et ChatGPT demande une confirmation avant les actions d'écriture. Ces comportements dépendent du client et peuvent changer, donc le serveur ne doit pas en dépendre.

On expose d'abord un serveur en lecture seule, puis on ajoute les écritures une par une. Chaque écriture est journalisée avec l'utilisateur, les arguments, l'aperçu montré et la confirmation. Les suppressions, les opérations en masse et les paiements restent dans l'interface du logiciel.

Transport HTTP, déploiement et observabilité

En production, un serveur FastMCP tourne en HTTP et se déploie comme n'importe quel service web. Le transport stdio sert aux tests et aux usages sur le poste de l'utilisateur ; le transport SSE est conservé pour la compatibilité, et la documentation recommande HTTP pour tout nouveau projet.

Pour un déploiement derrière votre infrastructure, FastMCP expose une application ASGI.

app = mcp.http_app()   # application ASGI, servie par uvicorn ou équivalent

On la sert avec un serveur ASGI comme uvicorn, derrière votre reverse proxy avec TLS, dans un conteneur, avec les variables d'environnement habituelles pour les secrets. Les contraintes sont celles de tout service exposé. Il faut des vérifications de santé, des limites de débit, des journaux centralisés et une gestion des versions. Un point propre à MCP à garder en tête avant de multiplier les instances est de vérifier dans la documentation de votre version de FastMCP comment les sessions sont gérées en HTTP.

L'observabilité compte plus qu'ailleurs, parce que votre serveur voit les appels d'outils mais pas la conversation. Chaque appel est tracé (utilisateur, outil, arguments, durée, résultat ou erreur). Pour un éditeur de plateforme IA, de juillet à novembre 2025, nous avons développé des serveurs MCP avec FastMCP, des agents Pydantic AI qui les appellent, et suivi le tout avec Logfire. Les traces servent à comprendre une réponse contestée, à repérer les outils jamais appelés (souvent mal décrits) et à alimenter le jeu de tests avec les vraies demandes. Notre comparatif des outils d'évaluation et d'observabilité des LLM présente les alternatives.

Tester le tool calling avant la mise en production

Un serveur MCP se teste à deux niveaux. Le code d'abord, avec le client de test de FastMCP branché directement sur le serveur, sans réseau. Le comportement du modèle ensuite, qui est ce qui casse quand on modifie une description ou qu'on change de modèle.

from fastmcp import Client

async def test_liste_commandes():
    async with Client(mcp) as client:
        resultat = await client.call_tool(
            "lister_commandes_client", {"client_id": "C-1042"}
        )
    assert isinstance(resultat.data, list)

Pour le second niveau, nous avons construit un benchmark du tool calling sur le projet évoqué plus haut. Le principe que nous recommandons est simple. On écrit des demandes réalistes, chacune avec la trace attendue (quel outil, avec quels arguments, ou aucun appel). On peut alors noter chaque scénario de façon binaire sur trois critères, le bon outil, les bons arguments, aucun appel inutile. Le taux de bon outil choisi devient alors un chiffre qu'on suit.

  • À chaque changement de description, pour savoir si la modification améliore ou dégrade le choix de l'outil
  • À chaque changement de modèle, car une même liste d'outils n'est pas lue de la même façon par tous les modèles
  • À chaque évolution de l'API, avec les tests du serveur dans la CI de l'API

C'est la même logique que pour un RAG, où la mesure posée dès le départ permet de savoir si on progresse ou si on régresse. Sans jeu de requêtes, une description « améliorée » est une impression, pas un résultat.

Ce que ça implique pour un dirigeant

Construire le premier serveur est rapide. Le temps va aux décisions (quels outils, quels droits, quelles écritures) et à la mise en place des tests et du suivi. Le serveur est un client de votre API, ses outils forment un contrat avec les modèles, et les dépendances (FastMCP, la spécification MCP) évoluent : la maintenance fait partie du projet.

Si vous voulez publier un serveur MCP pour votre produit, c'est ce que couvre notre offre pour ajouter l'IA à un logiciel : liste d'outils, authentification, journalisation, jeu de tests du tool calling, avec le code livré dans votre dépôt. Si le besoin est un agent qui orchestre plusieurs outils de votre côté, voyez notre développement d'agents IA sur mesure.

Vous préparez un serveur MCP pour votre logiciel ?

Montrez-nous votre API et les demandes de vos utilisateurs. Nous vous disons quels outils exposer en premier, comment les sécuriser et comment les tester, sur devis.

Prendre un rendez-vous

Questions fréquentes sur FastMCP et les serveurs MCP en Python

FastMCP est un framework Python qui transforme des fonctions typées en outils d'un serveur MCP. Il génère le schéma des paramètres à partir des annotations de type, gère les transports (stdio et HTTP) et propose des briques d'authentification. Il ne décide ni des outils à exposer, ni de leurs descriptions, ni des droits : ce travail reste le vôtre.
Pour un serveur en Python, FastMCP est le chemin le plus court : un décorateur suffit pour publier un outil. Le SDK officiel convient si vous voulez rester au plus près de la spécification ou si vous ne souhaitez qu'une dépendance minimale. Dans les deux cas, ce qui fait la qualité du serveur (outils, descriptions, droits, tests) ne dépend pas du framework.
Le moins possible, tant que chaque tâche fréquente des utilisateurs a son outil. Un outil par endpoint de l'API donne une liste longue d'outils voisins, et le modèle se trompe plus souvent d'outil. On part des demandes réelles, on regroupe, et on vérifie sur un jeu de requêtes que le bon outil est bien choisi.
À trois niveaux. Les tests unitaires du code, avec le client FastMCP branché directement sur le serveur en mémoire. L'inspection à la main avec MCP Inspector, qui liste les outils et permet de les appeler. Et un jeu de scénarios de tool calling, rejoué sur les modèles de vos utilisateurs, qui mesure le taux de bon outil choisi et de bons arguments.
Le transport HTTP, qui expose le serveur sur une URL (par défaut /mcp), derrière OAuth et votre reverse proxy. Le transport stdio sert aux tests et aux usages sur le poste de l'utilisateur. Le transport SSE est conservé pour la compatibilité, et la documentation FastMCP recommande HTTP pour tout nouveau projet.
Par une authentification sur chaque requête HTTP (FastMCP propose notamment un vérificateur de jetons JWT), un appel de votre API avec le jeton de l'utilisateur plutôt qu'un compte de service, des droits contrôlés par l'API à chaque appel, et une validation humaine avant toute écriture. Les annotations d'outils comme readOnlyHint sont des indications pour le client, pas des protections.

Pour aller plus loin

Formation

Pour que vos équipes appliquent ces usages sur leurs propres documents, voir notre formation agents IA, construite sur vos cas.

IA dans votre logiciel

Vous voulez brancher l'IA sur votre logiciel ou vos API ?

On conçoit l'intégration avec vos développeurs : serveur MCP, appels API aux modèles, agents qui agissent dans votre produit, avec droits d'accès, journalisation et tests sur vos vrais cas avant la mise en production.

Anas Rabhi, ingénieur IA et data scientist, fondateur de Tensoria
Anas R. Ingénieur IA, fondateur de Tensoria ianas.fr

Je suis ingénieur IA et data scientist, fondateur de Tensoria. Depuis plus de 6 ans, je conçois et développe des systèmes IA pour les entreprises : assistants internes basés sur RAG, agents IA en production, automatisations sur mesure, traitement intelligent de documents. Je prends le projet en charge du cadrage à la mise en production, sur les modèles du marché (Mistral, Claude, GPT) ou sur des modèles ouverts hébergés chez le client quand la confidentialité l'exige.