Le paysage des Modèles Linguistiques de Grande taille (LLMs) évolue rapidement, allant au-delà de la simple génération de texte vers des interactions complexes avec des systèmes externes et des sources de données. Faciliter cette interaction nécessite une approche standardisée, un langage commun pour que les LLMs demandent des informations et déclenchent des actions. C'est là qu'intervient le Model Context Protocol (MCP), conçu comme une norme universelle – souvent comparée au "port USB-C pour l'IA" – permettant une communication transparente entre les LLMs et les ressources dont ils ont besoin.
Bien que MCP fournisse la spécification, la construction de serveurs et de clients qui y adhèrent peut impliquer un code passe-partout et une gestion de protocole importants. C'est là que FastMCP brille. FastMCP est un framework Pythonique de haut niveau conçu pour simplifier considérablement la création de serveurs et de clients MCP. Il gère les complexités sous-jacentes du protocole, permettant aux développeurs de se concentrer sur la définition des outils, des ressources de données et des modèles d'interaction précieux qu'ils souhaitent exposer aux LLMs.
Vous voulez une plateforme intégrée, tout-en-un, pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?
Apidog répond à toutes vos demandes et remplace Postman à un prix beaucoup plus abordable !
Qu'est-ce que le Model Context Protocol (MCP) ?
Avant de plonger plus profondément dans FastMCP, il est essentiel de comprendre les concepts de base de MCP lui-même. MCP définit une manière standardisée pour les applications LLM (clients) d'interagir avec des systèmes externes (serveurs). Un serveur MCP peut exposer plusieurs composants clés :
- Outils : Ce sont essentiellement des fonctions qu'un LLM peut demander au serveur d'exécuter. Pensez à eux comme des points de terminaison POST dans une API traditionnelle. Ils effectuent des actions, interagissent potentiellement avec d'autres systèmes (bases de données, API, matériel) et renvoient des résultats. Par exemple, un outil pourrait envoyer un e-mail, interroger une base de données ou effectuer un calcul.
- Ressources : Celles-ci exposent des données qu'un LLM peut lire ou récupérer. Semblables aux points de terminaison GET, les ressources fournissent des informations pour enrichir le contexte du LLM. Cela peut être n'importe quoi, des fichiers de configuration et des profils d'utilisateur aux flux de données en temps réel.
- Invites : Ce sont des modèles réutilisables pour structurer les interactions avec le LLM. Ils aident à guider la conversation et à garantir des résultats cohérents pour des tâches spécifiques.
- Contexte : Les serveurs peuvent fournir des informations contextuelles, notamment des instructions sur la meilleure façon d'interagir avec les outils et les ressources disponibles.
MCP vise à créer un écosystème robuste et sécurisé où les LLMs peuvent accéder et utiliser de manière fiable les capacités externes.
Pourquoi choisir FastMCP ?
Bien que vous puissiez implémenter la spécification MCP directement à l'aide de SDK de bas niveau, FastMCP offre des avantages convaincants, en particulier pour les développeurs Python :
- 🚀 Développement rapide : Son interface de haut niveau réduit considérablement la quantité de code nécessaire, accélérant le processus de développement. Souvent, la définition d'un outil ou d'une ressource est aussi simple que de décorer une fonction Python standard.
- 🍀 Simplicité : FastMCP abstrait les détails complexes de la configuration du serveur, de la gestion des protocoles, des types de contenu et de la gestion des erreurs, minimisant ainsi le code passe-partout.
- 🐍 Pythonique : Conçu en tenant compte des meilleures pratiques de Python, il semble naturel et intuitif pour les développeurs familiarisés avec le langage, en tirant parti de fonctionnalités telles que les indications de type et les décorateurs.
- 🔍 Complet : FastMCP vise à fournir une implémentation complète de la spécification MCP de base, garantissant la compatibilité et l'accès au plein potentiel du protocole.
FastMCP version 1 a connu un grand succès et est désormais intégré au SDK Python MCP officiel. La version 2 s'appuie sur cette base, en introduisant des fonctionnalités avancées axées sur la simplification des interactions avec le serveur, telles que des clients flexibles, la procuration de serveur et des modèles de composition.
Comment installer FastMCP
La configuration de FastMCP dans votre environnement Python est simple. La méthode recommandée utilise uv, un installateur et un résolveur de packages Python rapides.
1. Utilisation de uv (recommandé) :
Si vous gérez les dépendances d'un projet, ajoutez FastMCP en utilisant :
uv add fastmcp
Vous pouvez également l'installer directement dans votre environnement :
uv pip install fastmcp
2. Utilisation de pip :
Si vous préférez utiliser pip, vous pouvez installer FastMCP avec :
pip install fastmcp
3. Vérification de l'installation :
Après l'installation, vous pouvez vérifier que FastMCP est correctement installé et vérifier sa version, ainsi que la version du SDK MCP sous-jacent et les détails de votre environnement Python, en exécutant :
fastmcp version
Vous devriez voir une sortie similaire à celle-ci :
$ fastmcp version
FastMCP version: 0.4.2.dev41+ga077727.d20250410
MCP version: 1.6.0
Python version: 3.12.2
Platform: macOS-15.3.1-arm64-arm-64bit
FastMCP root path: ~/Developer/fastmcp
4. Installation pour le développement :
Si vous avez l'intention de contribuer au projet FastMCP lui-même, vous devrez configurer un environnement de développement :
git clone https://github.com/jlowin/fastmcp.git
cd fastmcp
uv sync
Cela clone le référentiel, navigue dans le répertoire et utilise uv sync pour installer toutes les dépendances nécessaires, y compris les outils de développement, dans un environnement virtuel. Vous pouvez ensuite exécuter des tests à l'aide de pytest.
Comment utiliser FastMCP : construire votre premier serveur
Maintenant, plongeons dans les aspects pratiques de l'utilisation de FastMCP.
1. Création d'une instance de serveur de base :
Le cœur de toute application FastMCP est la classe FastMCP. Vous commencez par créer une instance de cette classe.
Créez un fichier nommé my_server.py :
# my_server.py
from fastmcp import FastMCP
import asyncio # Nous en aurons besoin plus tard pour le client
# Instancier le serveur, en lui donnant un nom
mcp = FastMCP(name="My First MCP Server")
print("Objet serveur FastMCP créé.")
Le constructeur FastMCP accepte plusieurs arguments utiles :
name(str, facultatif) : Un nom lisible par l'homme pour votre serveur (par défaut "FastMCP"). Utile pour l'identification dans les journaux ou les applications clientes.instructions(str, facultatif) : Une description guidant les clients sur la façon d'interagir avec le serveur, expliquant son objectif ou mettant en évidence les fonctionnalités clés.lifespan(callable, facultatif) : Un gestionnaire de contexte asynchrone pour gérer le démarrage et l'arrêt du serveur (par exemple, l'initialisation des connexions à la base de données).tags(set[str], facultatif) : Balises pour catégoriser le serveur lui-même.**settings: Vous pouvez passer des arguments de mot-clé correspondant àServerSettings(commeport,host,log_level) directement au constructeur pour la configuration.
2. Ajout de composants :
Un serveur vide n'est pas très utile. Ajoutons les composants MCP de base.
Ajout d'un outil : Les outils sont des fonctions exposées au client. Utilisez le décorateur @mcp.tool(). FastMCP utilise les indications de type Python pour définir les paramètres d'entrée attendus et le type de retour pour le client.
# my_server.py (continued)
@mcp.tool()
def greet(name: str) -> str:
"""Retourne une simple salutation."""
return f"Bonjour, {name} !"
@mcp.tool()
def add(a: int, b: int) -> int:
"""Ajoute deux nombres ensemble."""
return a + b
print("Outils 'greet' et 'add' ajoutés.")
Ajout d'une ressource : Les ressources exposent des données via un URI. Utilisez le décorateur @mcp.resource(), en fournissant la chaîne URI.
# my_server.py (continued)
APP_CONFIG = {"theme": "dark", "version": "1.1", "feature_flags": ["new_dashboard"]}
@mcp.resource("data://config")
def get_config() -> dict:
"""Fournit la configuration de l'application."""
return APP_CONFIG
print("Ressource 'data://config' ajoutée.")
Ajout d'un modèle de ressource : Ce sont comme des ressources dynamiques où des parties de l'URI agissent comme des paramètres.
# my_server.py (continued)
USER_PROFILES = {
101: {"name": "Alice", "status": "active"},
102: {"name": "Bob", "status": "inactive"},
}
@mcp.resource("users://{user_id}/profile")
def get_user_profile(user_id: int) -> dict:
"""Récupère le profil d'un utilisateur par son ID."""
# Le {user_id} de l'URI est automatiquement passé en argument
return USER_PROFILES.get(user_id, {"error": "Utilisateur non trouvé"})
print("Modèle de ressource 'users://{user_id}/profile' ajouté.")
Ajout d'une invite : Les invites définissent des modèles d'interaction réutilisables.
# my_server.py (continued)
@mcp.prompt("summarize")
async def summarize_prompt(text: str) -> list[dict]:
"""Génère une invite pour résumer le texte fourni."""
return [
{"role": "system", "content": "Vous êtes un assistant utile compétent en matière de résumé."},
{"role": "user", "content": f"Veuillez résumer le texte suivant :\n\n{text}"}
]
print("Invite 'summarize' ajoutée.")
3. Test du serveur (en cours de traitement) :
Avant d'exécuter le serveur en externe, vous pouvez tester ses composants directement dans le même script Python à l'aide du Client. Ceci est utile pour des vérifications rapides et des tests unitaires.
# my_server.py (continued)
from fastmcp import Client # Importer le client
async def test_server_locally():
print("\n--- Test du serveur localement ---")
# Pointer le client directement sur l'objet serveur
client = Client(mcp)
# Les clients sont asynchrones, utilisez donc un gestionnaire de contexte async
async with client:
# Appeler l'outil 'greet'
greet_result = await client.call_tool("greet", {"name": "FastMCP User"})
print(f"Résultat de la salutation : {greet_result}")
# Appeler l'outil 'add'
add_result = await client.call_tool("add", {"a": 5, "b": 7})
print(f"Résultat de l'ajout : {add_result}")
# Lire la ressource 'config'
config_data = await client.read_resource("data://config")
print(f"Ressource de configuration : {config_data}")
# Lire un profil d'utilisateur à l'aide du modèle
user_profile = await client.read_resource("users://101/profile")
print(f"Profil de l'utilisateur 101 : {user_profile}")
# Obtenir la structure de l'invite 'summarize' (n'exécute pas l'appel LLM ici)
prompt_messages = await client.get_prompt("summarize", {"text": "Ceci est du texte."})
print(f"Structure de l'invite de résumé : {prompt_messages}")
# Exécuter la fonction de test locale
# asyncio.run(test_server_locally())
# Mis en commentaire pour l'instant, nous allons nous concentrer sur l'exécution du serveur ensuite
Notez l'utilisation de async et await. Les clients FastMCP fonctionnent de manière asynchrone, nécessitant une fonction async et utilisant async with client: pour gérer le cycle de vie du client.
4. Exécution du serveur :
Pour rendre votre serveur MCP accessible aux clients externes (comme une application LLM), vous devez l'exécuter. Il existe deux méthodes principales :
Exécution Python standard (recommandée pour la compatibilité) :
Ajoutez le bloc if __name__ == "__main__": suivant à votre fichier my_server.py. Il s'agit de la pratique Python standard pour rendre un script exécutable.
# my_server.py (à la fin du fichier)
if __name__ == "__main__":
print("\n--- Démarrage du serveur FastMCP via __main__ ---")
# Cela démarre le serveur, généralement en utilisant le transport stdio par défaut
mcp.run()
Pour exécuter le serveur, exécutez le script à partir de votre terminal :
python my_server.py
Cette commande démarre le serveur MCP, en écoutant les connexions client à l'aide du mécanisme de transport stdio (entrée/sortie standard) par défaut. Cette méthode garantit que votre serveur s'exécute de manière cohérente pour divers clients qui s'attendent à exécuter un script Python.
Utilisation de l'interface de ligne de commande FastMCP :
FastMCP fournit une interface de ligne de commande pour l'exécution de serveurs, qui offre plus de flexibilité et de contrôle, en particulier en ce qui concerne les options de transport.
# Exécuter le serveur en utilisant stdio (par défaut)
fastmcp run my_server.py:mcp
# Exécuter le serveur en utilisant les événements envoyés par le serveur (SSE) sur le port 8080
fastmcp run my_server.py:mcp --transport sse --port 8080 --host 0.0.0.0
# Exécuter avec un niveau de journalisation différent
fastmcp run my_server.py:mcp --transport sse --log-level DEBUG
Points clés concernant l'interface de ligne de commande :
my_server.py:mcp: Spécifie le fichier (my_server.py) et l'objet serveur FastMCP dans ce fichier (mcp). Si vous omettez:mcp, FastMCP essaiera de trouver automatiquement un objet nommémcp,appouserver.- Le bloc
if __name__ == "__main__":n'est pas requis lors de l'utilisation defastmcp run; l'interface de ligne de commande trouve et exécute directement l'objet serveur spécifié. --transport: Sélectionne le protocole de communication (stdio,sse). SSE est courant pour les interactions basées sur le Web.--port,--host,--log-level: Configurez les paramètres de transport et de journalisation.
5. Interaction avec un serveur en cours d'exécution (client) :
Une fois votre serveur en cours d'exécution (soit via python my_server.py, soit via fastmcp run), vous pouvez créer un script client distinct pour interagir avec lui.
Créez un nouveau fichier, my_client.py :
# my_client.py
from fastmcp import Client
import asyncio
async def interact_with_server():
print("--- Création du client ---")
# Option 1 : Se connecter à un serveur exécuté via `python my_server.py` (utilise stdio)
# client = Client("my_server.py")
# Option 2 : Se connecter à un serveur exécuté via `fastmcp run ... --transport sse --port 8080`
client = Client("http://localhost:8080") # Utilisez l'URL/le port correct
print(f"Client configuré pour se connecter à : {client.target}")
try:
async with client:
print("--- Client connecté ---")
# Appeler l'outil 'greet'
greet_result = await client.call_tool("greet", {"name": "Remote Client"})
print(f"Résultat de la salutation : {greet_result}")
# Lire la ressource 'config'
config_data = await client.read_resource("data://config")
print(f"Ressource de configuration : {config_data}")
# Lire le profil utilisateur 102
profile_102 = await client.read_resource("users://102/profile")
print(f"Profil de l'utilisateur 102 : {profile_102}")
except Exception as e:
print(f"Une erreur s'est produite : {e}")
finally:
print("--- Interaction client terminée ---")
if __name__ == "__main__":
asyncio.run(interact_with_server())
Exécutez ce script client pendant que le serveur est en cours d'exécution dans un autre terminal :
python my_client.py
Le client se connectera au serveur en cours d'exécution (assurez-vous que la cible Client(...) correspond à la façon dont le serveur est en cours d'exécution – chemin de fichier pour stdio, URL pour sse), exécutera les appels d'outils et les lectures de ressources, et imprimera les résultats.
6. Configuration du serveur (ServerSettings) :
Vous pouvez affiner le comportement du serveur à l'aide de ServerSettings. Les paramètres peuvent être appliqués par ordre de priorité :
- Arguments de mot-clé lors de l'initialisation de
FastMCP(priorité la plus élevée). - Variables d'environnement (préfixées par
FASTMCP_SERVER_, par exemple,FASTMCP_SERVER_PORT=8888). - Valeurs chargées à partir d'un fichier
.envdans le répertoire de travail. - Valeurs par défaut (priorité la plus faible).
Exemple de configuration lors de l'initialisation :
from fastmcp import FastMCP
mcp_configured = FastMCP(
name="ConfiguredServer",
port=8080, # Définit le port SSE par défaut
host="127.0.0.1", # Définit l'hôte SSE par défaut
log_level="DEBUG", # Définit le niveau de journalisation
on_duplicate_tools="warn" # Avertir si des outils portant le même nom sont enregistrés (options : 'error', 'warn', 'ignore')
)
# Accéder aux paramètres via l'attribut .settings
print(f"Port configuré : {mcp_configured.settings.port}") # Sortie : 8080
print(f"Politique d'outil en double : {mcp_configured.settings.on_duplicate_tools}") # Sortie : warn
Les principales options de configuration incluent host, port, log_level et les politiques de gestion des noms de composants en double (on_duplicate_tools, on_duplicate_resources, on_duplicate_prompts).
Que pouvez-vous faire d'autre avec FastMCP ?
FastMCP prend également en charge des cas d'utilisation plus avancés :
- Composition : Combinez plusieurs serveurs FastMCP.
main.mount("sub", sub_server)crée un lien en direct, tandis quemain.import_server(sub_server)copie les composants. Cela facilite la modularité. - Procuration : Utilisez
FastMCP.from_client(client)pour créer une instance de serveur FastMCP qui agit comme un proxy pour un autre serveur MCP (local ou distant). Ceci est utile pour relier les transports (par exemple, exposer un serveur SSE distant viastdiolocal) ou ajouter un frontend unifié.
Conclusion
FastMCP abaisse considérablement la barrière à l'entrée pour la création d'applications LLM puissantes et contextuelles en simplifiant l'implémentation du Model Context Protocol. Sa conception Pythonique, son objectif de réduire le code passe-partout et son ensemble complet de fonctionnalités en font un excellent choix pour les développeurs qui cherchent à équiper les LLMs d'outils personnalisés et d'un accès aux données de manière sécurisée et efficace.
En suivant les étapes décrites ci-dessus – l'installation de FastMCP, la création d'une instance de serveur, l'ajout d'outils et de ressources à l'aide de décorateurs simples et l'exécution du serveur – vous pouvez rapidement commencer à créer vos propres applications compatibles MCP. Que vous créiez des outils utilitaires simples ou des intégrations complexes et gourmandes en données, FastMCP fournit la base d'interactions LLM robustes et évolutives.
