AvancéAgents IA
22 min de lecture11 vues

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

TransportUsageAvantages
stdioLocal, même machineSimple, sécurisé, aucun réseau
SSE (Server-Sent Events)Remote, HTTP unidirectionnelCompatible navigateurs, easy deploy
Streamable HTTPRemote, bidirectionnelLe 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èreFunction Calling classiqueMCP
PortabilitéSpécifique à chaque fournisseurStandard universel
DéploiementDans le code de l'agentServeur indépendant
RéutilisabilitéLimitéeUn serveur = N clients
MaintenanceCouplée à l'agentDécouplée
SécuritéGérée par le développeurCouche auth dédiée
ÉcosystèmeSiloed+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.