MCP et Connectors : connecter des services externes

Le Model Context Protocol (MCP) est un protocole ouvert qui permet à votre agent de se connecter à des services externes de manière standardisée. Plutôt que de recoder l’intégration avec chaque service, vous branchez un serveur MCP et votre agent obtient instantanément de nouveaux outils.

Qu’est-ce que MCP ?

MCP est un standard ouvert qui définit comment un client (votre agent) communique avec un serveur (un service externe). Chaque serveur MCP expose des tools que votre agent peut utiliser. Le protocole gère le transport, la sérialisation et la découverte des outils.

L’Agents SDK intègre nativement le support MCP. Vous pouvez connecter n’importe quel serveur MCP compatible.

Connecter un serveur MCP

Le SDK fournit la classe MCPServerStdio pour les serveurs locaux et MCPServerSse pour les serveurs distants :

from agents import Agent, Runner
from agents.mcp import MCPServerStdio

# Serveur MCP local (communique via stdin/stdout)
server_fichiers = MCPServerStdio(
    name="Gestionnaire de fichiers",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "/chemin/vers/dossier"],
)

async def main():
    async with server_fichiers:
        agent = Agent(
            name="Agent fichiers",
            instructions="Vous gérez des fichiers pour l'utilisateur.",
            mcp_servers=[server_fichiers],
        )
        result = await Runner.run(agent, "Liste les fichiers dans le dossier principal.")
        print(result.final_output)

Serveurs MCP distants via SSE

Pour les serveurs hébergés, utilisez le transport SSE (Server-Sent Events) :

from agents.mcp import MCPServerSse

server_github = MCPServerSse(
    name="GitHub",
    url="https://mcp.github.com/sse",
    headers={"Authorization": "Bearer ghp_votre_token"},
)

async def main():
    async with server_github:
        agent = Agent(
            name="Agent DevOps",
            instructions="Vous gérez les repositories GitHub.",
            mcp_servers=[server_github],
        )
        result = await Runner.run(
            agent,
            "Crée une issue dans le repo mon-projet avec le titre 'Bug critique'"
        )
        print(result.final_output)

Connecteurs OpenAI (Connectors)

En plus de MCP, OpenAI propose des connectors managés directement sur la plateforme. Ces connecteurs s’intègrent dans l’Agent Builder et sont utilisables via le SDK :

from agents import Agent, Runner

# Les connectors configurés dans l'Agent Builder sont automatiquement disponibles
agent = Agent(
    name="Agent CRM",
    instructions="""Vous êtes un assistant CRM. Utilisez les connecteurs
    pour accéder à Salesforce, HubSpot, et Google Workspace.""",
    model="gpt-5.3",
    # Les connectors sont liés à la configuration de l'agent sur la plateforme
)

Les connectors gèrent l’authentification OAuth, la pagination, et le rate limiting pour vous.

Combiner MCP et function tools

Vous pouvez mélanger des tools locaux et des serveurs MCP :

from agents import Agent, Runner, function_tool
from agents.mcp import MCPServerStdio

@function_tool
def calculer_facture(montant_ht: float, tva: float = 20.0) -> str:
    """Calcule le montant TTC d'une facture."""
    ttc = montant_ht * (1 + tva / 100)
    return f"Montant HT: {montant_ht}€, TVA {tva}%: {montant_ht * tva / 100:.2f}€, TTC: {ttc:.2f}€"

server_db = MCPServerStdio(
    name="Base de données",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/mydb"],
)

async def main():
    async with server_db:
        agent = Agent(
            name="Agent comptable",
            instructions="""Vous gérez la comptabilité.
            Utilisez la base de données pour les données clients
            et la fonction de calcul pour les factures.""",
            tools=[calculer_facture],
            mcp_servers=[server_db],
        )
        result = await Runner.run(
            agent,
            "Récupère les commandes du client Alice et calcule la facture totale"
        )
        print(result.final_output)

Filtrer les tools MCP

Un serveur MCP peut exposer de nombreux tools. Pour limiter ceux que votre agent utilise :

server = MCPServerStdio(
    name="GitHub",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-github"],
)

# Lors de la connexion, vous pouvez filtrer
async with server:
    tools = await server.list_tools()
    # Inspecter les tools disponibles
    for tool in tools:
        print(f"- {tool.name}: {tool.description}")

Gestion des erreurs MCP

Les connexions MCP peuvent échouer. Gérez les erreurs proprement :

from agents.mcp import MCPServerStdio

async def creer_agent_avec_mcp():
    server = MCPServerStdio(
        name="Service externe",
        command="npx",
        args=["-y", "mon-serveur-mcp"],
    )

    try:
        async with server:
            agent = Agent(
                name="Mon agent",
                instructions="Utilisez le service externe.",
                mcp_servers=[server],
            )
            result = await Runner.run(agent, "Exécutez la tâche.")
            return result.final_output
    except Exception as e:
        # Fallback sans MCP
        agent_fallback = Agent(
            name="Mon agent (mode dégradé)",
            instructions="Le service externe est indisponible. Informez l'utilisateur.",
        )
        result = await Runner.run(agent_fallback, "Le service est indisponible.")
        return result.final_output

Points clés à retenir

MCP est un protocole ouvert pour connecter des services externes à votre agent
MCPServerStdio pour les serveurs locaux, MCPServerSse pour les serveurs distants
Les connectors OpenAI sont des intégrations managées sur la plateforme
Vous pouvez combiner function tools et serveurs MCP dans le même agent
Gérez les erreurs de connexion MCP avec un mode dégradé