Model Context Protocol (MCP) expliqué : hôte, client, serveur, outils et transports

Model Context Protocol expliqué : hôte, client, serveur, outils, ressources, prompts, transports stdio et HTTP, et ce que MCP change pour les ops.
Model Context Protocol (MCP) expliqué : hôte, client, serveur, outils et transports

Le Model Context Protocol (MCP) est un standard ouvert qui définit comment une application d’IA se connecte à des outils et à des sources de données externes. Au lieu d’écrire une intégration spécifique pour chaque couple « assistant × système », on expose une fois ses capacités derrière un serveur MCP, et n’importe quel client compatible peut les utiliser : un assistant de code, un agent conversationnel ou un outil interne.

Publié par Anthropic fin 2024 puis adopté par de nombreux éditeurs et projets open source, MCP est rapidement devenu le point de passage entre les modèles de langage et le reste du système d’information. Pour une équipe d’exploitation, c’est une question très concrète : demain, des agents liront vos métriques, ouvriront vos runbooks et proposeront des actions. Mieux vaut comprendre le protocole avant de le brancher sur la production.

Cet article est le point d’entrée de notre série MCP. Il explique l’architecture, les trois primitives exposées par un serveur, les transports, puis ce que tout cela change pour un SRE ou un ingénieur plateforme.

Qu’est-ce que le Model Context Protocol, concrètement ?

MCP est un protocole d’échange de messages fondé sur JSON-RPC 2.0. Il ne dit rien du modèle utilisé ni de la façon dont celui-ci raisonne : il standardise uniquement la conversation entre l’application qui héberge le modèle et les services qui lui fournissent du contexte ou des capacités d’action. On le compare souvent à un « port USB-C de l’IA » : un connecteur unique, des périphériques interchangeables.

La spécification est versionnée par date et publiée sur modelcontextprotocol.io, avec des SDK officiels dans plusieurs langages. Elle évolue régulièrement : vérifiez toujours quelle révision vos clients et serveurs prennent en charge.

Hôte, client, serveur : qui fait quoi ?

Le vocabulaire MCP distingue trois rôles, et les confondre est la première source d’erreurs de conception.

  • L’hôte est l’application avec laquelle l’utilisateur interagit : un éditeur de code, une application de chat, un agent maison. C’est lui qui détient le modèle, gère le consentement de l’utilisateur et décide quels serveurs sont autorisés.
  • Le client est un composant de l’hôte. Il maintient une connexion avec un serveur donné. Un hôte relié à trois serveurs fait donc tourner trois clients.
  • Le serveur est un programme, souvent léger, qui expose des capacités : interroger une plateforme d’observabilité, lire une base de connaissances, créer un ticket.

Cette séparation a une conséquence importante : le serveur ne voit jamais la conversation complète. Il reçoit des requêtes précises et renvoie des résultats. C’est l’hôte qui assemble le tout et le présente au modèle.

Les trois primitives d’un serveur MCP

Les outils (tools)

Un outil est une fonction que le modèle peut décider d’appeler : il a un nom, une description en langage naturel et un schéma JSON pour ses arguments. Le client les découvre avec tools/list et les invoque avec tools/call. Ce sont les outils qui donnent à un agent sa capacité d’action, et donc l’essentiel du risque.

Les ressources (resources)

Une ressource est une donnée identifiée par une URI : un fichier, un runbook, un schéma de base, un extrait de documentation. Elle est plutôt pilotée par l’application, qui choisit de l’ajouter au contexte. Les méthodes correspondantes sont resources/list et resources/read.

Les prompts

Un prompt est un modèle de message réutilisable, généralement déclenché explicitement par l’utilisateur, par exemple une commande « analyser l’incident en cours » qui prépare les bonnes questions. Il se découvre avec prompts/list et se récupère avec prompts/get.

La spécification décrit aussi des capacités côté client, comme l’échantillonnage (le serveur demande une génération au modèle de l’hôte) ou la sollicitation d’informations auprès de l’utilisateur. Leur prise en charge varie selon les hôtes, et certaines évoluent d’une révision à l’autre : vérifiez leur statut dans la révision que vous ciblez.

Les transports : stdio ou HTTP ?

MCP définit deux transports standards :

  • stdio : l’hôte lance le serveur comme un processus local et échange les messages par l’entrée et la sortie standard. C’est simple, sans réseau, idéal sur un poste de développeur. En contrepartie, la sortie standard est réservée au protocole : tout journal doit partir sur la sortie d’erreur.
  • HTTP (« Streamable HTTP ») : le serveur est un service distant joignable par HTTP, capable de diffuser des réponses en flux. Il remplace l’ancien transport HTTP + SSE des premières versions. C’est le choix naturel pour un serveur partagé par une équipe, avec une authentification que la spécification fonde sur OAuth.

En pratique, stdio convient aux usages individuels et HTTP aux serveurs mutualisés, déployés et supervisés comme n’importe quel microservice.

Pourquoi MCP intéresse les équipes ops

Pour une équipe plateforme, MCP apporte trois bénéfices tangibles. D’abord, une intégration unique : un serveur pour votre outil interne sert tous les assistants de l’entreprise. Ensuite, un point de contrôle : chaque appel d’outil passe par une interface déclarée, que l’on peut restreindre, journaliser et tracer. Enfin, un contexte de production réel : un assistant de code qui interroge votre plateforme d’observabilité raisonne sur des faits, pas sur des suppositions, comme on l’a vu avec le plugin Dynatrace pour Cursor.

Le revers est symétrique : un serveur MCP mal configuré offre à un modèle, et indirectement à quiconque peut l’influencer, un accès à vos systèmes. La sécurité et l’observabilité ne sont pas des options.

En pratique

Étape 1 — Choisir un premier serveur en lecture seule

Commencez par un serveur existant qui ne fait que lire, par exemple celui de votre plateforme d’observabilité. Le serveur MCP de Dynatrace dans un assistant de code est un bon cas d’école : on y passe d’un symptôme à un correctif sans rien modifier en production.

Étape 2 — Déclarer le serveur dans l’hôte

La plupart des hôtes acceptent une configuration JSON qui décrit comment lancer ou joindre chaque serveur. La forme exacte dépend de l’hôte ; elle ressemble souvent à ceci :

{
  "mcpServers": {
    "runbooks": {
      "command": "python",
      "args": ["serveur_runbooks.py"],
      "env": { "RUNBOOKS_DIR": "/opt/runbooks" }
    }
  }
}

Étape 3 — Observer l’échange

Pour comprendre ce qui circule, inspectez les messages. Un appel d’outil est une simple requête JSON-RPC :

{
  "jsonrpc": "2.0",
  "id": 7,
  "method": "tools/call",
  "params": {
    "name": "get_runbook",
    "arguments": { "service": "paiement" }
  }
}

Le projet propose un outil de débogage, MCP Inspector, pour explorer un serveur et rejouer ses outils : consultez la documentation officielle pour son mode de lancement.

Étape 4 — Écrire votre propre serveur

Une fois le protocole compris, exposer vos propres procédures devient accessible. Notre guide pour créer un serveur MCP en Python part d’un cas concret : rendre les runbooks d’exploitation consultables par un assistant.

Étape 5 — Sécuriser et tracer avant d’élargir

Avant d’ouvrir l’accès à d’autres équipes, appliquez les règles décrites dans sécuriser un serveur MCP et instrumentez les appels comme expliqué dans observer les agents MCP avec OpenTelemetry.

Bonnes pratiques

  • Démarrer en lecture seule et n’ajouter des outils d’écriture qu’avec une validation humaine explicite.
  • Rédiger des descriptions d’outils précises : le modèle choisit ses outils d’après elles.
  • Limiter le nombre d’outils par serveur ; trop de choix dégrade la sélection.
  • Utiliser stdio en local, HTTP authentifié pour tout serveur partagé.
  • Épingler les versions des serveurs tiers et relire leurs mises à jour.
  • Journaliser chaque appel d’outil avec son appelant, ses arguments et son résultat.

Questions fréquentes

MCP est-il lié à un modèle ou à un éditeur particulier ?

Non. Le protocole est ouvert et indépendant du modèle. Il a été initié par Anthropic, mais de nombreux hôtes, éditeurs et projets open source l’implémentent.

Quelle différence entre MCP et une API REST classique ?

MCP ne remplace pas vos API : un serveur MCP les enveloppe souvent. Il ajoute la découverte dynamique des capacités et des descriptions pensées pour qu’un modèle sache quand et comment les utiliser.

Faut-il préférer stdio ou HTTP ?

stdio pour un usage local et personnel, HTTP pour un serveur mutualisé qui doit être authentifié, mis à l’échelle et supervisé.

Conclusion

Le Model Context Protocol fournit un langage commun entre les assistants IA et vos systèmes. Pour les équipes ops, il ouvre une perspective intéressante, des agents qui travaillent sur des données réelles, à condition de traiter chaque serveur comme un composant de production : périmètre réduit, accès contrôlé, appels tracés. Les articles satellites de cette série détaillent chacune de ces étapes.

span.observer est un blog indépendant de la communauté, non affilié à Dynatrace LLC ni aux projets cités. Les marques citées appartiennent à leurs propriétaires. Les outils évoluent vite : vérifiez les commandes et options dans leur documentation officielle.

Total
0
Shares
7 comments
Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Previous Post
Ingestion logs : détecter le silence, les trous de couverture et les excès de volume

Ingestion logs : détecter le silence, les trous de couverture et les excès de volume

Next Post
Serveur MCP Dynatrace : du symptôme au correctif avec un assistant de code

Serveur MCP Dynatrace : du symptôme au correctif avec un assistant de code

Related Posts