MCP : Le Protocole qui Connecte les Agents aux Outils
Découvrez MCP (Model Context Protocol) créé par Anthropic : architecture client-serveur, transports stdio et HTTP, utilisation avec Agno, et création de votre propre serveur MCP.
Le problème avant MCP
Avant MCP, chaque LLM avait sa propre façon d'appeler des outils. OpenAI avait son format de function calling, Anthropic le sien, et les frameworks comme LangChain devaient écrire des adaptateurs spécifiques pour chaque combinaison modèle × outil.
Résultat : une fragmentation massive. Un connecteur écrit pour GPT-4 ne fonctionnait pas avec Claude. Un outil développé pour LangChain n'était pas réutilisable dans LlamaIndex. Chaque équipe réinventait la roue.
MCP (Model Context Protocol) est un standard ouvert créé par Anthropic en novembre 2024 pour résoudre ce problème. Il définit un protocole universel entre un client (l'agent LLM) et un serveur (la source d'outils ou de données). Pensez-y comme un USB pour l'IA : une prise universelle.
Architecture MCP : client, serveur, transports
Les 3 types de transport
| Transport | Usage | Avantages |
|---|---|---|
| stdio | Local, même machine | Simple, sécurisé, aucun réseau |
| SSE (Server-Sent Events) | Remote, HTTP unidirectionnel | Compatible navigateurs, easy deploy |
| Streamable HTTP | Remote, bidirectionnel | Le plus performant, streaming natif |
Un serveur MCP expose trois types de primitives :
- Tools : fonctions que le LLM peut appeler (ex : lire un fichier, faire une requête SQL)
- Resources : données accessibles en lecture (ex : contenu d'un fichier, résultats de requête)
- Prompts : templates réutilisables avec paramètres
MCP vs Function Calling classique
| Critère | Function Calling classique | MCP |
|---|---|---|
| Portabilité | Spécifique à chaque fournisseur | Standard universel |
| Déploiement | Dans le code de l'agent | Serveur indépendant |
| Réutilisabilité | Limitée | Un serveur = N clients |
| Maintenance | Couplée à l'agent | Découplée |
| Sécurité | Gérée par le développeur | Couche auth dédiée |
| Écosystème | Siloed | +1000 serveurs publics |
Avec MCP, un serveur "accès Notion" peut être utilisé par Claude.app, Cursor, votre agent Agno, et tout autre client MCP : sans réécrire une ligne.
Utiliser un serveur MCP dans Agno
Agno intègre MCP via la classe MCPTools. Deux modes principaux.
Transport stdio (local)
Le serveur MCP tourne comme un sous-processus sur votre machine. Idéal pour les outils locaux (filesystem, bases de données locales).
import asyncio
from agno.agent import Agent
from agno.models.anthropic import Claude
from agno.tools.mcp import MCPTools
async def main():
async with MCPTools("npx -y @modelcontextprotocol/server-filesystem .") as mcp:
agent = Agent(
model=Claude(id="claude-sonnet-4-20250514"),
tools=[mcp],
markdown=True,
)
await agent.aprint_response("Quels fichiers sont dans le répertoire courant ?")
asyncio.run(main())
Le async with démarre le serveur MCP en arrière-plan et le coupe proprement à la fin. La commande npx -y @modelcontextprotocol/server-filesystem . lance le serveur officiel de filesystem d'Anthropic sans installation préalable.
Transport URL (SSE ou Streamable HTTP)
Pour les serveurs MCP distants (APIs externes, services managés) :
import asyncio
from agno.agent import Agent
from agno.models.anthropic import Claude
from agno.tools.mcp import MCPTools
async def main():
# Serveur MCP distant via Streamable HTTP
async with MCPTools(
url="https://mcp.example.com/server",
transport="streamable-http"
) as mcp:
agent = Agent(
model=Claude(id="claude-sonnet-4-20250514"),
tools=[mcp],
markdown=True,
)
await agent.aprint_response("Exécute une recherche sur nos données clients.")
asyncio.run(main())
Micro-exercice : agent qui explore le filesystem via MCP
Prérequis : Node.js installé (pour npx)
import asyncio
from agno.agent import Agent
from agno.models.anthropic import Claude
from agno.tools.mcp import MCPTools
async def explorer_filesystem():
# Le serveur MCP filesystem expose le répertoire courant
async with MCPTools("npx -y @modelcontextprotocol/server-filesystem .") as mcp:
agent = Agent(
model=Claude(id="claude-sonnet-4-20250514"),
tools=[mcp],
markdown=True,
instructions="Tu explores le filesystem et fournis des réponses structurées.",
)
# L'agent utilise les tools MCP pour lire réellement les fichiers
await agent.aprint_response(
"Liste tous les fichiers Python dans ce répertoire et donne-moi "
"un résumé du contenu de chacun."
)
asyncio.run(explorer_filesystem())
Ce qui se passe : l'agent appelle list_directory, puis read_file pour chaque .py trouvé : des vrais appels au filesystem via le protocole MCP, pas une simulation.
Créer son propre serveur MCP en Python
Le SDK Python officiel d'Anthropic rend la création d'un serveur MCP triviale.
# mon_serveur_mcp.py
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("Mon Serveur MCP")
@mcp.tool()
def calculer_tva(montant_ht: float, taux: float = 0.20) -> dict:
"""Calcule la TVA et le montant TTC."""
tva = montant_ht * taux
return {
"montant_ht": montant_ht,
"tva": round(tva, 2),
"montant_ttc": round(montant_ht + tva, 2),
"taux_applique": f"{taux * 100}%"
}
@mcp.tool()
def convertir_devise(montant: float, de: str, vers: str) -> str:
"""Convertit un montant entre devises (taux fictifs pour l'exemple)."""
taux = {"EUR_USD": 1.08, "USD_EUR": 0.93, "EUR_GBP": 0.85}
cle = f"{de}_{vers}"
if cle in taux:
resultat = montant * taux[cle]
return f"{montant} {de} = {resultat:.2f} {vers}"
return f"Conversion {de} → {vers} non supportée"
if __name__ == "__main__":
mcp.run()
Pour l'utiliser dans Agno :
async with MCPTools("python mon_serveur_mcp.py") as mcp:
agent = Agent(model=Claude(id="claude-sonnet-4-20250514"), tools=[mcp])
await agent.aprint_response("Calcule la TVA sur 1500€ HT.")
Le décorateur @mcp.tool() suffit. Le SDK génère automatiquement le schéma JSON de l'outil à partir des type hints et de la docstring Python.
MCP en production : sécurité et authentification
Un serveur MCP expose des capacités réelles (lecture de fichiers, requêtes BDD, appels API). En production, ces points sont non-négociables :
- Authentification : utilisez OAuth 2.0 ou des API keys. Le standard MCP supporte les headers HTTP Authorization.
- Validation des inputs : ne faites jamais confiance aux paramètres envoyés par le LLM. Validez avec Pydantic ou des assertions strictes.
- Principe du moindre privilège : un serveur MCP "lecture seule BDD" ne doit pas avoir de credentials d'écriture.
- Audit logs : loggez chaque appel d'outil avec l'identité de l'appelant et les paramètres.
- Rate limiting : protégez vos serveurs MCP comme n'importe quelle API publique.
L'écosystème MCP grandit rapidement : en 2026, des centaines de serveurs sont disponibles publiquement pour Slack, GitHub, Notion, PostgreSQL, et bien d'autres.
Specialiste IA — Master Intelligence Artificielle
Diplome d'un Master en Intelligence Artificielle, je travaille au quotidien sur des projets IA en entreprise. J'ai cree IwanttolearnAI pour rendre l'apprentissage de l'IA accessible a tous, gratuitement.
Continuer a apprendre
Mémoire des Agents IA : Short-Term et Long-Term avec Agno
Apprenez à donner une mémoire persistante à vos agents Agno : short-term dans le contexte, long-term avec SQLite et PostgreSQL, et partage de mémoire entre plusieurs agents.
Tool Use et Function Calling avec Agno
Donnez des "mains" à vos agents IA : apprenez à utiliser les outils intégrés d'Agno (recherche web, fichiers, finance) et à créer vos propres outils custom avec le décorateur @tool.
Comprendre les Agents IA : Au-delà du Simple Chatbot
Découvrez ce qu'est un agent IA, comment il diffère d'un simple chatbot, et les concepts fondamentaux : boucle de raisonnement, outils, mémoire et planification.