Qu’est-ce que le Model Context Protocol (MCP) ?

Présentation du Model Context Protocol

Le MCP sert de passerelle universelle entre des modèles d’IA externes et vos systèmes internes. Il ne s’agit ni d’une base de données, ni d’un moteur d’exécution, ni d’un modèle à proprement parler. Il s’agit d’un protocole de communication standardisé (fondé sur JSON-RPC), créé par Anthropic en 2024, qui connecte de manière sécurisée l’IA aux outils et aux informations propriétaires en temps réel dont elle a besoin pour être utile.

Les premiers modèles d’IA ne disposaient d’aucun moyen intégré pour accéder aux données et systèmes d’entreprise sécurisés et en temps réel. Auparavant, leur connexion nécessitait l’écriture d’un code d’intégration personnalisé pour chaque association entre un modèle et une source de données. Cette approche fragile ne pouvait pas être déployée à grande échelle.

MCP résout ce problème avec une couche unique et unifiée. Les API traditionnelles obligent le modèle à connaître les caractéristiques précises de chaque point de terminaison. Les kits de développement logiciel (SDK) limitent quant à eux les intégrations à certains langages de programmation. Le MCP contourne ces deux contraintes en fournissant une couche unique et universellement adaptable pour transférer des données et invoquer des outils. Surtout, cela donne aux modèles d’IA le pouvoir de changer les choses dans le monde réel. Au lieu de se contenter de générer du texte dans une interface de chat isolée, le modèle acquiert la capacité d’agir sur vos systèmes : supprimer des données, modifier des configurations, écrire des fichiers ou encore changer des autorisations. Cela élimine le besoin de code personnalisé chaque fois qu’une nouvelle intégration est nécessaire.

Comparaison du MCP avec les frameworks d’outils existants

Les évaluateurs techniques utilisant déjà des frameworks d’agents d’IA demandent fréquemment comment MCP se compare aux fonctionnalités natives telles que l’appel de fonctions OpenAI, l’utilisation d’outils Anthropic ou les bibliothèques d’orchestration comme LangChain. En résumé, le MCP ne remplace pas ces technologies. Il intervient à un niveau d’infrastructure entièrement différent.

L’appel de fonctions d’OpenAI et l’utilisation d’outils d’Anthropic sont des API intervenant au niveau des requêtes. Elles permettent à un modèle précis de comprendre et de générer des données structurées afin d’exécuter des outils. LangChain fournit des abstractions au niveau applicatif permettant d’orchestrer ces comportements agentiques. À l’inverse, MCP est un protocole de transport au niveau du système, neutre vis-à-vis des fournisseurs.

Une application d’IA conçue avec LangChain peut toujours utiliser la fonctionnalité native d’appel de fonctions d’OpenAI pour déclencher une action. Le MCP standardise toutefois la manière dont cette action est acheminée de façon sécurisée vers la source de données externe. Grâce à ce découplage, vous pouvez créer un outil une seule fois sous la forme d’un serveur MCP, puis l’exposer à n’importe quel modèle ou framework. Vous n’avez ainsi plus besoin de maintenir un code d’intégration cloisonné pour chaque fournisseur d’IA.

Incidence du MCP sur les workflows de développement

Ces avantages techniques améliorent directement la façon dont les équipes gèrent les intégrations d’IA complexes. Grâce à l’utilisation d’un protocole standardisé, les développeurs peuvent se concentrer sur la logique métier plutôt que sur la gestion de formats de données ou de protocoles de connexion disparates.

La séparation entre la couche d’IA et la couche des sources de données crée un environnement plus modulaire. Cette modularité permet aux organisations d’adapter leur infrastructure pour répondre à l’évolution des besoins sans perturber les fonctionnalités existantes de l’assistant ou de l’agent IA.

Quels sont les principaux composants et l’architecture du MCP ?

L’architecture MCP utilise un modèle client-serveur strict pour acheminer le contexte de manière sécurisée. Dans ce cadre, les clients MCP sont généralement des applications intégrant l’IA ou des environnements de développement intégrés (IDE). Ces clients communiquent avec des serveurs MCP, qui agissent comme des mandataires légers auprès des sources de données et exposent des fonctions exécutables appelées « outils ».

Lors d’un échange de contexte, le client émet une requête demandant au serveur d’exécuter un outil précis. Le serveur récupère et formate ensuite les données brutes selon un schéma MCP standard avant de les renvoyer au client. Ce cycle de vie commence par un établissement de liaison et une négociation des capacités, suivis de requêtes JSON-RPC structurées et de réponses déterministes.

Bien que le protocole soit principalement conçu pour des interactions sans état, des sessions avec état peuvent être implémentées en utilisant des identifiants de session au sein de la couche de transport. Le MCP garantit son extensibilité en fonctionnant sur des couches de transport standard, notamment les entrées/sorties standard (Stdio) pour les processus locaux et les événements envoyés par le serveur (Server-Sent Events, ou SSE) pour les connexions réseau distantes.

Quels sont les outils MCP ?

Pour récupérer des données, le protocole s’appuie sur des fonctionnalités précisément définies appelées outils. Dans l’écosystème MCP, les outils sont strictement définis comme des fonctions exécutables exposées par un serveur MCP. Ces outils comprennent un schéma JSON précisant les arguments d’entrée requis et les formats de sortie attendus. Ils constituent ainsi les points de terminaison d’API précis qui traduisent une intention abstraite de l’IA en opérations concrètes sur l’infrastructure.

Voici quelques exemples réels de noms d’outils MCP :

• read_local_file pour interagir avec un système de fichiers.
• github_create_issue pour interagir avec un système de gestion du code source.
• scan_artifact_vulnerabilities pour interagir avec des plateformes de sécurité.

Que sont les compétences d’agent ?

Pour comprendre le fonctionnement concret des compétences d’agent, il est utile d’examiner la manière dont elles sont réellement conçues. Les plugins et compétences natifs utilisés par les agents de programmation modernes reposent essentiellement sur des serveurs MCP. Ces serveurs regroupent des outils spécifiques afin de fournir ses capacités au modèle d’IA.

Selon leur mode d’hébergement et d’utilisation, ces compétences reposant sur le MCP se répartissent généralement en trois catégories :

• Serveurs distants (accessibles par URL) : ces serveurs sont hébergés sur une infrastructure externe et accessibles par l’intermédiaire d’un point de terminaison web. Parce qu’ils ne sont pas téléchargés ou installés localement, ils ne peuvent pas être gérés comme des artefacts logiciels traditionnels. La gouvernance et les contrôles de sécurité doivent alors être strictement appliqués au niveau de l’environnement d’exécution et du réseau.
• Packages open source : de nombreux serveurs MCP sont distribués par l’intermédiaire d’écosystèmes open source standard, tels que npm ou PyPI, ou sous la forme d’images Docker. Ils possèdent toutes les caractéristiques des packages logiciels open source classiques. Ils peuvent être facilement téléchargés depuis des registres publics et installés localement. Ils doivent donc être traités et analysés comme des artefacts logiciels standard.
• Personnalisé : Les organisations développent fréquemment leurs propres serveurs MCP propriétaires pour un usage interne uniquement. Ces serveurs personnalisés agissent comme des passerelles sécurisées, permettant aux agents de programmation internes d’accéder aux systèmes privés de l’entreprise, d’interagir avec eux et de les modifier en toute sécurité.

Intégration aux systèmes existants

L’intégration de MCP implique le déploiement de serveurs spécifiques aux côtés de l’infrastructure existante. Grâce à l’intégration du MCP aux pipelines CI/CD, les agents d’IA peuvent interroger l’état des builds ou récupérer des données de journalisation afin de faciliter le débogage automatisé. Lorsque le MCP est connecté à des outils et plateformes de développement, tels que les environnements de développement intégrés ou les systèmes de gestion de versions, les assistants d’IA intégrés peuvent demander de manière transparente le contexte de l’espace de travail local.

L’utilisation du MCP avec les API et services existants est simple : le MCP ne remplace pas les API REST ou GraphQL. Il les encapsule et traduit les requêtes standardisées du modèle en appels précis vers les API existantes. Il constitue donc un atout essentiel pour l’ingénierie de plateforme et les plateformes internes pour développeurs (IDP), car il permet aux équipes de standardiser la manière dont les outils d’IA accèdent de façon sécurisée aux composants internes.

Prise en main du MCP : implémentation et configuration

Lorsque vous êtes prêt à implémenter le protocole, le processus de configuration dépend du type de serveur MCP que vous utilisez.

• Pour les serveurs prédéveloppés ou distants : le processus est considérablement simplifié. Vous n’avez aucun développement à effectuer. Il vous suffit d’obtenir l’URI de transport du serveur existant afin de configurer votre client MCP.
• Pour les serveurs personnalisés : le processus nécessite une phase de développement. Commencez par identifier les sources de données dont vous avez besoin et par sélectionner un SDK MCP, par exemple pour Python ou TypeScript. Ensuite, développez un script serveur qui définit vos outils et votre logique de récupération de données. Vous devez ensuite déployer ce serveur dans un environnement sécurisé disposant d’un accès autorisé aux données ciblées.

Quel que soit le chemin que vous empruntez, l’étape finale est identique. Pour terminer la configuration, configurez le client, lancez un handshake entre le client et le serveur, puis vérifiez que les outils ont bien été découverts.

Cas d’utilisation courants du MCP

Le MCP est extrêmement polyvalent, offrant aux modèles d’IA un accès à la réalité opérationnelle. Le protocole permet de mettre en œuvre de nombreuses intégrations puissantes :

• DevOps assisté par l’IA : les agents peuvent interroger l’état des clusters afin de suggérer des optimisations opérationnelles.
• Gestion des artefacts : les modèles peuvent identifier instantanément les arborescences de dépendances ou les versions binaires afin d’obtenir immédiatement des informations sur les dépôts.
• Dépannage des pipelines CI/CD : le MCP est particulièrement efficace dans les pipelines CI/CD, car il peut récupérer les journaux d’échec et suggérer des corrections du code.
• Intégration DevSecOps : il facilite les analyses de sécurité en mettant en corrélation les bases de données de vulnérabilités avec le code source.
• Workflows des développeurs : le MCP permet de mettre en place des workflows en libre-service pour les développeurs, notamment au moyen de chatbots capables de provisionner des environnements de préproduction.

Le MCP est maintenu dans le cadre d’une collaboration open source. Cet écosystème fournit des SDK standardisés et des serveurs préconfigurés, utilisant des standards ouverts pour garantir une large compatibilité et une cohérence de développement. Il évolue à mesure que les développeurs rencontrent des cas particuliers, proposent des demandes de commentaires (RFC) et soumettent des contributions aux projets en amont, tout en respectant rigoureusement des principes de conception indépendants des fournisseurs afin d’éviter toute dépendance propriétaire.

Toutefois, l’utilisation de ces serveurs MCP open source et de dépendances externes introduit des risques inhérents pour la chaîne d’approvisionnement logicielle. Les organisations doivent appliquer à ces ressources de l’écosystème les mêmes mesures d’analyse continue et de contrôle rigoureux qu’à tout autre composant tiers, afin d’empêcher des packages malveillants de compromettre leur infrastructure.

Considérations relatives à la sécurité et à la conformité

Une implémentation réussie nécessite un modèle de responsabilité confié à l’équipe d’ingénierie de plateforme, dans lequel les serveurs MCP sont traités comme des composants essentiels de l’infrastructure et leur gouvernance est partagée entre les équipes de développement, d’exploitation et de sécurité. Ce point est important, car le MCP se trouve directement sur le chemin d’accès aux données et aux systèmes internes. À mesure que l’IA passe d’un rôle d’interaction passive à un rôle d’exécution active, les identifiants et autorisations accordés aux agents ont des conséquences opérationnelles bien réelles. Cet accès doit être géré avec la même rigueur que tout autre élément critique de la pile.

Ce qu’imposent les bonnes pratiques en matière d’implémentation sécurisée :

• Exécuter les serveurs dans des environnements isolés et ne jamais les exécuter avec les privilèges root.
• Exiger des modèles robustes d’authentification et d’autorisation, tels que l’authentification TLS mutuelle (mTLS) ou les jetons porteurs, pour les transports distants.
• Appliquer un contrôle d’accès strict au niveau des outils et veiller à ce que les opérations destructrices ne soient jamais exposées.
• Respecter le principe du moindre privilège pour les interactions avec l’IA, en n’accordant au compte de service du serveur que les autorisations de lecture et d’écriture strictement nécessaires.

Les équipes chargées de la sécurité des applications doivent anticiper et réduire les vulnérabilités courantes :

• Des outils disposant de privilèges excessifs peuvent permettre à des pirates d’exfiltrer des bases de données. Ce risque peut être atténué grâce à l’utilisation de requêtes paramétrées.
• Les injections de prompts et les scénarios d’utilisation abusive doivent être gérés en assainissant toutes les entrées côté serveur.
• Une gestion rigoureuse des secrets et des mesures de prévention contre la fuite d’identifiants doivent être mises en œuvre au moyen de coffres-forts sécurisés. Elles doivent être complétées par une observabilité approfondie et par la journalisation, à des fins d’audit, de chaque invocation d’outil.

En alignant l’utilisation du MCP sur des pratiques DevSecOps telles que l’analyse statique de la sécurité des applications (SAST) et l’analyse de la composition logicielle (SCA), les organisations peuvent respecter les normes réglementaires et sectorielles, telles que le RGPD ou la loi HIPAA. Pour les actions sensibles, des mécanismes stricts d’application des politiques et des workflows d’approbation doivent être conçus afin d’imposer une intervention humaine.

L’avenir du MCP

Le MCP est en passe de devenir le système nerveux standard de l’IA. Sa feuille de route prévoit notamment la prise en charge native du streaming bidirectionnel, des plateformes conçues nativement pour l’IA et intégrant directement des interfaces serveur, ainsi que la poursuite du développement de workflows autonomes. L’impact sur le développement logiciel est déjà tangible. Au lieu de parcourir des tableaux de bord et de la documentation, les développeurs peuvent interroger directement l’infrastructure en temps réel au moyen d’une conversation. Cette réduction des frictions entre les humains, les modèles et les systèmes explique pourquoi le MCP est de plus en plus considéré comme un socle d’infrastructure essentiel assurant leur interconnexion. Une collaboration durable entre les différents fournisseurs devrait consolider sa position de norme ouverte à long terme pour l’ensemble du secteur.