Comment fonctionne MCP : host, client, serveur, JSON-RPC et transports

Comment fonctionne MCP : host, client, serveur, JSON-RPC et transports

Dans le premier article, on a vu pourquoi MCP existe : brancher n'importe quelle IA sur n'importe quel outil avec un seul protocole. On ouvre maintenant le capot : qui parle à qui, avec quels messages, et par quel canal. Tous les exemples JSON de cet article sont de vrais messages, capturés avec le petit serveur que l'on construira dans le troisième article (et, pour la révision 2026-07-28, avec sa version Symfony de l'article 4).

Quelle version du protocole ? La spécification MCP évolue par révisions datées. Cet article suit la révision 2025-11-25 : c'est celle que parlent aujourd'hui la plupart des SDK et des applications. La révision 2026-07-28 simplifie plusieurs mécanismes : je la présente en fin d'article.

Les trois rôles : host, client, serveur

Un host qui dialogue avec le modèle et trois clients, chacun relié à un serveur MCP différent
Schéma — Un host dialogue avec le modèle et ouvre un client par serveur. Chaque serveur donne accès à une ressource réelle.
RôleExemplesSa responsabilité
HostClaude Desktop, Claude Code, un IDE, votre propre applicationL'application utilisée par l'humain. Elle dialogue avec le modèle (souvent via une API distante), garde le contexte de la conversation, choisit quels serveurs sont autorisés et demande le consentement de l'utilisateur.
ClientUn composant à l'intérieur du hostGère une connexion vers un serveur (relation un à un) : ouverture, négociation, envoi des requêtes, réception des réponses.
ServeurServeur de fichiers, GitHub, base de données…Expose des capacités (outils, données, modèles de prompts) et les exécute réellement. C'est lui qui porte la sécurité : authentification, droits, limites.

Un même host ouvre donc autant de clients qu'il utilise de serveurs. Point d'entretien classique : une connexion MCP ne donne aucun droit implicite. Le serveur doit toujours vérifier ce que l'utilisateur a le droit de faire, même si la demande vient d'un client connecté.

Le langage commun : JSON-RPC 2.0

Tous les échanges MCP sont des messages JSON-RPC 2.0. Il en existe trois sortes :

  • La requête : elle a un id, une method et des params. Elle attend une réponse.
  • La réponse : elle reprend le même id, et contient soit un result, soit une error.
  • La notification : elle n'a pas d'id. C'est un message à sens unique, on n'attend pas de réponse.

Voici une vraie requête d'appel d'outil, puis la réponse du serveur. Notez que l'id (ici 2) relie les deux :

{"jsonrpc":"2.0","id":2,"method":"tools/call",
 "params":{"name":"ajouter_note","arguments":{"texte":"Tester MCP"}}}

{"jsonrpc":"2.0","id":2,
 "result":{"content":[{"type":"text","text":"Note ajoutée (3 au total)."}]}}

Le cycle de vie d'une connexion

Dans la révision 2025-11-25, la spécification découpe une session en trois temps : l'initialisation, le fonctionnement et la fermeture. Pour mieux comprendre, le schéma sépare le fonctionnement en deux (découverte, puis utilisation), et met à part les notifications, qui circulent tout au long de la session :

Initialisation, découverte, utilisation, et notifications tout au long de la session
Schéma — Initialisation, découverte, utilisation, et notifications tout au long de la session (révision 2025-11-25).

1. Initialisation : la poignée de main

Le client envoie initialize avec la version du protocole qu'il parle et ses propres capacités. La spécification est versionnée par date (ici 2025-11-25) : client et serveur s'accordent sur une version commune.

{"jsonrpc":"2.0","id":0,"method":"initialize",
 "params":{"protocolVersion":"2025-11-25","capabilities":{},
           "clientInfo":{"name":"test","version":"1.0.0"}}}

Le serveur répond avec ses capacités. C'est la négociation des capacités : ici, il annonce qu'il propose des tools, des resources et des prompts, et qu'il préviendra si leur liste change (listChanged).

{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":"2025-11-25",
 "capabilities":{"tools":{"listChanged":true},
                 "resources":{"listChanged":true},
                 "prompts":{"listChanged":true}},
 "serverInfo":{"name":"carnet-de-notes","version":"1.0.0"}}}

Le client confirme ensuite par une notification (pas d'id) : {"jsonrpc":"2.0","method":"notifications/initialized"}. La session est ouverte.

2. Découverte : « qu'est-ce que tu sais faire ? »

Le client demande la liste de ce que le serveur propose : tools/list, resources/list, prompts/list. Chaque outil est décrit par un nom, une description et un JSON Schema de ses arguments :

{"jsonrpc":"2.0","id":1,"result":{"tools":[{
  "name":"ajouter_note",
  "description":"Ajoute une note au carnet",
  "inputSchema":{"type":"object",
    "properties":{"texte":{"type":"string","description":"Le contenu de la note"}},
    "required":["texte"]}}]}}

C'est cette description que le host transmet au modèle. Le modèle ne connaît donc que ce que le serveur a déclaré. Si la liste est longue, elle est paginée (la réponse contient un nextCursor, à renvoyer dans le paramètre cursor de la requête suivante).

3. Utilisation : les appels

Quand le modèle décide d'utiliser un outil, le client envoie tools/call (l'exemple vu plus haut). Pour lire une donnée, c'est resources/read ; pour récupérer un modèle de prompt, prompts/get. On détaille ces trois primitives dans le prochain article.

Diagramme de séquence entre client et serveur : initialize, tools/list, tools/call
Schéma — Le minimum vital d'une session : initialize, tools/list, tools/call (révision 2025-11-25).

Tout au long de la session : les notifications

Pendant toute la session, les deux côtés peuvent s'envoyer des notifications (en 2026-07-28, sans session, le client les reçoit en s'abonnant avec subscriptions/listen, et la progression arrive avec la réponse de la requête concernée) :

  • notifications/tools/list_changed (et ses équivalents pour resources et prompts) : « ma liste a changé, redemande-la ». Pas besoin d'interroger en boucle.
  • notifications/progress : l'avancement d'une opération longue.
  • notifications/cancelled : « laisse tomber la requête n°X ».
  • notifications/message : des logs envoyés par le serveur (le logging est déprécié en 2026-07-28).

Il existe aussi un ping (une requête, cette fois) pour vérifier que l'autre côté est toujours vivant. Il a disparu de la révision 2026-07-28.

Et la fermeture ?

Rien de spectaculaire : en stdio, le client ferme l'entrée standard du serveur et le processus s'arrête ; en HTTP (révision 2025-11-25), le client peut envoyer un DELETE avec son identifiant de session (en 2026-07-28, sans session, il n'y a plus rien à fermer en HTTP). On le verra en vrai dans l'article sur Symfony.

Les deux transports : stdio et HTTP

Les messages JSON-RPC doivent bien voyager quelque part. MCP définit deux transports standards :

stdio : host et serveur sur la même machine via stdin et stdout ; HTTP : serveur distant via Internet avec authentification
Schéma — stdio pour un serveur local, Streamable HTTP pour un serveur distant et partagé.
stdioStreamable HTTP
PrincipeLe host lance le serveur comme sous-processus. Messages sur l'entrée standard (stdin) et la sortie standard (stdout), un message JSON par ligne.Le serveur est un service web avec un point d'entrée unique (ex. POST /mcp). Il répond en JSON, ou en flux (SSE) pour les réponses longues.
Cas d'usageOutils locaux : fichiers, Git, base de dev, analyse de code.Services partagés : SaaS, serveurs d'entreprise, plusieurs utilisateurs.
SécuritéAucun port réseau ouvert. Le serveur a les droits de l'utilisateur qui le lance : à isoler (conteneur) si on ne lui fait pas confiance.Authentification indispensable en pratique (la spécification s'appuie sur OAuth 2.1), contrôle d'accès, journalisation : c'est un service exposé comme un autre.

Piège classique en stdio : stdout est réservé au protocole. Un simple echo ou console.log de debug corrompt le flux JSON-RPC. Les logs doivent partir sur stderr.

Bon à savoir : l'ancien transport « HTTP + SSE » (deux points d'entrée séparés) est déprécié au profit de Streamable HTTP.

Enfin, le modèle ne voit jamais le transport : pour lui, un outil reste un outil, qu'il tourne sur votre portable ou dans le cloud.

Deux sortes d'erreurs

MCP distingue deux niveaux d'erreur, et c'est une question d'entretien très appréciée :

  • L'erreur de protocole : la requête elle-même est invalide (message mal formé, méthode inconnue, outil inexistant…). Le serveur répond avec un objet error JSON-RPC et un code standard : -32700 (JSON illisible), -32600 (requête invalide), -32601 (méthode inconnue), -32602 (paramètres invalides : outil inconnu, requête mal structurée), -32603 (erreur interne).
  • L'erreur d'exécution d'un outil : l'outil a échoué, ou ses arguments ne respectent pas le schéma. Le serveur renvoie un result normal avec "isError": true. L'intérêt : le message d'erreur arrive dans le contexte du modèle, qui peut comprendre et corriger son appel.

Le cas des arguments invalides a longtemps été ambigu. La révision 2025-11-25 a tranché (proposition SEP-1303) : ils doivent être renvoyés comme des erreurs d'exécution (isError), justement pour que le modèle puisse se corriger. Exemple réel : on envoie un nombre au lieu d'un texte, et le SDK TypeScript répond ainsi :

{"jsonrpc":"2.0","id":5,"result":{"isError":true,"content":[{"type":"text",
 "text":"Input validation error: Invalid arguments for tool ajouter_note: texte: Invalid input: expected string, received number"}]}}

Ce qui change avec la révision 2026-07-28

La révision publiée le 28 juillet 2026 rend le protocole sans état. Les SDK s'y mettent progressivement : le SDK PHP officiel parle déjà les deux révisions, alors que le SDK TypeScript 2.4 en reste à 2025-11-25. Les serveurs dits « bi-révision » acceptent les deux en même temps. Voici les changements à connaître :

  • Plus de poignée de main : initialize et notifications/initialized disparaissent. Chaque requête porte elle-même sa version et les capacités du client, dans son champ _meta. Pour connaître le serveur, le client peut appeler server/discover, sans y être obligé.
  • Plus de session en HTTP : l'en-tête Mcp-Session-Id est supprimé. Chaque requête HTTP est autonome et annonce sa méthode (Mcp-Method) et, le cas échéant, le nom de l'outil ou du prompt visé (Mcp-Name).
  • Les abonnements changent : resources/subscribe est remplacé par subscriptions/listen.
  • Plus de ping, et trois fonctionnalités dépréciées : roots, sampling et logging.
  • Le serveur ne fait plus de requêtes de lui-même : quand il a besoin d'une information (par exemple pour une elicitation), il répond input_required et le client relance sa requête avec les réponses (inputResponses). C'est le mécanisme MRTR (Multi Round-Trip Requests).
  • Ce qui ne change pas : les tools, resources et prompts, et les méthodes pour les découvrir et les appeler.
Révision 2026-07-28 : server/discover facultatif, requêtes autonomes avec _meta, et mécanisme MRTR avec input_required puis inputResponses
Schéma — En 2026-07-28, chaque requête est autonome ; quand le serveur a besoin d'une information, il répond input_required (MRTR). (Cliquez sur le schéma pour l'agrandir.)

Je l'ai vérifié sur le serveur Symfony de l'article 4, qui parle déjà cette révision. Un appel d'outil, directement, sans poignée de main :

{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{
  "name":"ajouter_note","arguments":{"texte":"Tester MCP 2026"},
  "_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28",
           "io.modelcontextprotocol/clientCapabilities":{},
           "io.modelcontextprotocol/clientInfo":{"name":"test","version":"1.0.0"}}}}

{"jsonrpc":"2.0","id":3,"result":{"content":[{"type":"text","text":"Note ajoutée (3 au total)."}],
 "isError":false,"resultType":"complete",
 "_meta":{"io.modelcontextprotocol/serverInfo":{"name":"carnet-de-notes","version":"1.0.0"}}}}

Ici, resultType vaut complete (et non input_required) : pas besoin d'aller-retour. Et un ping envoyé dans cette révision est refusé : « Method "ping" does not exist in protocol version 2026-07-28 » (code -32601).

Questions d'entretien : les réponses courtes

Différence entre host et client ?
Le host est l'application (Claude Desktop, un IDE). Le client est un composant du host qui gère une connexion avec un seul serveur. Un host a autant de clients que de serveurs.
Que se passe-t-il à la connexion ?
Jusqu'à la révision 2025-11-25 : initialize (négociation de la version et des capacités), puis la notification notifications/initialized, puis la découverte avec tools/list, etc. Depuis 2026-07-28 : plus de poignée de main, chaque requête porte sa version et ses capacités dans _meta, et server/discover est facultatif.
Requête ou notification ?
Une requête a un id et attend une réponse ; une notification n'a pas d'id et n'attend rien.
stdio ou HTTP ?
stdio pour un serveur local lancé en sous-processus (pas de réseau, logs sur stderr) ; Streamable HTTP pour un serveur distant et partagé, avec authentification.
isError ou erreur JSON-RPC ?
Erreur JSON-RPC quand la requête elle-même est invalide (méthode ou outil inconnu, message mal formé) ; isError: true quand l'outil échoue ou que ses arguments sont invalides (depuis la révision 2025-11-25), pour que le modèle voie l'erreur et se corrige.
Qu'apporte la révision 2026-07-28 ?
Un protocole sans état : plus d'initialize, plus de session HTTP (Mcp-Session-Id), plus de ping ; roots, sampling et logging dépréciés ; les demandes du serveur passent par MRTR (input_required). Les tools, resources et prompts ne changent pas.

Prochaine étape : les tools, resources et prompts en détail, et un premier serveur MCP complet en Node.js. La version Symfony suivra dans le quatrième article.

Continuer la lecture

Article suivant — Outils IA Tools, Resources et Prompts : les primitives MCP et votre premier serveur Explorer tout : Outils IA

Commentaires

Soyez le premier à laisser un commentaire — le robot attend.

Laisser un commentaire

Les champs obligatoires sont indiqués avec *