Qu’est-ce que MCP ? Guide 2026 : Model Context Protocol, JSON-RPC, agents IA et appels d’outils

Ce qu’est MCP : pas un modèle — un protocole d’outils

La définition minimale tient en trois parties : un Host (éditeur ou processus agent), un Client (côté du Host qui parle aux serveurs), un Server (processus ou endpoint HTTPS qui expose outils, ressources et prompts). Le Client demande le catalogue, injecte name, description et inputSchema dans le contexte, puis envoie tools/call quand le modèle décide. MCP gouverne la découverte et la forme d’appel. Pas la pensée du modèle.

Dire « plugin IA » n’est vrai qu’à moitié. Un plugin navigateur tient à un hôte ; un Server MCP peut être réutilisé par plusieurs Clients — la même recherche de factures sert Cursor, Claude Desktop ou votre orchestrateur. L’écart n’est pas « peut-on appeler une fonction », c’est la standardisation du catalogue et de l’enveloppe. Un adaptateur OpenAPI maison appelle déjà HTTP ; un second Client impose de le réécrire. MCP plie cette couche en protocole. Concepts et spécification officiels :documentation Model Context Protocol.

Sur la ligne de temps : Anthropic a open-sourcé MCP en 2024 ; fin 2025 le protocole est passé sous l’Agentic AI Foundation (AAIF) de la Linux Foundation. En 2026, les Hosts le traitent comme canal d’outils distant par défaut, pas comme démo. Une version de protocole apparaît dans _meta — 2026-07-28 veut dire « les deux côtés s’accordent sur cette sémantique », pas « le modèle a gagné en intelligence ». L’écart avec un chatbot ou un workflow cron est dansQu’est-ce qu’un AI Agent : sans boucle ni forme d’arguments vérifiable, ce n’est que du chat ; une boucle sur des fonctions locales peut encore être un agent — simplement sans catalogue distant standard.

JSON-RPC 2.0 : pourquoi cette enveloppe

MCP n’a pas inventé un nouveau RPC. Chaque action de protocole tient dans une enveloppe JSON-RPC 2.0 : jsonrpc, id, method, params, ou error. Requête et réponse partagent un id ; les notifications peuvent l’omettre. Pour passerelles et journaux, c’est plus simple à découper qu’une trame de flux maison : method d’abord, métier ensuite. Les champs sont dans laspécification JSON-RPC 2.0.

method est un verbe de protocole, pas le nom de votre fonction métier. tools/list liste ; tools/call invoque ; resources/read lit. Le nom métier vit dans params.name ; les arguments dans params.arguments. Écrire searchInvoices comme method est une lecture fausse courante — c’est votre service JSON-RPC, pas MCP. Une requête de catalogue standard ressemble à ceci :

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {}
}

L’enveloppe règle trois points : multiplexage (plusieurs id en vol), erreurs classables (parse, méthode inconnue, refus métier), transport interchangeable (stdio ou Streamable HTTP portent le même JSON). Elle ne décide pas si les arguments sont justes. Une enveloppe JSON-RPC légale peut encore livrer un arguments incomplet au Server. Le Server parse et valide contre inputSchema lui-même.

Comment un agent IA utilise MCP : découvrir → choisir → appeler

Ôtez la vidéo démo : une boucle d’agent branchée sur MCP a encore cinq pas. Ce qui change, c’est que les pas 2 et 4 ne sont plus collés aux fonctions locales :

1. L’objectif utilisateur entre dans le contexte (langage naturel + contraintes système optionnelles).
2. Le Client envoie tools/list à chaque Server MCP connecté et convertit le catalogue en tools / functions lisibles par le modèle.
3. Le modèle renvoie des tool_calls (fonction + arguments) ou un texte / Structured Output final.
4. Le runtime parse les arguments, envoie MCP tools/call et réécrit le result dans les messages.
5. Le modèle relit le résultat et choisit l’outil suivant ou s’arrête. maxSteps, annulation ou échec Schema arrêtent aussi.

La requête MCP du pas 4 ressemble à ceci. params.arguments est déjà un objet, pas une chaîne. Une version de protocole peut tenir dans _meta pour le routage sans état :

{
  "jsonrpc": "2.0",
  "id": 42,
  "method": "tools/call",
  "params": {
    "name": "searchInvoices",
    "arguments": {
      "startDate": "2026-01-01",
      "endDate": "2026-01-31",
      "status": "paid"
    },
    "_meta": {
      "io.modelcontextprotocol/protocolVersion": "2026-07-28"
    }
  }
}

Un agent ne dépend pas de MCP. Fonctions locales, OpenAPI et votre HTTP suffisent comme outils. La valeur de MCP : un Server découvert par plusieurs Hosts, même catalogue et même forme d’appel à distance. Le critère d’adoption est « un second Client réutilisera-t-il cet ensemble », pas « cela a-t-il l’air 2026 ». La définition d’ingénierie de la boucle est dansle fonctionnement d’un AI Agent.

Appels d’outils du modèle : tool_calls vs tools/call

Côté ingénierie, tool calling et function calling sont un même mécanisme : le modèle ne touche pas la base ; il émet une demande structurée « appelez cette fonction avec ces arguments ». MCP est le hop suivant : le runtime traduit en JSON-RPC tools/call. Les noms de champs des deux hops se mélangent sans cesse :

Quand le modèle appelle, un tool_calls typique ressemble à ceci. arguments est encore une chaîne. Le runtime parse d’abord, puis place l’objet dans params.arguments MCP. Ne jetez pas la chaîne brute dans JSON-RPC — elle devient « un champ chaîne nommé arguments » et la validation Schema du Server échoue tout de suite.

{
  "id": "call_8f3a",
  "type": "function",
  "function": {
    "name": "searchInvoices",
    "arguments": "{\"startDate\":\"2026-01-01\",\"endDate\":\"2026-01-31\",\"status\":\"paid\"}"
  }
}

Les coquilles vendeur diffèrent : OpenAI tools[].function.parameters, Anthropic input_schema, Gemini function_declarations. MCP : Tool.inputSchema. Les noms changent ; le Schema canonique doit rester un fichier. L’alignement des champs et pourquoi strict exige chaque property dans required :MCP et JSON Schema. La réponse finale passe par Structured Output — ne partagez pas ce fichier avec les entrées d’outil.

Carte 2026 : local, distant, sans état, A2A

Deux transports principaux. Stdio local : le Host lance un processus fils, JSON-RPC circule sur stdin/stdout — fichier ou base locale. Streamable HTTP distant : le Client POSTE la même enveloppe vers un endpoint HTTPS — factures, tickets, APIs internes partagés. Le distant n’est plus « poignée de main puis Session ID ». Vers 2026-07-28, les requêtes se veulent auto-descriptives pour qu’une passerelle limite par method.

Sans état désigne la couche protocole : n’importe quelle instance prend n’importe quelle requête. L’application a toujours une base, des clés d’idempotence, une identité. Lire « protocole sans état » comme « plus besoin de valider les outils » est à l’envers — sans cache de session, n’assumez pas que le tools/list du tour précédent vit encore. Un catalogue périmé écrit la mauvaise forme dans tools/call. Détails :MCP sans état et JSON-RPC.

MCP n’est pas non plus un protocole multi-agents. Un planificateur qui délègue à des agents prix, conformité, logistique passe par A2A message/send, pas tools/call. Chaque spécialiste peut encore user de MCP pour sa base. La « guerre des protocoles » est souvent le mauvais cadre : une couche face aux outils, l’autre face aux agents. ComparerA2A vs MCP. Spec et implémentations :MCP GitHub — croyez le dépôt de spec pour les versions, pas le blog d’un seul Host.

Validation terrain et JSONVue

Chaque hop : parse → Schema → règles métier. Une enveloppe MCP légale ne rend pas les arguments légaux. Un modèle habile ne remplace pas ces trois pas.

1. Chaîne arguments du modèle : JSON.parse ; en échec, journaliser raw + id et renvoyer une enveloppe retryable — pas encore l’aval.
2. Valider contre inputSchema / parameters (Draft 2020-12) ; émettre path et keyword.
3. Porte métier : plage de dates, enum vs droits, clés étrangères. Puis seulement le Server frappe l’API aval.

Alignez trois blobs : arguments modèle, params.arguments envoyés à MCP, objet réellement utilisé. Un écart est presque toujours l’adaptateur. Dans le navigateur :formateur JSON pour le parse ;Validateur JSON Schema pour arguments vs fichier Schema ;JSON Diff pour arguments vs body MCP / HTTP. Partagez les fixtures valid / missing-field / wrong-enum en CI et au debug manuel.

À lire : Qu’est-ce qu’un AI Agent, MCP et JSON Schema, MCP sans état, A2A vs MCP.

FAQ

Synthèse et suite

MCP en 2026 : découvrir et appeler des outils en JSON-RPC, réécrire les résultats dans le contexte du modèle. Ce n’est ni un modèle, ni un agent, ni A2A. Le tool calling gouverne le choix de fonction ; MCP gouverne la découverte et l’appel distant ; JSON Schema gouverne la forme de chaque hop.

Ensuite : listez les trois JSON (arguments modèle, params.arguments MCP, body aval) et vérifiez qu’ils partagent un Schema ; rejouez valid / champ manquant / mauvais enum dans JSONVue. Protocole dans l’article MCP sans état ; alignement dans l’article Schema ; multi-agents dans A2A.