MCP (Model Context Protocol) est une norme commune pour connecter les applications d'IA à des outils et à des données externes. Une fois qu'un outil est configuré comme serveur MCP, il fonctionne de la même manière depuis n'importe quelle application compatible avec MCP. Au chapitre précédent, nous avons fait fonctionner un agent minimal qui relie des outils à un LLM et exécute sa propre boucle. Dans ce chapitre, vous apprendrez à ne plus devoir créer chaque outil à la main, à le connecter de façon standard avec MCP, et à concevoir les outils que vous confiez afin qu'ils soient utilisés en toute sécurité.

Ce que vous allez acquérir dans ce chapitre

L'objectif : connecter les outils en toute sécurité grâce à une norme, sans les créer soi-même

Comprendre le fonctionnement de MCP
Comprenez la relation entre clients et serveurs, ainsi que l'idée d'une norme commune où il suffit de brancher pour que ça fonctionne.
Tirer parti des serveurs existants
Maîtrisez les bons réflexes pour choisir et connecter des serveurs MCP prêts à l'emploi pour les fichiers, les bases de données, la recherche, les SaaS, etc.
Confier des outils en toute sécurité
Acquérez les principes pour confier des outils : le moindre privilège, la rédaction des descriptions et la gestion des outils dangereux.

Pourquoi la connexion aux outils est au cœur des agents

Un LLM, aussi performant soit-il, ne peut que produire du texte. Il ne peut ni connaître le stock actuel ni écrire une ligne dans un fichier sans moyen d'interagir avec le monde extérieur. Un agent peut faire tourner la boucle « se renseigner, agir, vérifier » parce qu'il dispose d'outils lui permettant d'agir sur l'extérieur.

En d'autres termes, ce qu'un agent peut faire dépend des outils auxquels il est connecté et des permissions dont il dispose sur ceux-ci. Deux agents reposant sur le même LLM peuvent être très différents : l'un qui ne dispose que d'une calculatrice, l'autre connecté à une base de données, à un moteur de recherche, à des fichiers et à une API interne. Selon l'objectif, connecter les bons outils peut élargir bien davantage le champ des tâches confiables que de passer à un modèle plus haut de gamme.

💡 « Bien équipé » vaut mieux que « intelligent ». Même une personne brillante ne peut rien faire avec une boîte à outils vide. Une grande partie du développement d'agents consiste à concevoir quels outils donner, et comment les confier en toute sécurité. Ce chapitre en constitue le cœur.

Les limites des définitions d'outils classiques

Au chapitre précédent, vous avez défini vous-même les outils. Vous avez écrit une fonction, transmis au LLM son nom, ses arguments et sa description, puis, lorsqu'un appel arrivait, vous l'avez exécutée et renvoyé le résultat. Ce déroulement est juste et reste la base aujourd'hui. Pour un petit traitement utilisé dans une seule application, cette méthode suffit. Le problème apparaît lorsqu'il faut recréer le même outil pour chaque outil et chaque projet.

Prenons l'exemple d'un « outil de recherche dans une base de données ». Il faut écrire la logique de connexion, construire les requêtes, mettre en forme les résultats, gérer les erreurs et manipuler les identifiants de façon sécurisée… Votre projet, l'équipe d'à côté ou quelqu'un qui travaille dans un autre langage implémentent chacun cet ensemble de leur côté. Des développeurs du monde entier recréent sans cesse le même outil : c'est la réalité des définitions d'outils classiques.

🔁 Difficile à réutiliser

Un outil écrit pour un projet est lié à son framework et à son langage, ce qui le rend difficile à transposer ailleurs.

🧱 L'enfer des combinaisons N×M

Relier M types d'outils à N plateformes d'agents exige, en théorie, N×M codes de connexion.

🔧 La maintenance se disperse

À chaque modification des spécifications du service connecté, il faut corriger un à un les outils maison disséminés un peu partout.

C'est un peu comme à l'époque où chaque périphérique nécessitait son propre câble. Les imprimantes avaient leur prise, les souris la leur : plus il y avait d'appareils, plus les types de connexion se multipliaient. Un « port commun » permet de réduire ce problème d'un seul coup. C'est là qu'intervient MCP.

Qu'est-ce que MCP ? Une norme commune pour la connexion aux outils

MCP (Model Context Protocol) est une norme ouverte qui permet de connecter l'IA à des outils et à des données externes de manière standardisée. Anthropic l'a publié en open source en novembre 2024, et d'autres entreprises ont ensuite intégré la prise en charge dans leurs produits, notamment ChatGPT, Cursor, Gemini, Microsoft Copilot et Visual Studio Code. En décembre 2025, il a été confié à l'Agentic AI Foundation (AAIF), placée sous la tutelle de la Linux Foundation, de sorte que la spécification est désormais développée sans dépendre d'une seule entreprise.

En une phrase, l'idée de MCP est « l'USB des connexions d'outils d'IA ». Tout comme l'USB a permis d'utiliser les périphériques de n'importe quel fabricant avec la même prise, un outil compatible MCP fonctionne avec n'importe quelle application compatible MCP, il suffit de le brancher. Lorsque les créateurs et les utilisateurs suivent la même convention, les combinaisons N×M se réduisent à N+M.

🧑‍💻 Client MCP
L'agent (le côté qui utilise les outils)

Il fonctionne dans l'agent que vous créez ou dans une application comme Claude. C'est le côté qui interroge le serveur pour savoir quels outils il peut utiliser, puis appelle ceux dont il a besoin.

🔌 Serveur MCP
Le côté qui fournit les outils

Il expose des fonctions telles que les opérations sur fichiers, la recherche en base de données ou l'intégration SaaS sous forme d'« outils ». Un seul serveur peut proposer plusieurs outils.

Les deux parties échangent selon une procédure établie. Le client reçoit d'abord du serveur la liste des outils disponibles, avec le nom, la description et le format des arguments de chacun. Le LLM examine cette liste et choisit l'outil adapté, le client l'appelle, puis le serveur l'exécute et renvoie le résultat. Dans la spécification officielle des outils, la récupération de la liste s'appelle tools/list et l'appel d'un outil tools/call. C'est cet aller-retour qui fonctionne sans implémentation individuelle pour chaque outil, et c'est le cœur de MCP.

Échanges MCP de base (schéma)
Client → Serveur : « Indique-moi les outils disponibles » (tools/list)
Serveur     → Client : « search_docs / read_file / query_db : ces trois outils, voici leurs descriptions »
Le LLM décide  : « Je vais appeler query_db avec les arguments {sql:"..."} »
Client → Serveur : « Exécute query_db » (tools/call)
Serveur     → Client : « Le résultat est ces lignes de données »

Le contenu de la liste n'est pas figé. Selon la spécification, un serveur peut restreindre les outils renvoyés en fonction des permissions de l'utilisateur, et la liste peut changer par la suite. Retenez bien que « la connexion fonctionne » et « les outils dont vous avez besoin sont utilisables » sont deux choses différentes.

La spécification officielle définit deux modes de communication (transports) standard. Les messages échangés sont identiques dans les deux cas, et la façon dont le client les traite change très peu.

stdio (lancé en local)

Le client lance le serveur comme processus enfant et communique par l'entrée et la sortie standard. Ce mode convient pour se connecter à vos propres fichiers ou à une base de données de développement. Les identifiants sont transmis par l'environnement d'exécution, par exemple via des variables d'environnement.

Streamable HTTP (se connecte à une URL)

Il envoie les requêtes en HTTP à l'URL du serveur. Ce mode convient aux intégrations SaaS partagées au sein d'une équipe. Lorsqu'une authentification est nécessaire, utilisez l'autorisation basée sur OAuth définie par la spécification.

📖 Attention à la version de la spécification. Les versions de la spécification MCP sont désignées par une date, et la version actuelle est la 2026-07-28 en octobre 2026. À partir de cette version, la version est indiquée à chaque requête, ce qui diffère de la procédure des versions antérieures à 2025-11-25, où le client et le serveur convenaient de la version lors de la connexion, via initialize. Ne suivez donc pas aveuglément les anciennes procédures : vérifiez les versions prises en charge par votre SDK, votre application et votre serveur. Si vous souhaitez d'abord lire les origines et la terminologie expliquées simplement, l'article explicatif « Qu'est-ce que MCP ? » vous aidera à suivre ce chapitre.

Utiliser et créer des serveurs MCP

Le meilleur atout de MCP est que vous pouvez utiliser tel quel un serveur déjà publié. Pour les outils courants, le fournisseur du service propose souvent un serveur MCP officiel, que vous pouvez trouver dans le MCP Registry officiel. En le connectant à votre agent, ses capacités augmentent immédiatement, sans rien recréer.

📁 Fichiers / local

Lecture et écriture dans un dossier donné. C'est la base pour faire lire des documents à un agent ou lui faire produire des livrables.

🗄 Bases de données

Exécution de SQL et consultation des schémas. Lorsqu'on lui demande des totaux, il interroge les données réelles et répond.

🔎 Recherche / récupération

Recherche sur le Web et dans la base de connaissances interne. C'est la « main qui enquête », qui va chercher des informations récentes et des sources.

☁ Intégrations SaaS

Gestion de tickets, messagerie, stockage, etc. Vos outils métier existants peuvent devenir les mains de l'agent.

La procédure de connexion elle-même est simple : enregistrez la commande de lancement (stdio) ou l'URL (HTTP) du serveur dans les paramètres de votre client, puis effectuez l'authentification si nécessaire. Ensuite, l'agent reçoit la liste des outils et les appelle selon les besoins. Vous n'avez pas à écrire vous-même le fonctionnement interne d'un « outil de recherche en base de données ». Votre travail consiste à combiner les outils fournis selon votre objectif.

Avant de vous connecter, vérifiez toutefois le fournisseur, l'état de la maintenance, les permissions requises et le code qui sera lancé. Par exemple, les serveurs Filesystem, Git et Fetch du dépôt officiel servers sont des implémentations de référence pédagogiques, qui montrent comment fonctionnent la spécification et le SDK. Le dépôt précise lui-même qu'il ne s'agit pas de produits finis destinés à la production. Figurer dans le Registry n'est pas non plus une garantie de sécurité.

⚠️ « Tout connecter parce que c'est pratique » est à proscrire. Chaque serveur ajouté augmente le nombre de descriptions d'outils transmises au LLM, ce qui disperse ses décisions et élargit les possibilités d'erreur. La règle de base est de ne connecter que les outils dont l'objectif de l'agent a réellement besoin.

Vous pouvez aussi créer votre propre serveur

Pour les outils qui n'ont pas de serveur prêt à l'emploi, comme une API interne spécifique ou une logique métier particulière, vous pouvez écrire votre propre serveur MCP. C'est là toute la force de MCP : une fois publié comme serveur, il peut être utilisé de la même façon par n'importe quel agent compatible. Un outil créé pour un projet peut être réutilisé dans le suivant, ou par un autre agent de votre équipe, sans être réécrit.

Créer un serveur revient à définir les fonctions que vous voulez proposer comme outils, à déclarer leur nom, leurs arguments et leur description, puis, lorsqu'elles sont appelées, à exécuter le traitement et renvoyer le résultat. L'idée est la même que celle des définitions d'outils classiques du chapitre précédent, mais la différence décisive est que la sortie va vers une « prise commune » MCP plutôt que vers un « agent spécifique ». Notez que seule la convention de connexion est standardisée : la validation des entrées, la vérification des permissions et le suivi des évolutions de la spécification du service connecté restent, comme auparavant, à la charge de celui qui construit le serveur.

🛠 Si vous voulez entrer dans l'implémentation. Pour du code concret permettant de construire des agents et des connexions d'outils avec Claude, l'initiation au Claude Agent SDK est très pratique. Le SDK intègre un mécanisme de gestion des serveurs MCP : vous pouvez connecter des serveurs existants comme en créer de nouveaux, en suivant la documentation officielle.

L'ordre à suivre quand « ça ne marche pas »

  1. La connexion n'aboutit pas : pour stdio, vérifiez la commande de lancement et l'environnement d'exécution ; pour HTTP, vérifiez l'URL et les conditions de communication. Lisez aussi les messages d'erreur relatifs à la version prise en charge ou à l'authentification.
  2. L'outil nécessaire n'apparaît pas dans la liste : vérifiez si le serveur fournit cet outil, s'il apparaît avec les permissions de votre utilisateur et si l'application ne le restreint pas.
  3. L'appel est effectué mais échoue : vérifiez les arguments, les données cibles, les permissions d'exécution et l'erreur renvoyée. N'élargissez pas les permissions et ne répétez pas la même opération jusqu'à ce que ça fonctionne.

Quels outils donner, et comment

Une fois que l'on sait « connecter » des outils, la question suivante est « quoi donner, et comment ? ». C'est un point de conception clé, qui détermine la qualité et la sécurité de l'agent, et qui pose les bases des chapitres suivants. Retenez trois principes.

① Limitez les permissions au minimum

Ne donnez que les outils et le périmètre nécessaires à la tâche. Si la lecture suffit, n'accordez pas de droit d'écriture. Les bases : un compte en lecture seule et restreint pour une base de données, et uniquement le dossier concerné pour les fichiers.

② Rédigez des descriptions précises

Le LLM décide d'utiliser ou non un outil en se fondant sur son nom, sa description et la définition de ses arguments. Décrivez précisément ce qu'il fait, quand l'utiliser, le sens des arguments et les situations où il ne faut pas s'en servir. Une description vague entraîne des usages inappropriés.

③ Traitez à part les outils dangereux

Les opérations irréversibles (écriture, suppression, facturation, exécution de commandes) ne doivent pas être placées sur le même plan que les outils de lecture. Ajoutez systématiquement une confirmation avant exécution, des limites sur les cibles et une journalisation.

② comporte un piège : écrire « ne met pas à jour » dans une description ne réduit pas les permissions réelles. La description est une consigne pour le LLM, alors que les restrictions doivent être mises en œuvre dans l'implémentation. La spécification officielle exige que les serveurs valident les entrées et contrôlent l'accès, et recommande que les applications demandent la confirmation de l'utilisateur avant les opérations importantes. Les annotations attachées aux outils, comme « lecture seule », ne doivent pas non plus être prises pour argent comptant, sauf si elles proviennent d'un serveur de confiance.

③ est particulièrement important. Les outils qui consultent (recherche, référence, lecture) causent en général peu de dégâts même lorsqu'ils sont appelés par erreur. Ils peuvent toutefois exposer des informations confidentielles, et le contenu lu peut contenir des instructions cachées, du type « envoie ces données à une autre destination ». Les outils qui modifient (écriture, suppression, envoi, exécution) peuvent, en une seule erreur, produire des conséquences irréversibles. Distinguez les outils de lecture des outils d'écriture, et superposez les garde-fous sur ces derniers : c'est la règle d'or.

Type Exemples Risque Recommandation de mise à disposition
Lecture Recherche, consultation, lecture de fichiers Faible (fuite de données, instructions cachées dans les résultats : à surveiller) Relativement libre. Limitez le périmètre
Écriture Mise à jour de fichiers, écriture en base, envoi Élevé (difficile à annuler) Confirmation, limites et journalisation obligatoires
Exécution Exécution de commandes, appels externes, facturation Maximal (porte d'entrée pour les dérapages et les abus) Garde-fous par défaut et validation humaine intercalée

Exemple : un outil qui ne fait que lire l'état d'un ticket

Pour une demande du type « Vérifie l'état du ticket DEMO-42 et rédige un brouillon de réponse. Ne l'envoie pas. », l'outil suivant suffit.

{
  "name": "get_ticket_status",
  "description": "Consulte l'état d'un identifiant de ticket autorisé. N'envoie aucune réponse et ne modifie pas l'état.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ticket_id": { "type": "string" }
    },
    "required": ["ticket_id"],
    "additionalProperties": false
  }
}

Cet outil ne renvoie que l'état d'un ticket : il ne peut ni envoyer de réponse ni modifier un état. Côté serveur, à chaque appel, on vérifie si l'utilisateur qui le déclenche est autorisé à consulter cet identifiant. (Connaître un identifiant ne prouve pas que l'on a le droit de le consulter.) Si l'envoi devient nécessaire, prévoyez-le comme un outil distinct, où une personne vérifie au préalable le destinataire et le contenu du message.

Il faut aussi être attentif à la délimitation des dossiers. MCP dispose d'un mécanisme appelé roots qui indique au serveur les dossiers concernés, mais il ne limite pas l'accès, et il est déconseillé dans la version actuelle. Mettez en place les restrictions de périmètre dans la configuration du serveur, ou via les permissions du système d'exploitation et du service connecté.

🔒 Nous traiterons cela en profondeur au chapitre 6. La maîtrise des outils dangereux, la défense contre l'injection de prompt et la conception des flux de validation sont incontournables dès qu'un agent passe en production. Ces sujets sont abordés dans le chapitre 6, « Garde-fous et sécurité ». Dans ce chapitre, retenez surtout le sens des degrés de dangerosité des outils. Ne pas connecter à la légère un serveur MCP non fiable est aussi une habitude précieuse.

Outils avancés comme le contrôle du navigateur

Parmi les outils, ceux qui attirent particulièrement l'attention ces dernières années sont les outils de contrôle du navigateur. L'agent regarde l'écran, suit les liens, remplit des formulaires et appuie sur des boutons. Si l'on peut confier à un agent les opérations qu'une personne effectue dans un navigateur, de nombreux services web sans API dédiée deviennent eux aussi des « mains » à sa disposition. Des implémentations proposant le contrôle du navigateur comme serveur MCP sont apparues, et le seuil de connexion s'est abaissé.

Cependant, c'est aussi l'un des outils les plus puissants et les plus risqués. Les instructions affichées à l'écran peuvent être prises au pied de la lettre (manipulation et fausses informations), des clics ou des envois peuvent avoir lieu involontairement, et des informations peuvent être exposées depuis des pages où vous êtes connecté. Les mises en garde de la section précédente sur les outils d'« exécution » s'appliquent pleinement. Passer par MCP ne fait pas disparaître ces risques. Le plus sage est de commencer par des usages orientés lecture, comme la consultation et la collecte d'informations, de séparer les opérations impliquant une saisie, un envoi ou un achat, et de mettre en place des garde-fous avec prudence.

🌐 Jusqu'où peut-on déléguer ? Nous testons les capacités réelles et les limites des agents qui pilotent un navigateur dans l'article Jusqu'où l'IA peut-elle automatiser les tâches dans un navigateur ?. Comprendre la juste distance, ni toute-puissante ni inutile lorsque l'usage est bien ciblé, permet de garder des choix d'outils cohérents.

Au-delà du navigateur, plus un outil est avancé, plus ses possibilités et leurs conséquences éventuelles augmentent en proportion. Plus l'outil que vous confiez est puissant, plus il faut appliquer avec soin les trois principes : permissions, descriptions et garde-fous. C'est le message que nous n'avons cessé de répéter tout au long de ce chapitre.

Résumé de ce chapitre
  • Ce qu'un agent peut faire dépend de les outils auxquels il est connecté et des permissions dont il dispose sur ceux-ci.
  • Créer soi-même des outils classiques les rend difficiles à réutiliser et propices au problème des combinaisons N×M.
  • MCP est une norme ouverte qui connecte l'IA à des outils externes de manière standardisée. Les clients (le côté qui utilise) et les serveurs (le côté qui fournit) échangent listes et appels d'outils selon la même convention : c'est « l'USB de l'IA ».
  • Les modes de communication sont stdio (lancé en local) et Streamable HTTP (connexion à une URL). Connectez les serveurs prêts à l'emploi après avoir vérifié le fournisseur et les permissions, et transformez vos outils propres en serveurs personnalisés pour pouvoir les réutiliser.
  • Les principes de mise à disposition des outils sont ① le moindre privilège ② des descriptions précises ③ les outils dangereux traités à part. Les restrictions se mettent en œuvre dans l'implémentation, et non dans les descriptions ; soyez particulièrement prudent avec les outils puissants comme le contrôle du navigateur.

Une fois la façon d'assembler les outils comprise, l'étape suivante est « d'ajouter des agents ». Vous passerez à la conception où plusieurs agents se répartissent le travail et coopèrent, au lieu qu'un seul gère davantage qu'il ne peut. Dans le chapitre 4, « Conception multi-agents », vous apprendrez à répartir les rôles et à faire coopérer les agents entre eux (A2A).