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. Là où vous auriez écrit trois cents lignes de client GitHub, il reste une déclaration de serveur.

Qu’est-ce que MCP ?

MCP est un standard ouvert qui définit comment un client — votre agent — communique avec un serveur, c’est-à-dire un service externe. Chaque serveur MCP expose des tools que votre agent peut utiliser, et le protocole prend en charge le transport, la sérialisation et la découverte des outils. Cette dernière propriété est la plus utile au quotidien : l’agent interroge le serveur pour savoir ce qu’il sait faire, sans que vous ayez à maintenir une liste. L’Agents SDK intègre nativement le support MCP et se connecte à n’importe quel serveur compatible.

Connecter un serveur MCP

Le SDK fournit la classe MCPServerStdio pour les serveurs locaux, qui communiquent via stdin/stdout — typiquement un processus Node lancé par npx.

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)

Le async with n’est pas décoratif : il démarre le processus serveur, découvre ses tools, puis l’arrête proprement à la sortie du bloc. Un agent créé hors de ce contexte n’aura aucun outil.

Serveurs MCP distants via SSE

Pour les serveurs hébergés, utilisez MCPServerSse et le transport SSE (Server-Sent Events). La logique reste identique, seuls l’URL et les en-têtes d’authentification changent.

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. Ils s’intègrent dans l’Agent Builder et restent utilisables via le SDK, sans serveur à héberger de votre côté.

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.6-terra",
    # Les connectors sont liés à la configuration de l'agent sur la plateforme
)

L’absence de paramètre mcp_servers s’explique : les connectors sont liés à la configuration de l’agent sur la plateforme. Ils gèrent pour vous l’authentification OAuth, la pagination et le rate limiting, trois sujets qui consomment beaucoup de temps quand on les traite à la main.

Combiner MCP et function tools

Rien n’oblige à choisir. Un même agent peut disposer d’un serveur MCP pour accéder aux données et de vos propres fonctions pour la logique métier que vous ne voulez pas déléguer.

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)

Le calcul de TVA reste dans votre code, où il est testable et auditable ; la lecture des commandes passe par le serveur MCP PostgreSQL. C’est la répartition à viser.

Filtrer les tools MCP

Un serveur MCP peut exposer des dizaines de tools, dont la plupart ne concernent pas votre cas d’usage — et chacun consomme du contexte et augmente le risque d’un appel inapproprié. Commencez par inspecter ce qui est réellement disponible.

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

Un serveur MCP est un processus ou un service distant : il peut ne pas démarrer, perdre sa connexion ou expirer son token. Prévoyez un mode dégradé plutôt que de laisser l’exception remonter jusqu’à l’utilisateur.

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

L’agent de repli ne fait pas semblant de travailler : il annonce l’indisponibilité. Un agent qui invente une réponse quand sa source de données est coupée est bien plus coûteux qu’un agent qui admet son incapacité.

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é