Prendre RDV
Lexique · Frameworks / outils IA

MCP : définition, fonctionnement et exemple

Un standard ouvert qui connecte un LLM à des outils et à des données par des serveurs interchangeables : principe, architecture, exemple de code, comparaison avec A2A et le function calling.

Par Équipe Blent· Mis à jour le · 13 min de lecture· Niveau intermédiaire

MCP en bref

Nom complet
Model Context Protocol
Type
Protocole ouvert client-serveur
Créateur
Anthropic
Lancement
Novembre 2024

Définition : MCP

Le MCP, ou Model Context Protocol, est un standard ouvert qui définit la manière dont une application d'IA se connecte à des outils et à des sources de données externes. Lancé par Anthropic en novembre 2024, il repose sur une architecture client-serveur : un serveur MCP expose des outils, des ressources et des prompts, et l'application hôte les propose au LLM par l'intermédiaire d'un client. Un même serveur peut ainsi servir n'importe quelle application compatible, sans intégration spécifique. Le protocole est aujourd'hui adopté par OpenAI, Google et Microsoft, et géré dans un cadre neutre au sein de la Linux Foundation.

En une phrase : le MCP est un standard ouvert qui permet à n'importe quelle application d'IA d'utiliser les mêmes serveurs d'outils et de données, sans intégration sur mesure.

Dans cette définition

Qu'est-ce que le MCP ?

Le MCP, pour Model Context Protocol, répond à un problème d'intégration. Pour qu'un assistant puisse lire un dépôt de code, une base de données ou une messagerie, chaque application devait écrire son propre connecteur pour chaque système, et le refaire pour chaque modèle. Le protocole remplace cette multiplication de connecteurs par une interface unique, que l'on compare souvent à un port USB-C pour l'IA.

Il s'inscrit dans la logique des agents IA : un LLM seul ne fait que produire du texte, mais relié à des outils par le tool calling, il peut agir. Le MCP standardise la partie qui manquait, c'est-à-dire la publication et la découverte de ces outils. Notre article Model Context Protocol : définition et exemples en détaille les primitives.

Anthropic a publié le protocole en novembre 2024. Il a ensuite été adopté par OpenAI, Google et Microsoft, puis confié en décembre 2025 à l'Agentic AI Foundation, un fonds de la Linux Foundation, ce qui en fait un standard neutre.

À retenir : le MCP ne remplace pas le function calling. Il standardise la façon dont les outils sont exposés et découverts, le modèle les appelant toujours par son mécanisme habituel.

Comment fonctionne le MCP ?

Une interaction MCP suit cinq temps, de la connexion au serveur jusqu'à la réponse finale du modèle.

  1. Connecter le client au serveur

    L'application hôte (assistant, IDE, agent) lance un client MCP qui se connecte à un serveur, en local par l'entrée standard ou à distance par HTTP.

  2. Négocier les capacités

    Au démarrage, client et serveur échangent leur version du protocole et déclarent ce qu'ils savent faire : outils, ressources, prompts.

  3. Découvrir les outils

    Le client demande la liste des outils du serveur, avec leur description et leur schéma d'arguments, puis la transmet au modèle.

  4. Appeler un outil

    Quand le modèle décide d'utiliser un outil, le client envoie la requête au serveur, qui exécute l'action et renvoie un résultat structuré.

  5. Réinjecter le résultat

    Le résultat est ajouté au contexte du modèle, qui peut enchaîner un nouvel appel ou formuler sa réponse à l'utilisateur.

Sous le capot : hôte, client et serveur

L'architecture du MCP distingue trois rôles. L'hôte est l'application qui embarque le modèle (assistant, IDE, agent). Il crée un client MCP par serveur auquel il se connecte. Le serveur expose ses capacités et exécute les demandes.

Un serveur peut publier trois types de briques :

  • Outils : des fonctions que le modèle peut appeler, avec des arguments typés (créer un ticket, exécuter une requête).
  • Ressources : des données en lecture, identifiées par un URI (fichier, enregistrement, page de documentation).
  • Prompts : des modèles de requêtes réutilisables, que l'utilisateur peut déclencher.

Les messages suivent le format JSON-RPC 2.0. Deux transports sont courants : l'entrée et la sortie standard pour un serveur lancé en local, et HTTP pour un serveur distant, qui suppose une authentification. La spécification évolue par révisions datées, d'où l'étape de négociation de version à la connexion.

Exemple : un serveur MCP en Python

Le SDK Python officiel permet de publier un outil en quelques lignes. Cet exemple expose une fonction qui renvoie le statut d'une commande.

python
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("commandes")

@mcp.tool()
def statut_commande(numero: str) -> str:
    """Renvoie le statut d'une commande à partir de son numéro."""
    # Appel à la base ou à l'API interne (simulé ici)
    return f"Commande {numero} : expédiée"

if __name__ == "__main__":
    # Transport par entrée standard, pour un client lancé en local
    mcp.run()

Le décorateur @mcp.tool() publie la fonction : son nom, sa docstring et ses types d'arguments deviennent la description que le modèle lit pour décider de l'appeler. Il suffit ensuite de déclarer ce serveur dans la configuration d'un client compatible pour que l'outil apparaisse dans l'assistant.

Les principaux cas d'usage du MCP

Le MCP sert partout où un modèle doit lire une donnée ou déclencher une action dans un système externe.

  • Assistants de code

    Donner à l'IDE l'accès au dépôt Git, au gestionnaire de tickets ou à la documentation.

  • Accès aux données

    Interroger une base SQL ou un entrepôt de données en langage naturel, avec des droits limités.

  • Recherche documentaire

    Brancher un assistant sur un drive, un wiki ou une base de connaissances d'entreprise.

  • Automatisation métier

    Créer un ticket, envoyer un message ou mettre à jour un CRM depuis une conversation.

  • Navigation et tests

    Piloter un navigateur ou un terminal pour tester une interface ou collecter une information.

  • Agents multi-outils

    Offrir à un agent un catalogue d'outils standardisé, extensible sans modifier son code.

Quels sont les avantages du MCP ?

L'intérêt du MCP est d'abord économique : une intégration écrite une fois sert toutes les applications compatibles.

  • Un serveur MCP se développe une seule fois et fonctionne avec plusieurs clients et plusieurs modèles.
  • Le protocole évite la multiplication des connecteurs spécifiques à chaque application.
  • Les outils sont découverts dynamiquement : ajouter une capacité ne demande pas de modifier l'agent.
  • Un écosystème large de serveurs existe déjà, des officiels comme des communautaires.
  • Le standard est ouvert, documenté et doté de SDK dans plusieurs langages.
  • Les droits et les périmètres d'accès se règlent côté serveur, au plus près de la donnée.

Quelles sont les limites du MCP ?

Le MCP standardise la connexion, pas la confiance : la qualité et la sécurité dépendent de chaque serveur utilisé.

  • Un serveur tiers non vérifié peut exposer des outils dangereux ou exfiltrer des données.
  • Les descriptions d'outils entrent dans le contexte du modèle et peuvent servir de vecteur d'injection de prompt.
  • Charger beaucoup d'outils alourdit le contexte et dégrade le choix du modèle.
  • L'authentification et la gestion des droits à distance demandent une vraie conception.
  • Le protocole évolue par révisions successives : les clients et les serveurs doivent suivre.
  • Pour une seule intégration simple, un appel d'API direct reste plus léger.

MCP vs A2A et function calling : quelles différences ?

Ces trois notions sont souvent confondues, alors qu'elles se situent à des niveaux différents.

CritèreMCPA2AFunction calling
RelationAgent vers outil ou donnéeAgent vers agentModèle vers fonction
InitiateurAnthropic, 2024Google, 2025Fournisseurs de modèles
NatureProtocole ouvert de connexionProtocole ouvert de collaborationCapacité du modèle via l'API
DécouverteListe des outils du serveurFiche descriptive de l'agentDéfinie dans chaque requête
RéutilisationUn serveur pour tous les clientsUn agent pour tous les agentsPropre à chaque application
ExempleLire une base de ticketsDéléguer une analyse à un autre agentAppeler get_weather(ville)

Ce n'est pas un choix binaire. Un agent utilise le MCP pour accéder à ses outils et A2A pour collaborer avec d'autres agents. Le protocole A2A traite ce second volet.

Bonnes pratiques de sécurité et de contexte

Brancher un serveur MCP revient à donner à un modèle un accès à un système réel. Quelques règles limitent les risques :

  • Ne pas faire confiance par défaut : choisir des serveurs dont la source est connue et épingler leur version.
  • Limiter les droits : accès en lecture seule quand c'est possible, jetons à portée réduite.
  • Faire valider les actions sensibles : écriture, suppression et paiement passent par une confirmation humaine.
  • Isoler l'exécution : un bac à sable limite l'impact d'un outil compromis.
  • Garder un catalogue court : chaque outil chargé occupe le contexte, et l'ingénierie du contexte conseille de ne charger que ce qui sert la tâche. Les Agent Skills complètent utilement cette approche.

Quand utiliser le MCP ?

La question à se poser : l'intégration doit-elle être réutilisée par plusieurs applications ou plusieurs modèles ?

Pertinent si

L'intégration doit être partagée

  • Plusieurs applications ou agents ont besoin des mêmes outils.
  • Le catalogue d'outils évolue souvent.
  • L'équipe veut changer de modèle sans réécrire les connecteurs.
  • Un serveur existe déjà pour le système à brancher.
Moins adapté si

Le besoin est ponctuel et fermé

  • Un seul outil interne, dans une seule application, suffit.
  • Le function calling du fournisseur couvre déjà le besoin.
  • Les exigences de sécurité interdisent des serveurs externes.
  • Le traitement est un enchaînement fixe sans choix d'outil par le modèle.

Technologies et outils associés au MCP

Le MCP s'appuie sur des SDK, des clients compatibles et des frameworks d'agents qui consomment ses serveurs.

Les concepts à connaître autour du MCP

Le MCP s'inscrit dans la boîte à outils de l'Agentic AI et de l'ingénierie du contexte.

Ressources pour approfondir le MCP

Trois articles du blog Blent pour passer de la définition à la conception d'agents outillés.

Questions fréquentes

Questions fréquentes

MCP signifie Model Context Protocol. C'est un standard ouvert, lancé par Anthropic en novembre 2024, qui décrit comment une application d'IA découvre et utilise des outils, des ressources et des prompts exposés par des serveurs, avec un format de messages commun pour tous les modèles.

Expertise

À propos de l'auteur

Équipe Blent

Les ingénieurs et mentors Blent conçoivent, évaluent et mettent en production des agents IA, et forment chaque année des centaines de professionnels à l'IA générative.

Sources et méthodologie

  • Anthropic, Introducing the Model Context Protocol, novembre 2024
  • Documentation et spécification officielles du Model Context Protocol (modelcontextprotocol.io)
  • Linux Foundation, annonce de l'Agentic AI Foundation, décembre 2025
  • Retours d'expérience des projets et formations Blent
Lexique

Explorer le lexique

Voir toutes les définitions