Qu'est-ce que le protocole de contexte de modèle (MCP) ?

Les modèles d'IA sont aujourd'hui de plus en plus puissants, mais il y a un problème : ils n'ont accès qu'aux informations qu'ils ont acquises pendant l'entraînement et sont donc limités en termes de connaissances et d'aptitudes. Ils sont comme des assistants très intelligents ne pouvant travailler qu'avec les connaissances dont ils disposent déjà, ne pouvant ni rechercher des informations, ni vérifier vos fichiers ni réaliser des tâches pour vous.

Les grands modèles de langage (LLM) deviennent beaucoup plus puissants lorsqu'ils peuvent accéder au contexte et prendre des mesures dans d'autres outils et applications. Jusqu'à récemment, il n'existait pas de méthode uniforme pour que ces modèles se connectent à d'autres applications. Le protocole MCP (Model Context Protocol), initialement développé par Anthropic, est rapidement en train de devenir la méthode standard permettant aux systèmes agentiques d'IA de faire l'interface avec d'autres applications – le « connecteur USB-C » de l'IA.

Pour en savoir plus sur la prise en charge de MCP par Figma, consultez notre article de blog présentant le serveur MCP de Figma. Voyons de plus près ce qu'est le protocole MCP, comment il fonctionne et pourquoi il compte.

Qu'est-ce que le protocole MCP ?

Le protocole MCP (Model Context Protocol) est une norme open source définissant comment les systèmes pilotés par l'IA peuvent se connecter aux applications logicielles, aux outils et aux plateformes.

Le protocole MCP est un protocole de communication bidirectionnelle. D'un côté, les fournisseurs de données et les développeurs d'applications souhaitent que les LLM puissent accéder aux données et agir dans leur logiciel. Ils soutiennent le protocole MCP en concevant ce qu’on appelle un serveur MCP. De l'autre côté, des développeurs conçoivent des outils pilotés par l'IA ou des systèmes agentiques. Ils mettent en œuvre un client MCP, qui permet à leurs modèles d'IA de se connecter aux serveurs MCP pour récupérer un contexte et accomplir des tâches dans d'autres applications.

Par exemple, un outil de codage IA tel que Cursor peut disposer d'un client MCP qui se connecte au serveur MCP fourni par Figma et GitHub. La communication entre les clients et les serveurs s'effectue à l'aide d'un protocole standard, tout comme HTTP définit un protocole de communication pour Internet. Le protocole MCP spécifie quels types de messages peuvent être envoyés, comment ils sont formatés, comment fonctionne l'authentification, et plus encore.

Le problème : pourquoi le protocole MCP est nécessaire

Réserver des vols pour les prochaines vacances, extraire des analyses de données pour un rapport de ventes hebdomadaire, construire un prototype d'une nouvelle fonctionnalité – ces types de tâches nécessitent un contexte qui va au-delà des données d'entraînement d'un LLM et s'étend à un vaste écosystème d'applications et de services. Plus un assistant IA dispose de contexte, plus il sera capable de comprendre les nuances spécifiques d'une demande et de fournir un résultat de haute qualité.

Considérez un scénario dans lequel un outil de codage IA est utilisé pour générer du code à partir d'un fichier de design. Si un LLM visualise une capture d'écran du fichier et utilise ses données d'entraînement pour interpréter les pixels, il se peut qu'il puisse créer un prototype approximatif. Mais pour obtenir un produit final vraiment utile, il a besoin de plus de contexte (par exemple, les variables, les composants et les styles spécifiques, voire un pseudocode décrivant la fonctionnalité). Ce type de contexte est inestimable pour l'IA, mais réside en général profondément à l'intérieur d'autres outils (par exemple, Figma).

Avant le protocole MCP, chaque développeur travaillant sur des outils agentiques d'IA devait créer des intégrations personnalisées à des applications et à des services externes, ce qui ralentissait le développement et fragmentait l'écosystème. Chaque application exposant des données et des fonctions de manière légèrement différente, chaque intégration nouvelle nécessiterait une quantité importante de travail préalable.

Le protocole MCP observe une approche « écrire une fois, utiliser partout » pour résoudre le problème. Un développeur d'application peut écrire un seul serveur MCP à utiliser par n'importe quel système agentique d'IA, fournissant un ensemble canonique d'outils et de données ainsi qu'une fonctionnalité utile telle que la gestion des erreurs. De même, un système d'IA peut mettre en œuvre le protocole et se connecter à n'importe quel serveur MCP existant aujourd'hui comme demain.

L'origine du protocole MCP

Le protocole MCP a été créé par Anthropic pendant l'été 2024 pour offrir à Claude Desktop un moyen plus facile d'utiliser des sources de données telles que le système de fichiers local. Ses auteurs se sont inspirés du protocole LSP (Language Server Protocol) de Microsoft, la norme définissant comment les environnements de développement intégrés (IDE) prennent en charge des fonctionnalités telles que la mise en évidence du contexte ou la complétion de code à travers de nombreux langages de programmation différents.

Après avoir conçu le protocole et l'avoir utilisé en interne, Anthropic en a fait un protocole open source MCP en novembre 2024, en publiant publiquement la spécification complète du protocole accompagnée d'une documentation et de SDK (par exemple, Python).

Depuis, il a connu un succès grandissant. En janvier et en février 2025, de nombreux IDE IA, tels que Cursor et Windsurf, ont commencé à prendre en charge le protocole MCP. En mars, OpenAI a ajouté la prise en charge de MCP, et GitHub a publié son serveur MCP peu de temps après. Les produits arrivés à maturité adoptent également le protocole MCP : Microsoft Windows a annoncé qu'il prendra en charge le protocole dans les prochains mois.

Comment fonctionne le protocole MCP ?

Le protocole MCP est essentiellement un va-et-vient de demandes et de réponses : le LLM demande des données ou déclenche une action, et l'application externe répond. En termes de mise en réseau, MCP suit une architecture client-serveur où un côté (le client) envoie une demande et l'autre (le serveur) renvoie des données ou effectue une action.

La spécification MCP définit trois types de fonctionnalités que les serveurs offrent aux clients :

• ressources : données et contenu que l'application offre aux LLM (par exemple, des enregistrements de base de données, des fichiers, des captures d'écran ou des blocs de code).
• Outils : fonctions qui exécutent des actions dans l'application (par exemple, un serveur MCP PostgreSQL peut exposer un outil pour exécuter une requête SQL dans une base de données).
• Prompts : modèles de texte prédéfinis et workflows que les systèmes d'IA peuvent utiliser, conçus pour bien fonctionner avec les ressources et les outils de l'application.

Le protocole MCP définit comment les serveurs doivent exposer les ressources, les outils et les prompts aux clients de manière normalisée, y compris :

• Format de réponse : les données peuvent être envoyées sous forme de blobs JSON, de lignes SQL ou même d'images brutes – le serveur MCP convertit toutes les données qu'il reçoit dans un format standard attendu par les clients MCP (JSON-RPC 2.0).
• Analyse des commandes : le serveur MCP agit comme un traducteur, transformant les demandes des LLM en commandes que les applications peuvent utiliser (par exemple, des appels d'API).
• Gestion des erreurs : le paramètre MCP définit des codes d'erreur standard et renvoie les erreurs au LLM pour qu'il puisse réessayer ou demander de l'aide à l'utilisateur.
• Découverte d'outils : les serveurs MCP exposent une fonction qui répertorie les outils disponibles sur ce serveur, permettant ainsi à un système d'IA de savoir rapidement quelles actions il peut effectuer dans une application externe.

Architecture : hôtes MCP, clients et serveurs

Le protocole MCP repose sur un modèle d'architecture courant dans les réseaux, impliquant des hôtes, des clients et des serveurs. Le protocole définit des responsabilités spécifiques pour chaque rôle.

• Hôtes MCP : les hôtes gèrent la découverte, les autorisations et la communication entre les clients et les serveurs. L'hôte est généralement le produit ou la plateforme (par exemple, Windows OS ou Claude Desktop) où les utilisateurs accèdent aux agents d'IA pour effectuer des tâches. Lorsque le modèle a besoin d'accéder à une application externe, l'hôte lance et connecte le serveur MCP de cette application et le client correspondant.
• Clients MCP : les clients commencent et maintiennent une connexion aux serveurs MCP, avec un client par serveur. Les clients échangent des demandes et des réponses entre les LLM et les serveurs MCP.
• Serveurs MCP : les serveurs se branchent directement sur des systèmes externes (par exemple, Figma, Google Drive ou Postgres), fournissant aux LLM un accès aux données et aux fonctionnalités. Les serveurs MCP reçoivent des requêtes des clients MCP et les traduisent en commandes pour des applications externes (par exemple, des appels d'API ou des requêtes de base de données). Ils reçoivent et analysent également les réponses de l'application dans un format standard. Étant donné que les développeurs d'applications mettent en œuvre des serveurs MCP, ils peuvent choisir à quelles données les LLM ont accès, et le protocole fournit des directives concernant la sécurité et les autorisations.

Pour voir comment les pièces s'assemblent, parcourons un exemple de workflow en utilisant le serveur MCP de Figma :

• Un utilisateur ouvre Cursor, un outil de codage IA avec MCP activé, dans son dépôt de code.
• L'utilisateur demande au LLM dans Cursor de récupérer son dernier fichier Figma et de le mettre en œuvre dans sa base de code.
• Cursor lance le serveur MCP de Figma ainsi qu'un client MCP correspondant.
• Le LLM reçoit du serveur (via le client) la liste des prompts, des ressources et des outils disponibles.
• Le LLM envoie ensuite un message au serveur contenant l'outil qu'il souhaite appeler ainsi que tous les paramètres (par exemple, l'ID du fichier Figma). Le serveur formate cette demande en une demande API et envoie la demande via l'API de Figma.
• Le serveur attend les données du fichier provenant de la réponse de l'API Figma, les formate en chaîne et les renvoie au LLM (via le client).
• Avec tout le contexte supplémentaire fourni par Figma, le LLM peut alors commencer à générer le code pertinent dans Cursor.

Avantages du protocole MCP : pourquoi il compte pour l'intégration de l'IA

Les développeurs adoptent le protocole MCP car il simplifie la connexion des LLM aux applications. Comparé aux intégrations personnalisées, MCP présente plusieurs avantages.

Tout d'abord, les développeurs de systèmes IA agentiques n'ont besoin d'intégrer MCP qu'une seule fois, et ils peuvent ensuite utiliser n'importe quel serveur MCP. Les développeurs d'applications externes n'ont besoin de créer qu'un seul serveur MCP, et ensuite n'importe quel outil d'IA compatible MCP peut s'y connecter.

Deuxièmement, puisque chaque serveur MCP et chaque client MCP doivent offrir la même interface de base, changer de serveurs et de clients est trivial. Cela signifie que les développeurs et les utilisateurs peuvent naviguer facilement entre des applications telles que Dropbox et Google Docs ou Slack et Microsoft Teams.

Enfin, à mesure que les produits d'IA deviennent plus conscients du contexte grâce au protocole MCP, les outils d'IA s'améliorent partout pour les utilisateurs. Et un protocole standard pour l'écosystème signifie que les développeurs passent moins de temps à écrire du code d'intégration standard et plus de temps à développer de nouvelles fonctionnalités.

Protocole MCP et API traditionnelles : quelle est la différence ?

Pourquoi ne pas utiliser une API au lieu du protocole MCP ? C'est une question courante, car les API donnent largement accès aux mêmes données et actions des applications. En fait, de nombreux serveurs MCP utilisent des API en arrière-plan pour rendre visibles les données et les actions.

En bref, le protocole MCP permet aux assistants IA d'utiliser un ensemble de commandes pour toutes les API, ce qui simplifie grandement l'intégration. Alors qu'utiliser directement des API nécessite d'écrire du code personnalisé pour les demandes, les réponses et les nouvelles tentatives, avec MCP, un développeur peut obtenir les mêmes résultats simplement en important le serveur MCP. Passer d'un serveur MCP à un autre est facile, tandis que changer d'API nécessite d'écrire un tout nouveau jeu de code.

Le protocole MCP est également mieux optimisé pour l'utilisation des LLM. Il garantit que toutes les données dont un LLM a besoin pour accéder à un système sont bien définies et bien documentées, de manière structurée. Les définitions ad hoc d'API peuvent ne pas contenir des descriptions importantes ou rendre des données disponibles d'une manière que l'IA ne peut pas comprendre ou risque de mal interpréter.

Comment le protocole MCP et les agents IA vont de pair

Un agent IA est une IA qui prend des mesures dans le monde réel pour vous. Le protocole MCP facilite largement la création d'agents IA. Au lieu d'intégrer les API une par une, un développeur peut mettre en œuvre le protocole pour permettre à son outil IA d'agir dans n'importe quelle application compatible avec MCP.

À mesure que l'écosystème MCP se développe, les agents gagnent eux aussi en puissance. Les agents IA doivent être capables de planifier et d'agir à travers plusieurs outils dans l'espace de travail d'un utilisateur : plus un agent peut utiliser d'outils, plus il est utile pour les utilisateurs. Avec MCP, les agents peuvent facilement trouver et utiliser un nombre croissant d'outils pour l'automatisation des tâches.

MCP et A2A : comment les protocoles se complètent

MCP n'est pas le seul protocole LLM nouveau disponible – Google a récemment annoncé le protocole Agent2Agent (A2A). Mais les développeurs n'ont pas besoin de choisir l'un ou l'autre. Ces protocoles résolvent différents problèmes et se complètent.

Le protocole MCP doit permettre aux systèmes d'IA d'apprendre sur le monde et d'agir dans le monde. Le protocole A2A doit aider les systèmes d'IA à échanger entre eux sur leur travail et leurs intentions – pour collaborer, attribuer des tâches, argumenter, déléguer ou négocier.

Deux agents pourraient utiliser le protocole A2A pour décider lequel d'entre eux va effectuer une tâche et lequel va superviser le travail. Ils pourraient utiliser le protocole MCP pour se donner des instructions sur le travail à effectuer et les données à utiliser.

L'avenir de l'intégration de MCP et de l'IA

L'équipe MCP met continuellement à jour le protocole, de nouvelles versions étant publiées plusieurs fois par mois. MCP est également une norme ouverte, permettant ainsi à la communauté globale de l'IA de contribuer à la roadmap. Plus d'accent devrait être mis sur la sécurité dans les prochaines versions : mécanismes d'authentification, d'autorisation et de filtrage des données ou de confidentialité pour des domaines spécifiques (par exemple, la santé ou la finance).

Si le protocole MCP est largement adopté, alors des secteurs entiers de l'industrie de l'IA pourraient commencer à optimiser son utilisation. Les développeurs de modèles pourraient commencer à inclure l'utilisation de l'outil MCP dans leurs données d'entraînement, et les cadres d'orchestration LLM (par exemple, LangChain) pourraient soutenir MCP comme solution de premier plan dans leurs cas d'utilisation.

Au fil du temps, le protocole MCP pourrait devenir le standard de facto pour connecter l'IA à l'ensemble du paysage numérique des outils et des services. Intégrer dans les expériences LLM des données et des actions provenant de systèmes externes sera de plus en plus simple et rapide dans l'écosystème de l'IA. Pour les développeurs, cela se traduit par moins de wrappers sur mesure, de meilleurs outils d'IA et plus de temps pour concevoir les fonctionnalités que les utilisateurs apprécient réellement. Pour les entreprises diffusant des applications riches en données, cela signifie une compatibilité instantanée avec chaque plateforme d'IA compatible MCP. Et pour les utilisateurs finaux, cela se traduit par de meilleures applications d'IA et des assistants personnels qui peuvent enfin récupérer le bon contexte, appuyer sur les bons boutons et accomplir un travail réel sans intervention fastidieuse de l'utilisateur.