MCP et Connectors : le standard universel

Le Model Context Protocol est un standard ouvert qui permet aux modeles d’interagir avec des services externes via un protocole unifie. Les Connectors d’OpenAI implementent ce standard pour connecter les modeles a des outils tiers directement dans la Responses API.

Le probleme que MCP resout

Sans MCP, chaque integration necessite du code personnalise :

# Avant MCP : integration manuelle pour chaque service
tools = [
    # Fonction pour Slack
    {"type": "function", "name": "slack_envoyer_message", ...},
    {"type": "function", "name": "slack_lire_channel", ...},
    # Fonction pour Jira
    {"type": "function", "name": "jira_creer_ticket", ...},
    {"type": "function", "name": "jira_lister_tickets", ...},
    # Fonction pour Google Drive
    {"type": "function", "name": "gdrive_lister_fichiers", ...},
    # ... des dizaines de fonctions a maintenir
]

Avec MCP, chaque service expose ses capacites via un protocole standard, et le modele les consomme directement.

Architecture MCP

Le protocole definit trois concepts :

Serveur MCP : un service qui expose des outils, des ressources et des prompts
Client MCP : le systeme qui consomme les capacites du serveur
Transport : le canal de communication entre client et serveur

# Un serveur MCP expose :
# - Tools : actions que le modele peut executer
# - Resources : donnees que le modele peut lire
# - Prompts : templates de prompts predefinies

Utiliser les Connectors OpenAI

OpenAI propose des connecteurs pre-integres pour des services populaires :

from openai import OpenAI

client = OpenAI()

# Exemple conceptuel : connecteur vers un service externe
response = client.responses.create(
    model="gpt-5.3",
    input="Cree un ticket Jira pour le bug de la page d'accueil",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.votre-serveur.com/jira",
            "require_approval": "always"
        }
    ]
)

Le parametre require_approval controle la validation humaine :

"always" : chaque action necessite une approbation
"never" : execution automatique

Creer un serveur MCP en Python

Vous pouvez creer vos propres serveurs MCP pour exposer vos services internes :

from mcp.server import Server
from mcp.types import Tool, TextContent
import json

server = Server("mon-crm")

@server.tool()
async def rechercher_client(terme: str, champ: str = "nom") -> str:
    """Rechercher un client dans le CRM interne.

    Args:
        terme: Le terme de recherche (nom, email ou ID)
        champ: Le champ dans lequel chercher (nom, email, id)
    """
    # Votre logique metier
    resultats = await crm_database.search(terme, field=champ)
    return json.dumps([{
        "id": r.id,
        "nom": r.nom,
        "email": r.email,
        "entreprise": r.entreprise
    } for r in resultats])

@server.tool()
async def creer_opportunite(
    client_id: str,
    titre: str,
    montant: float,
    probabilite: int
) -> str:
    """Creer une opportunite commerciale dans le CRM.

    Args:
        client_id: Identifiant du client
        titre: Titre de l'opportunite
        montant: Montant estime en euros
        probabilite: Probabilite de conclusion (0-100)
    """
    opp = await crm_database.create_opportunity(
        client_id=client_id,
        title=titre,
        amount=montant,
        probability=probabilite
    )
    return json.dumps({"id": opp.id, "statut": "cree"})

Exposer des ressources MCP

Les ressources permettent au modele de lire des donnees contextuelles :

@server.resource("crm://pipeline")
async def pipeline_commercial() -> str:
    """Etat actuel du pipeline commercial."""
    pipeline = await crm_database.get_pipeline()
    return json.dumps({
        "total_opportunites": pipeline.count,
        "valeur_totale": pipeline.total_value,
        "par_etape": {
            "prospection": pipeline.prospection,
            "qualification": pipeline.qualification,
            "proposition": pipeline.proposition,
            "negociation": pipeline.negociation,
            "cloture": pipeline.cloture
        }
    })

@server.resource("crm://client/{client_id}")
async def fiche_client(client_id: str) -> str:
    """Fiche complete d'un client."""
    client = await crm_database.get_client(client_id)
    return json.dumps({
        "nom": client.nom,
        "email": client.email,
        "historique_achats": client.purchases,
        "score_satisfaction": client.nps
    })

Connecter un serveur MCP a la Responses API

# Configuration du connecteur MCP dans l'appel API
response = client.responses.create(
    model="gpt-5.3",
    input="Quel est l'etat de notre pipeline commercial ? "
          "Cree une opportunite pour le client CLI-789 : "
          "migration cloud, 50000 euros, 70% de probabilite.",
    tools=[
        {
            "type": "mcp",
            "server_label": "crm-interne",
            "server_url": "https://mcp.interne.example.com/crm",
            "require_approval": "never"
        }
    ]
)

Pattern : hub multi-connecteurs

Connectez plusieurs services MCP dans un meme appel :

response = client.responses.create(
    model="gpt-5.3",
    input="Verifie les tickets Jira ouverts, envoie un resume sur Slack, "
          "et mets a jour le tableau de bord Notion",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.example.com/jira",
            "require_approval": "always"
        },
        {
            "type": "mcp",
            "server_label": "slack",
            "server_url": "https://mcp.example.com/slack",
            "require_approval": "always"
        },
        {
            "type": "mcp",
            "server_label": "notion",
            "server_url": "https://mcp.example.com/notion",
            "require_approval": "always"
        }
    ]
)

Securite et authentification

# Les serveurs MCP gerent l'authentification via des headers
# ou des tokens dans l'URL de configuration

# Bonne pratique : toujours require_approval pour les actions d'ecriture
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Validation humaine
        "allowed_tools": ["rechercher_client", "fiche_client"],  # Restreindre les outils
    }
]

Points cles a retenir

MCP est un standard ouvert pour connecter les modeles aux services externes
Les Connectors OpenAI integrent MCP directement dans la Responses API
Creez vos propres serveurs MCP pour exposer vos services internes
Utilisez require_approval pour controler la validation humaine
Connectez plusieurs serveurs MCP dans un meme appel pour des workflows transversaux