Technical Tutorials

Le protocole de contexte de modèle (MCP) est rapidement devenu la norme pour connecter les grands modèles de langage (LLM) aux outils et sources de données externes. À mesure que les développeurs passent du prompting statique aux flux de travail dynamiques et agentiques, comprendre comment construire des serveurs MCP efficaces n'est plus optionnel, c'est essentiel. Un serveur MCP agit comme le pont entre le moteur de raisonnement de l'IA et le monde réel, lui permettant de récupérer des données en direct, d'exécuter du code ou d'interagir avec des API propriétaires de manière structurée et sécurisée.

Qu'est-ce qu'un serveur MCP ?

En son cœur, un serveur MCP est une application légère qui expose des capacités spécifiques (outils) aux clients MCP. Le client, généralement une interface LLM ou un agent IA, découvre ces outils et les invoque lorsque c'est approprié. Contrairement aux API REST traditionnelles, conçues pour des charges utiles JSON lisibles par l'homme, MCP utilise un protocole JSON-RPC 2.0 standardisé pour gérer les cycles de requête/réponse, les abonnements et la gestion des erreurs, spécifiquement optimisé pour l'interaction avec l'IA.

La principale proposition de valeur de MCP réside dans sa prise en compte du contexte. Il permet au LLM non seulement d'appeler une fonction, mais aussi de comprendre le schéma de l'entrée qu'il s'attend à recevoir et le format de la sortie qu'il obtiendra, le tout sans intervention humaine dans la boucle.

Architecture et protocole

La spécification MCP définit trois types principaux d'interactions :

Outils : Fonctions exécutables (par exemple, "calculate_sum", "query_database").
Ressources : Sources de données en lecture seule (par exemple, "get_file_contents", "fetch_news_headlines").
Invocations : Modèles d'invocations prédéfinis que le client peut appeler.

La communication se fait via stdio (entrée/sortie standard) ou Server-Sent Events (SSE). Pour le développement local, stdio est l'approche par défaut et la plus simple, ce qui en fait un choix idéal pour les tests et les applications de bureau.

Construire votre premier serveur MCP avec Python

Bien que vous puissiez construire des serveurs MCP à partir de zéro dans n'importe quel langage, la bibliothèque fastmcp offre une expérience de développement fluide. Ci-dessous se trouve un exemple pratique d'un serveur MCP qui expose un outil de calculatrice simple et une ressource statique.


from fastmcp import FastMCP

mcp = FastMCP("Math Server")

@mcp.tool()
def add(a: float, b: float) -> float:
    """
    Adds two numbers together.
    
    Args:
        a: The first number.
        b: The second number.
    Returns:
        The sum of a and b.
    """
    return a + b

@mcp.resource("config://server_settings")
def get_server_settings() -> dict:
    """
    Returns the current configuration settings for the server.
    """
    return {
        "version": "1.0.0",
        "environment": "production",
        "features": ["addition", "subtraction"]
    }

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

Dans cet exemple, le décorateur @mcp.tool() définit une fonction que le LLM peut appeler. La docstring est cruciale ici ; les clients MCP utilisent ces descriptions pour déterminer *quand* utiliser l'outil. De même, le décorateur @mcp.resource() expose des données. Le schéma d'URI (config://) aide à catégoriser la ressource pour le client.

Meilleures pratiques pour le développement

Lors de la construction de serveurs MCP de qualité production, tenez compte des éléments suivants :

Descriptions d'outils claires : Les LLM s'appuient fortement sur la documentation. Soyez explicite sur les types d'entrée, les contraintes et les sorties attendues. Évitez l'ambiguïté.
Absence d'état (Statelessness) : Idéalement, les serveurs MCP devraient être sans état. Si un état est requis (par exemple, la gestion de session), gérez-le en interne via une base de données ou un cache, sans compter sur le client pour maintenir le contexte entre les appels.
Gestion des erreurs : Retournez des messages d'erreur significatifs. Si un outil échoue, le LLM doit savoir *pourquoi* afin qu'il puisse ajuster sa stratégie (par exemple, réessayer avec des paramètres différents ou choisir un autre outil).
Sécurité : N'exposez jamais de credentials sensibles dans les définitions d'outils. Utilisez des variables d'environnement ou des coffres-forts de clés sécurisés. Validez toutes les entrées pour prévenir les attaques par injection, en particulier lorsque les outils interagissent avec des bases de données ou des commandes shell.
Tests : Utilisez l'Inspecteur MCP (disponible dans le dépôt GitHub MCP) pour déboguer votre serveur. Il fournit une interface utilisateur pour lister les outils, afficher les schémas et tester les invocations manuellement.

Considérations de déploiement

Pour le développement local, l'exécution via stdio est suffisante. Cependant, pour un accès à distance (par exemple, depuis un agent IA basé dans le cloud), vous devez exposer le serveur via HTTP/SSE. Des bibliothèques comme fastmcp prennent en charge cette fonctionnalité nativement :


if __name__ == "__main__":
    # For remote access
    mcp.run(transport="sse", host="0.0.0.0", port=8000)

Notez que les points de terminaison SSE nécessitent une configuration CORS appropriée et une authentification (par exemple, des clés API, OAuth) pour prévenir l'accès non autorisé. Déployez toujours derrière un proxy inverse (comme Nginx ou Caddy) pour la terminaison TLS et la limitation de débit.

Conclusion

Les serveurs MCP représentent un changement de paradigme dans la façon dont nous intégrons l'IA avec les systèmes d'entreprise. En standardisant l'interface, MCP réduit le code de base nécessaire pour connecter les LLM à de nouveaux outils, permettant une itération plus rapide et des applications agentiques plus robustes. À mesure que l'écosystème mûrit, attendez-vous à voir des fonctionnalités plus avancées comme la sortie d'outils en streaming, les flux de travail multi-étapes et une intégration plus étroite avec les principaux fournisseurs d'IA. Commencez petit avec un seul outil, validez-le avec l'Inspecteur et passez à l'échelle supérieure à mesure que vos besoins grandissent. L'avenir de l'IA est connecté, et MCP est le protocole qui le rend possible.