FastMCP 2.0 : Le cœur Pythonique des interactions avec les LLM

Dans le paysage en constante évolution de l'IA, la capacité des grands modèles linguistiques (LLM) à interagir avec des données externes et à exécuter des fonctions spécifiques est primordiale. C'est là qu'intervient FastMCP 2.0, un framework Python open-source révolutionnaire qui fournit "le port USB-C pour l'IA" – une approche standardisée, efficace et pythonique pour créer des serveurs et des clients selon le Protocole de Contexte de Modèle (MCP).

Qu'est-ce que le Protocole de Contexte de Modèle (MCP) ?

Le Protocole de Contexte de Modèle (MCP) est une nouvelle norme conçue pour permettre aux applications LLM d'accéder de manière sécurisée et uniforme aux données et fonctionnalités externes. Considérez-le comme une API spécifiquement adaptée aux interactions LLM. Les serveurs MCP peuvent :

• Exposer des Ressources : Fournir des sources de données en lecture seule, similaires aux points de terminaison GET, pour charger des informations dans le contexte du LLM.
• Offrir des Outils : Permettre aux LLM d'effectuer des actions en exécutant des fonctions Python, à l'image des points de terminaison POST, pour des calculs, des appels d'API ou des effets secondaires.
• Définir des Invites : Créer des modèles de messages réutilisables qui guident les interactions LLM.

Pourquoi FastMCP 2.0 ?

Bien que le protocole MCP soit puissant, son implémentation à partir de zéro implique une quantité importante de code répétitif. FastMCP 2.0 élimine cette complexité, gérant la configuration du serveur, les gestionnaires de protocole, les types de contenu et la gestion des erreurs, permettant aux développeurs de se concentrer uniquement sur la création d'outils et de ressources utiles. Il est conçu pour être de haut niveau et pythonique, ne nécessitant souvent qu'un simple décorateur de fonction pour exposer des fonctionnalités à un LLM.

FastMCP 2.0 n'est pas seulement une mise à niveau ; c'est un écosystème complet construit sur les fondations de FastMCP 1.0 (maintenant intégré au SDK Python officiel de MCP). Cette dernière itération offre une boîte à outils complète pour les applications d'IA prêtes pour la production, y compris :

• Bibliothèques clientes : Interagissez de manière transparente avec n'importe quel serveur MCP par programmation.
• Systèmes d'authentification : Sécurisez vos serveurs et vos clients grâce à une prise en charge d'authentification intégrée.
• Outils de déploiement : Options simplifiées pour exécuter votre serveur localement ou le déployer en tant que service web.
• Intégrations : Générez des serveurs FastMCP à partir de spécifications OpenAPI existantes ou d'applications FastAPI, intégrant instantanément vos API web dans l'écosystème MCP.
• Frameworks de test : Test en mémoire efficace de vos serveurs sans gestion de processus ni appels réseau.
• Fonctionnalités avancées : Prise en charge des serveurs proxy, de la composition de serveurs, de la réécriture dynamique d'outils et des formats de documentation adaptés aux LLM.

Concepts Clés de FastMCP

FastMCP simplifie la création d'applications MCP grâce à des concepts de base intuitifs :

• Serveur FastMCP : L'objet central qui contient vos outils, ressources et invites, gérant les connexions et les configurations.
• Outils : Fonctions Python décorées avec @mcp.tool que les LLM peuvent appeler pour effectuer des actions. FastMCP génère automatiquement des schémas à partir des annotations de type et des docstrings.
• Ressources et Modèles : Sources de données exposées via @mcp.resource, permettant des données statiques ou des modèles dynamiques avec des espaces réservés pour les paramètres.
• Invites : Modèles de messages réutilisables définis avec @mcp.prompt pour guider les interactions LLM.
• Contexte : Accès aux capacités de session MCP dans vos outils, ressources ou invites, permettant la journalisation, l'échantillonnage LLM (ctx.sample()), les requêtes HTTP et le rapport de progression.
• Clients MCP : Le fastmcp.Client peut se connecter à des scripts locaux, des points de terminaison SSE, ou même des instances de serveur en mémoire pour des tests efficaces.

Premiers Pas avec FastMCP

FastMCP est conçu avec 💙 par Prefect. L'installation est simple en utilisant uv pip install fastmcp.

Pour exécuter un serveur de base, définissez vos outils et ressources dans une instance FastMCP et appelez mcp.run() :

# server.py
from fastmcp import FastMCP

mcp = FastMCP("Démo 🚀")

@mcp.tool
def ajouter(a: int, b: int) -> int:
    """Ajoute deux nombres"""
    return a + b

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

Exécutez votre serveur localement simplement en exécutant fastmcp run server.py.

FastMCP prend en charge divers protocoles de transport, y compris STDIO (par défaut), HTTP en continu, et SSE, assurant une flexibilité pour les environnements de développement et de production.

Avec plus de 13,6k étoiles et 830 forks sur GitHub, FastMCP est un projet en pleine croissance soutenu par une communauté dynamique. Son engagement à être rapide, simple, pythonique et complet en fait un outil indispensable pour quiconque cherche à construire des applications robustes et évolutives alimentées par les LLM.