Blank white background with no objects or features visible.

Bonjour, zone EMEA ! TrueFoundry étend sa présence en Europe, au Moyen-Orient et en Afrique. En savoir plus. →

Qu'est-ce qu'un client MCP ? Comment les agents IA se connectent aux outils

Published: novembre 20, 2026

En résumé
  • Un client MCP est le connecteur de protocole au sein d'une application IA qui ouvre et maintient exactement une connexion vers un serveur MCP, négocie les capacités et achemine chaque requête tools/list et tools/call via JSON-RPC 2.0.
  • L'hôte n'est pas le client. Claude Desktop, Cursor et VS Code sont des hôtes ; chacun instancie un client par serveur auquel il se connecte. L'hôte possède le modèle et l'utilisateur ; le client gère le réseau.
  • Le cycle de vie de la connexion est fixe : découvrir le serveur, s'authentifier (OAuth 2.1 pour les serveurs distants), initialize pour négocier les capacités, lister les outils et les ressources, puis invoquer et gérer les résultats. Sautez une étape et le serveur vous rejettera.
  • L'authentification s'est alignée sur de véritables standards. MCP distant s'appuie désormais sur OAuth 2.1 avec PKCE, les métadonnées de ressources protégées RFC 9728 et l'enregistrement dynamique de clients ; la révision de la spécification du 2026-07-28 a orienté les clients vers Streamable HTTP sans état et les en-têtes d'identité Mcp-Name.
  • À l'échelle de l'entreprise, vous ne pointez plus directement les clients vers les serveurs. Une passerelle fournit à chaque client un point de terminaison unique, un modèle d'authentification unique, une découverte centralisée et un audit, au lieu de N clients détenant chacun N jeux d'identifiants.

Le Model Context Protocol (MCP) est souvent décrit comme le « USB-C pour l'IA », ce qui est accrocheur mais presque inutile lorsqu'il s'agit de raccorder concrètement un agent à une base de données. La métaphore du port masque la partie qui fait le travail : l'élément au bout du câble qui parle le protocole. Dans MCP, cet élément est le client.

Si vous construisez ou exploitez des agents IA, le client est le composant que vous débugguerez à 2 heures du matin lorsqu'un appel d'outil se bloque, lorsqu'un jeton OAuth expire au milieu d'une session ou lorsqu'un serveur annonce un outil que votre hôte ne présente jamais au modèle. Comprendre exactement ce que fait le client, et ce qu'il ne fait pas, fait toute la différence entre traiter MCP comme de la magie ou l'exploiter comme une infrastructure.

Cet article définit le client MCP avec précision : son rôle dans la triade hôte/client/serveur, le cycle de vie de la connexion étape par étape, la façon dont les clients s'authentifient, l'endroit où les clients s'exécutent réellement et pourquoi, à grande échelle, vous devez placer une passerelle entre vos clients et vos serveurs.

Vous souhaitez un point de terminaison unique et gouverné pour chaque client MCP de votre organisation plutôt que des configurations dispersées ? Réservez une démonstration.

La triade hôte / client / serveur

MCP comprend trois rôles, et les confondre constitue la source de confusion la plus fréquente.

Un hôte est l'application IA avec laquelle l'utilisateur interagit. Il possède le modèle linguistique (ou la connexion à celui-ci), la conversation et la décision quant aux outils à exposer au modèle et à quel moment. Claude Desktop est un hôte. Cursor est un hôte. Un agent personnalisé écrit avec un SDK est un hôte.

Un client est un connecteur de protocole instancié par l'hôte. Son unique rôle est de maintenir une connexion avec un serveur et d'assurer la traduction entre le monde interne de l'hôte et le protocole réseau MCP. La relation est de un à un : un client, un serveur. Un hôte qui se connecte à cinq serveurs exécute cinq clients. Chaque client conserve son propre état de session, son propre ensemble de capacités et ses propres identifiants.

Un serveur expose des capacités, des outils (des fonctions que le modèle peut appeler), des ressources (des données lisibles comme des fichiers ou des lignes) et des prompts (des modèles réutilisables), via le protocole. Un serveur MCP GitHub expose des create_issue et des list_pull_requests. Un serveur Postgres expose un outil de requête et des ressources de tables.

The triad: a host such as Claude Desktop, Cursor, or a custom agent contains one or more MCP clients, each holding a dedicated connection to a single MCP server (GitHub, a database, an internal service).
La triade : un hôte tel que Claude Desktop, Cursor ou un agent personnalisé contient un ou plusieurs clients MCP, chacun détenant une connexion dédiée vers un seul serveur MCP (GitHub, une base de données, un service interne).

La séparation est essentielle car les responsabilités ne se chevauchent pas. L'hôte décide de la politique (« le modèle doit-il être autorisé à appeler delete_repo ? »). Le client applique le protocole (« ce serveur est-il initialisé ? la capacité est-elle annoncée ? »). Le serveur exécute le travail et renvoie un résultat. En cas de panne, vous réparez le problème dans la couche concernée. Un outil qui n'apparaît jamais au modèle est généralement un problème d'hôte. Un outil qui apparaît mais génère une erreur lors de l'invocation est généralement un problème de client ou de serveur.

Pourquoi un client par serveur

La règle du un à un n'est pas un hasard. Chaque connexion MCP est une session avec état comportant des capacités négociées. Le serveur A peut prendre en charge les abonnements aux ressources ; le serveur B peut ne pas le faire. Le serveur A s'authentifie avec un jeton OAuth GitHub ; le serveur B utilise un identifiant de base de données. Attribuer à chaque connexion son propre client permet d'isoler cet état, garantissant qu'une capacité ou un jeton expiré sur une connexion ne puisse pas corrompre une autre. L'hôte devient le multiplexeur : il répartit une requête utilisateur unique vers les clients nécessaires, collecte les résultats et les réinjecte dans le modèle.

Ce dont le client est responsable

En faisant abstraction des métaphores, un client MCP conforme accomplit cinq tâches concrètes.

Transport. Il établit et maintient la connexion. MCP définit deux transports standards : stdio, où le client lance le serveur en tant que sous-processus et communique via l'entrée/sortie standard, et Streamable HTTP, où le client effectue des requêtes HTTP vers l'URL d'un serveur et peut recevoir un flux d'événements envoyés par le serveur sur la réponse. Les outils locaux (un serveur de système de fichiers sur votre ordinateur portable) utilisent généralement stdio. Les outils distants (un service hébergé) utilisent HTTP.

Framing des messages. Chaque message MCP est en JSON-RPC 2.0. Le client construit des objets de requête avec un id, une method et des params, associe les réponses à leurs requêtes par id, et achemine les notifications initiées par le serveur. Si vous avez déjà observé le trafic MCP brut, il s'agit simplement d'un flux d'enveloppes JSON-RPC.

Négociation des capacités. Lors de la connexion, le client envoie initialize avec la version du protocole qu'il utilise et les capacités qu'il prend en charge (par exemple, s'il peut gérer les requêtes d'échantillonnage ou d'élicitation). Le serveur répond avec les siennes. À partir de cette poignée de main, les deux parties savent ce qui est autorisé. Un client qui tente d'utiliser une capacité que le serveur n'a jamais annoncée comporte un bug.

Invocation. Lorsque l'hôte décide que le modèle doit appeler un outil, le client envoie tools/call avec le nom de l'outil et ses arguments, attend le résultat et le transmet en retour. Il effectue la même opération pour resources/read et prompts/get.

Cycle de vie et nettoyage. Le client gère la session de la poignée de main jusqu'à la fermeture, incluant le rafraîchissement des jetons, la reconnexion et la fermeture propre de la connexion lorsque l'hôte la termine.

Remarquez ce qui ne figure pas dans cette liste : décider si un appel d'outil est sécurisé, masquer des secrets dans un résultat ou empêcher un agent autonome d'appeler 400 fois le même outil. Ces aspects relèvent de la responsabilité de l'hôte et de la gouvernance. Le protocole de base fournit la tuyauterie, pas la politique. C'est précisément dans cet intervalle que doivent s'insérer les contrôles d'entreprise présentés plus bas.

Le cycle de vie de la connexion, étape par étape

Une connexion client suit une séquence fixe. La comprendre permet de résumer la plupart des défaillances MCP à une question simple : « quelle étape a échoué ? »

The MCP client connection lifecycle: discover the server, authenticate, initialize and list capabilities, invoke tools, handle the result, then shut down cleanly.
Le cycle de vie de la connexion du client MCP : découvrir le serveur, s'authentifier, initialiser et lister les capacités, invoquer les outils, gérer le résultat, puis fermer proprement.

1. Découvrir. Le client a besoin d'un serveur auquel se connecter. Pour un serveur stdio local, la « découverte » consiste en une entrée de configuration : une commande et des arguments à lancer. Pour un serveur distant, il s'agit d'une URL. Dans les déploiements plus vastes, la découverte est dynamique : le client demande à un registre ou à une passerelle quels serveurs existent et quels sont leurs points de terminaison, au lieu de coder chacun d'eux en dur.

2. S'authentifier. Pour les serveurs HTTP distants, le client doit prouver son identité avant que le serveur ne communique avec lui. Le modèle d'autorisation de MCP repose sur OAuth 2.1. Le client découvre le serveur d'autorisation à partir des métadonnées de ressources protégées (RFC 9728), s'enregistre éventuellement de manière dynamique (RFC 7591), exécute le flux d'autorisation par code avec PKCE (RFC 7636) et joint le jeton porteur résultant à chaque requête. Les serveurs stdio locaux héritent généralement de la confiance provenant de la limite du processus et sautent cette étape.

3. Initialiser. Le client envoie la requête initialize : sa version de protocole, ses informations client et ses capacités. Le serveur répond avec sa version de protocole, ses informations serveur et ses capacités. Si les versions sont incompatibles, la connexion échoue ici, proprement, ce qui est bien préférable à un échec trois appels d'outils plus tard. Le client envoie ensuite une notification initialized pour confirmer que la session est active.

4. Lister les capacités. Le client appelle tools/list, ainsi que resources/list et prompts/list si nécessaire. Le serveur renvoie le nom de chaque outil, sa description et le JSON Schema de son entrée. Il s'agit du catalogue que l'hôte présentera au modèle. Les serveurs peuvent également envoyer une notification listChanged ultérieurement si leur jeu d'outils évolue, et un client bien conçu effectue à nouveau un listing en réponse.

5. Invoquer. L'hôte sélectionne un outil (généralement parce que le modèle l'a demandé) et le client envoie tools/call avec des arguments validés. Un appel à exécution longue peut transmettre des sorties intermédiaires en streaming. Le client associe la réponse à la requête par id.

6. Gérer le résultat. Le client renvoie le résultat de l'outil à l'hôte, qui le formate pour le modèle. Les résultats MCP comportent un indicateur distinguant une erreur au niveau de l'outil (l'outil s'est exécuté et a échoué, par exemple « dépôt non trouvé ») d'une erreur au niveau du protocole (l'appel lui-même était mal formé). Traiter ces deux cas de manière identique constitue un bug client fréquent : un « non trouvé » est une information destinée au modèle, tandis qu'une erreur de protocole est un élément que votre code doit gérer.

7. Fermer. Lorsque l'hôte a terminé, le client ferme le transport : fermeture du sous-processus pour stdio, ou fin de la session HTTP pour le mode distant.

Un flux minimal, de manière concrète

Imaginez un agent de codage auquel on demande d'« ouvrir un ticket intitulé 'Flaky CI' dans le dépôt api ». La séquence au sein de l'hôte est la suivante :

  1. Le client détient déjà une session initialisée vers le serveur MCP GitHub, avec un jeton OAuth valide.
  2. L'hôte dispose du catalogue d'outils issu de tools/list ; il inclut create_issue avec un schéma exigeant owner, repo et title.
  3. Le modèle émet un appel d'outil : create_issue({owner: "acme", repo: "api", title: "Flaky CI"}).
  4. Le client envoie tools/call, le serveur crée le ticket et renvoie {issue_number: 412, url: "..."} comme résultat sans erreur.
  5. Le client transmet ce résultat ; l'hôte le fournit au modèle, qui répond : « Ticket #412 ouvert. »

Chacune de ces étapes est un point où un problème peut survenir : un jeton expiré (étape 1), une incohérence de schéma mal devinée par le modèle (étape 3), un échec de permission côté serveur qui renvoie une erreur d'outil (étape 4). Connaître le cycle de vie vous indique où chercher.

Comment les clients MCP s'authentifient

Les premières connexions MCP étaient principalement constituées de serveurs stdio locaux, pour lesquels l'authentification était implicite. Les serveurs distants ont changé la donne, et le protocole s'est standardisé sur OAuth 2.1 plutôt que d'inventer un nouveau mécanisme.

Concrètement, un client distant :

  • Lit les métadonnées de ressources protégées (RFC 9728) à partir du serveur pour savoir quel serveur d'autorisation le protège.
  • Effectue éventuellement un enregistrement dynamique de client (RFC 7591) afin de ne pas avoir besoin d'un identifiant client pré-configuré pour chaque serveur qu'il pourrait rencontrer.
  • Exécute l'octroi de code d'autorisation avec PKCE (RFC 7636), ce qui protège l'échange même pour les clients publics incapables de conserver un secret.
  • Joint le jeton porteur délivré à chaque requête et le rafraîchit avant son expiration.

La révision de la spécification du 2026-07-28 a poursuivi une orientation claire : vers un transport Streamable HTTP sans état, où un serveur n'a pas besoin d'associer une session à longue durée de vie à un processus unique, et vers une identité de serveur explicite via des en-têtes Mcp-Name afin que les clients et les intermédiaires puissent nommer et router vers un serveur spécifique sans ambiguïté. Le transport sans état est essentiel sur le plan opérationnel car il permet aux serveurs d'évoluer horizontalement derrière un répartiteur de charge. Si vous souhaitez une analyse plus approfondie des flux de jetons, du ciblage d'audience et des modes de défaillance, consultez notre guide sur l'authentification MCP.

La leçon pratique : un client n'est aussi sécurisé que la gestion de ses jetons. Un client qui enregistre des jetons porteurs dans des logs, qui ne valide pas l'audience des jetons ou qui ne se rafraîchit pas proprement divulguera des identifiants ou interrompra des sessions. Ces responsabilités incombent au client et sont difficiles à maîtriser de manière isolée, une raison de plus pour laquelle une gestion centralisée s'impose à grande échelle.

Où résident les clients MCP : exemples réels

Le terme « client MCP » peut sembler abstrait jusqu'à ce que vous réalisiez que vous en avez probablement utilisé plusieurs. Voici les exemples courants et la définition précise de chacun d'eux.

Client / hôteCe que c'estOù le client s'exécuteTransport typique
Claude DesktopHôte desktop se connectant à des serveurs MCP locaux et distantsAu sein de l'application desktopstdio (local), Streamable HTTP (distant)
CursorÉditeur de code IA ; se connecte aux serveurs MCP pour les dépôts, la doc et les outilsAu sein de l'éditeurstdio et HTTP
VS Code (avec support MCP)Hôte éditeur ; le mode agent consomme des outils MCPAu sein de l'éditeur / hôte d'extensionstdio et HTTP
ClineExtension d'agent de codage open source agissant comme hôte MCPDans l'hôte d'extension VS Codestdio et HTTP
Agent SDK personnaliséVotre propre application utilisant une bibliothèque client MCPLà où vous le déployezVotre choix

La nuance importante dans ce tableau : dans chaque cas, le client est un composant de niveau bibliothèque au sein du produit. Claude Desktop est l'hôte ; l'élément qui communique réellement en JSON-RPC avec le serveur GitHub est un objet client créé par l'hôte. Lorsque vous écrivez un agent personnalisé avec un SDK MCP, vous instanciez vous-même cet objet client, en appelant directement connect(), list_tools() et call_tool().

Cela explique également pourquoi un même serveur peut se comporter légèrement différemment selon l'hôte. Le serveur est identique ; les clients diffèrent dans leur façon de relister les outils, de présenter les erreurs d'outils au modèle et de gérer l'authentification. L'affirmation « Cela fonctionne dans Claude Desktop mais pas dans mon agent » découle presque toujours d'une différence de comportement du client, et non du serveur.

The TrueFoundry MCP Gateway architecture. Source: TrueFoundry docs.
L'architecture TrueFoundry MCP Gateway. Source : documentation TrueFoundry.

Découvrez comment TrueFoundry centralise l'authentification, la découverte et l'audit pour chaque agent et client MCP. Réservez une démonstration.

Pourquoi une passerelle s'interpose entre clients et serveurs à grande échelle

Pointez un client vers un serveur et MCP reste simple. Passez maintenant à l'échelle réelle : 200 développeurs, 30 serveurs MCP internes, chaque hôte tentant de conserver ses propres jetons OAuth, chaque serveur accessible à sa propre URL, et une équipe de sécurité souhaitant savoir qui a appelé quel outil.

Le modèle de connexion directe se dégrade rapidement :

  • Dispersion des identifiants. Chaque client détient des identifiants pour chaque serveur. Renouveler un secret nécessite de modifier la configuration de chaque client.
  • Absence de découverte centralisée. Chaque hôte code les URL de serveur en dur. Ajouter ou déplacer un serveur impose de réintégrer chaque client.
  • Absence de gouvernance. Le protocole de base ne comporte pas de notion comme « l'équipe X peut utiliser le serveur de base de données mais pas le serveur de paiement », pas de limite de débit partagée, ni d'historique d'audit à travers les serveurs.
  • Authentification incohérente. Chaque client implémente OAuth légèrement différemment ; certains le font de manière incorrecte.

La solution repose sur le même schéma qui a résolu le problème équivalent pour les API d'LLM : placer une passerelle au milieu. Une passerelle MCP fournit à chaque client un point de terminaison unique. Le client s'authentifie une fois auprès de la passerelle ; la passerelle détient et renouvelle les identifiants pour les serveurs en aval. La découverte devient dynamique : le client demande au registre MCP de la passerelle ce qui existe, au lieu de maintenir une liste statique. Et comme chaque appel transite par un lieu unique, vous obtenez la gouvernance, le contrôle d'accès, les limites de débit et l'audit que le protocole lui-même ne fournit pas.

Sur le plan architectural, cela reflète un proxy LLM : une porte d'entrée logique unique, plusieurs backends derrière, et l'application des politiques au milieu. Le travail du client devient plus simple, et non plus complexe : il se connecte à un point de terminaison unique et connu avec un seul identifiant et laisse la passerelle gérer la distribution.

Pour les environnements réglementés, où les outils appellent des systèmes internes hébergeant des données sensibles, cela est indispensable. Vous avez besoin d'une gouvernance MCP d'entreprise : un contrôle d'accès par équipe déterminant quels serveurs et outils sont accessibles, un audit complet de chaque invocation d'outil, et la possibilité de révoquer les accès de manière centralisée. La passerelle et le registre MCP de TrueFoundry offrent exactement cela : les clients disposent d'un point de terminaison unique, l'authentification et le RBAC sont appliqués de manière centralisée, chaque appel d'outil est observable et étiqueté, et la découverte des serveurs s'effectue via un registre gouverné plutôt qu'à travers des fichiers de configuration dispersés. Si vous évaluez les options disponibles, notre synthèse des meilleures passerelles MCP détaille les compromis, tandis que la section hébergement de serveur MCP traite de l'exécution des serveurs eux-mêmes.

Les erreurs fréquemment commises par les équipes

Traiter l'hôte comme le client. Les équipes disent parfois : « Cursor est mon client MCP. » Cursor est l'hôte ; il contient des clients. La distinction devient essentielle au moment du débogage : un outil qui n'atteint jamais le modèle découle d'une décision d'exposition côté hôte, tandis qu'un outil qui génère une erreur lors d'un appel relève d'un problème de client ou de serveur. Confondre les deux vous oriente vers la mauvaise couche.

Ignorer la poignée de maininitialize. Les développeurs qui écrivent des clients personnalisés déclenchent parfois un tools/call avant que la négociation des capacités ne soit terminée, ou supposent une capacité que le serveur n'a jamais annoncée. Cela entraîne des échecs intermittents et confus. La poignée de main n'est pas une formalité ; elle constitue le contrat. Respectez-la sous peine de constater des comportements instables.

Confondre erreurs d'outils et erreurs de protocole. Un résultat MCP indique si l'outil lui-même a échoué (un code 404 que le modèle doit analyser) ou si l'appel était mal formé (un problème dans votre code). Les clients qui confondent ces deux cas masquent des signaux utiles au modèle ou plantent sur des conditions récupérables.

Coder en dur les URL de serveurs et les identifiants dans chaque client. Cela fonctionne pour trois serveurs, puis s'effondre à trente. Une configuration statique implique que chaque renouvellement et chaque déplacement devienne une modification à l'échelle de toute la flotte. La découverte dynamique via un registre est la seule approche évolutive.

Laisser chaque client gérer son propre OAuth. OAuth 2.1 avec PKCE et rafraîchissement de jeton est facile à implémenter de manière incorrecte (fuite de jetons dans les logs, absence de validation d'audience, rafraîchissement manqué). Centraliser l'authentification au niveau d'une passerelle permet de l'implémenter une seule fois, correctement, au lieu de N fois avec N bugs.

Conclusion

Le client MCP est le composant essentiel qui permet l'utilisation d'outils par les agents : il maintient la connexion, négocie les capacités, s'authentifie et achemine chaque appel d'outil via JSON-RPC. En adoptant le bon modèle mental (l'hôte possède la politique, le client gère le réseau, le serveur exécute le travail), MCP cesse d'être une boîte noire et devient un composant d'infrastructure maîtrisable et débuggable.

Avec un client et un serveur, le modèle direct convient parfaitement. À l'échelle de l'entreprise, avec des dizaines de serveurs et des centaines d'utilisateurs, vous ne pointez plus directement les clients vers les serveurs et vous placez une passerelle au milieu : un point de terminaison unique, une authentification et une découverte centralisées, ainsi qu'une gouvernance sur chaque appel d'outil. C'est l'architecture qui permet de conserver une flotte d'agents en expansion à la fois utile et sous contrôle.

Offrez à chaque client MCP une passerelle unique et sécurisée pour ses connexions. Réservez une démonstration.

Try now.

One gateway for all your models, MCP servers, and agents. No credit card needed.

INSCRIVEZ-VOUS
Table des matières

Gouvernez, déployez et suivez l'IA dans votre propre infrastructure

Réservez un séjour de 30 minutes avec notre Expert en IA

Réservez une démo

Le moyen le plus rapide de créer, de gérer et de faire évoluer votre IA

Démo du livre
Summarize with
ChatGPT logo by OpenAI
Perplexity AI logo
Blurry red snowflake on white background, symmetrical frosty design with soft edges and abstract shape.

Découvrez-en plus

Aucun article n'a été trouvé.
novembre 20, 2026
|
5 min de lecture

Grok 4.3 on Amazon Bedrock: We Routed Four Frontier Models Through One Gateway and Measured the Cost

Outils LLM
comparaison
novembre 20, 2026
|
5 min de lecture

Alternatives au bifrost : les meilleurs outils que vous pouvez envisager en 2026

Aucun article n'a été trouvé.
novembre 20, 2026
|
5 min de lecture

GPT-6.1 Terra : API, benchmarks, tarification et mode d'emploi

Aucun article n'a été trouvé.
novembre 20, 2026
|
5 min de lecture

GPT-5.1 vs GPT-5 : 9 améliorations majeures à connaître

LLM et GenAI
Aucun article n'a été trouvé.

Blogs récents

Black left pointing arrow symbol on white background, directional indicator.
Black left pointing arrow symbol on white background, directional indicator.
Faites un rapide tour d'horizon des produits
Commencer la visite guidée du produit
Visite guidée du produit