Bonnes pratiques pour écrire des serveurs MCP
Un cours avancé et pratique sur la conception, l’implémentation, la sécurisation et l’exploitation de serveurs MCP pour des développeurs expérimentés qui construisent des outils pour des agents IA, des applications LLM et des systèmes RAG.
Un cours intensif destiné aux développeurs expérimentés qui connaissent Python ainsi que l’écosystème AI/ML/LLM et souhaitent concevoir des serveurs MCP de production conformément à la spécification actuelle et aux pratiques du secteur. Le programme se concentre sur l’implémentation pratique : modélisation des contrats tools/resources/prompts, choix du transport (stdio, SSE, Streamable HTTP), sécurité et autorisation OAuth, ergonomie des schémas d’entrée/sortie, réduction du risque de prompt injection, observabilité, tests de conformité et déploiement en environnement de production. Le cours prend en compte les orientations les plus récentes de l’écosystème MCP, notamment la préférence pour des SDK officiels de haut niveau conformes, les exigences actuelles concernant l’association des requêtes du serveur à une requête client lors de sampling/elicitation/roots, ainsi que les bonnes pratiques d’intégration sécurisée avec des clients tels que ChatGPT, Claude Code, VS Code et des applications personnalisées. Les documents officiels actuels indiquent notamment que Python et TypeScript sont actuellement des SDK Tier 1, que le SDK Python officiel prend en charge stdio, SSE et Streamable HTTP, et que pour les serveurs MCP distants, il est recommandé d’utiliser des serveurs de fournisseurs de confiance, de faire preuve de prudence dans l’exposition des données et d’implémenter OAuth 2.0/2.1 avec enregistrement dynamique du client lorsque cela est possible.
Ce que vous apprendrez
- Vous expliquerez l’architecture MCP et répartirez correctement les responsabilités entre tools, resources et prompts.
- Vous concevrez un serveur MCP en Python à l’aide du SDK officiel Tier 1 et choisirez le transport approprié : stdio, SSE ou Streamable HTTP.
- Vous concevrez des contrats d’entrée/sortie stables, minimaux et sécurisés, basés sur JSON Schema, pour les outils MCP.
- Vous implémenterez une authentification et une autorisation sécurisées pour un serveur MCP distant à l’aide d’OAuth 2.x, y compris la gestion correcte des bearer tokens, de HTTPS et de la rotation des jetons.
- Vous appliquerez des pratiques de réduction des risques de prompt injection, d’exfiltration de données et d’abus de privilèges dans les serveurs MCP, en tenant compte du modèle de confiance client-serveur et du human-in-the-loop pour le sampling.
- Vous utiliserez correctement sampling, elicitation et roots conformément à la direction la plus récente de la spécification : uniquement comme des opérations liées à une requête client active.
- Vous ajouterez la journalisation, le tracing, les métriques, les limites, les timeouts, les retries et l’idempotence afin que le serveur MCP soit opérationnellement prêt pour la production.
- Vous préparerez des tests contractuels et d’intégration avec MCP Inspector ainsi qu’une checklist de déploiement en production.
Prerequis
Très bonne connaissance de Python 3.11+, HTTP/JSON, programmation asynchrone (asyncio), FastAPI ou de frameworks web similaires, bases d’OAuth 2.0, Docker, ainsi qu’une expérience pratique avec les LLM/RAG/agents IA. Le participant doit comprendre la différence entre tool calling, retrieval et orchestration d’agents, et savoir lire du JSON Schema. Recommandé : expérience des tests d’intégration, de l’observabilité et du déploiement de services backend.
Programme du cours
- MCP sans marketing : tools vs resources vs prompts sur des cas d’usage réels d’agents IA
- Quand un serveur MCP doit être une couche mince au-dessus d’une API, et quand il doit être une façade métier
- Antimodèles : un seul outil pour tout, logique d’agent cachée, effets de bord implicites
- Quiz : reconnaître un bon contrat MCP et les limites erronées de la responsabilité
- Démarrer avec FastMCP : création d’un serveur, @mcp.tool(), @mcp.resource(), @mcp.prompt()
- Démarrage via uv et streamable-http : une boucle de développement locale sans cérémonie inutile
- Structure du projet : app/, domain/, adapters/, schemas/, auth/, observability/
- Async I/O, injection de dépendances et séparation de la couche protocole de la logique métier
- Quiz : quels éléments devraient aller dans la couche MCP et lesquels dans les services de domaine
- Schéma JSON pour les entrées d’outils : enum, valeurs par défaut, validation, champs requis et messages d’erreur
- Concevoir les outputs : json_response, structures de résultat, champs status/error et typed payloads
- Conception des URI de ressources : versioning, nommage, cacheabilité et sémantique de lecture
- Les prompts comme interface réutilisable : paramétrage, garde-fous et réduction des dépendances cachées
- Comment rédiger les descriptions des outils pour que les modèles les choisissent correctement et n’hallucinent pas les paramètres
- Quiz : refactorisation de schémas d’entrée/sortie mal conçus
- stdio pour les outils de développement locaux vs Streamable HTTP pour les serveurs distants
- SSE et cycle de vie du stream : timeouts, keepalive, reverse proxy, load balancer, connexions inactives
- Streamable HTTP de bout en bout avec FastAPI/ASGI : routage, concurrence, backpressure
- Idempotence, correlation IDs et request scoping lors d’opérations longues
- Quiz : choisir le bon transport pour le connecteur ChatGPT, Claude Code et votre agent IDE
- Modèle de menace pour MCP : prompt injection, exfiltration, confused deputy, outils trop larges
- OAuth 2.x dans MCP : jetons bearer, PKCE, rotation des jetons, validation des URI de redirection, HTTPS partout
- Enregistrement dynamique des clients et découverte des métadonnées : quand les déployer et comment réduire les frictions d’intégration
- Le moindre privilège en pratique : scope par outil, isolation des tenants, minimisation des données et piste d’audit
- Effets secondaires sûrs : approvals, dry-run, clés d’idempotence, vérifications de politique avant l’exécution d’une action
- Quiz : analyse d’un incident de sécurité sur un serveur MCP distant
- Sampling sans clés API côté serveur : quand cela a du sens, et quand il vaut mieux ne pas l’utiliser
- Human-in-the-loop et politiques de sécurité avec sampling/createMessage
- Nouvelle règle d’association des requêtes : roots/list, sampling/createMessage et elicitation/create uniquement dans le contexte d’une requête active
- Conception de fallbacks si le client ne prend pas en charge certaines capabilities
- Quiz : quelles interactions sont conformes à la spécification et lesquelles enfreignent le modèle du protocole
- Tests de contrat pour les schémas d’outils et les ressources : snapshots, golden files, compatibilité ascendante
- MCP Inspector et tests d’intégration end-to-end avec un client MCP
- Journalisation structurée, traces OpenTelemetry, métriques par outil et budgets de latence
- Limitation de débit, retries, disjoncteurs et dégradation des services dépendants
- Gestion des erreurs : erreurs sûres pour l’utilisateur vs diagnostics développeur, mapping des exceptions vers les réponses MCP
- Quiz : sélection des métriques et des alertes pour un serveur MCP de production
- Docker, CI/CD et release engineering pour un serveur MCP : versionnement des contrats et rollouts
- Prêt pour la publication : documentation des outils, exemples, changelog, SLA et politiques de sécurité
- Choisir des intégrations officielles et de confiance : comment ne pas construire un serveur qu’on ne peut pas utiliser en toute sécurité
- Liste de contrôle de préparation à la production : auth, logs, traces, tests, quotas, rétention des données, réponse aux incidents
- Quiz final : architecture de référence du serveur MCP pour un produit d’IA réel
Questions fréquentes
C’est un programme intensif destiné aux développeurs expérimentés qui connaissent Python ainsi que l’écosystème AI/ML/LLM et souhaitent concevoir des serveurs MCP prêts pour un déploiement en production. Le cours sera particulièrement utile aux personnes qui construisent des intégrations d’agents, des outils pour développeurs, l’automatisation de workflows et des couches d’accès sécurisées aux données.
Oui. Le programme a été conçu sur la base des pratiques actuelles de l’écosystème MCP, dans lequel Streamable HTTP est le transport recommandé pour les serveurs distants, tandis que l’ancien modèle HTTP+SSE est maintenu principalement pour la compatibilité ascendante. Nous abordons également les orientations les plus récentes, telles que l’importance croissante de l’autorisation, le MCP Registry officiel en preview et les changements de spécification renforçant l’interopérabilité et la sécurité.
Les participants implémentent les contrats tools, resources et prompts, conçoivent des schémas d’entrée/sortie ergonomiques, choisissent le transport approprié, construisent une couche d’autorisation OAuth, mettent en place l’observabilité, les tests de conformité et des mécanismes de réduction du prompt injection. Nous mettons l’accent sur les décisions architecturales qui comptent en environnement de production : stabilité des interfaces, sécurité et diagnostic.
Absolument. C’est l’un des modules clés. Nous abordons le modèle de confiance MCP, l’autorisation OAuth pour les serveurs distants, la validation des données d’entrée et de sortie, la minimisation des privilèges et les techniques de réduction du prompt injection. C’est important aussi parce que les publications de recherche les plus récentes de 2025 et 2026 soulignent des vulnérabilités réelles liées à l’implémentation et à la conformité des serveurs MCP.
Oui. Le cours montre quand utiliser stdio dans les intégrations locales, comment comprendre le legacy HTTP+SSE et pourquoi les déploiements distants modernes s’appuient de plus en plus sur Streamable HTTP. Cela vous aidera à prendre les bonnes décisions de conception selon le type de client, les exigences réseau et le modèle de session.
Parce que MCP devient rapidement un standard d’intégration des modèles avec des outils et des sources de données. L’écosystème mûrit : des SDK officiels sont disponibles, un registry de serveurs est en développement, et les grands acteurs soutiennent une approche interopérable des agents et du tool-use. C’est le bon moment pour aller au-delà des tutoriels et apprendre des pratiques qui permettent de construire des serveurs maintenables, conformes à la spécification et prêts à évoluer avec le protocole.
- 40 heures
- Avance
- Certificat a la fin
- Acces immediat apres achat
- Acces a vie et mises a jour
Garantie 30 jours