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

| Rôle | Exemples | Sa responsabilité |
|---|---|---|
| Host | Claude Desktop, Claude Code, un IDE, votre propre application | L'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. |
| Client | Un composant à l'intérieur du host | Gère une connexion vers un serveur (relation un à un) : ouverture, négociation, envoi des requêtes, réception des réponses. |
| Serveur | Serveur 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, unemethodet desparams. Elle attend une réponse. - La réponse : elle reprend le même
id, et contient soit unresult, soit uneerror. - 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 :

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.

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 | Streamable HTTP | |
|---|---|---|
| Principe | Le 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'usage | Outils 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
errorJSON-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
resultnormal 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 :
initializeetnotifications/initializeddisparaissent. 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 appelerserver/discover, sans y être obligé. - Plus de session en HTTP : l'en-tête
Mcp-Session-Idest 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/subscribeest remplacé parsubscriptions/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_requiredet 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.

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 notificationnotifications/initialized, puis la découverte avectools/list, etc. Depuis 2026-07-28 : plus de poignée de main, chaque requête porte sa version et ses capacités dans_meta, etserver/discoverest facultatif. - Requête ou notification ?
- Une requête a un
idet attend une réponse ; une notification n'a pas d'idet 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: truequand 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 deping; 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.




Commentaires