Aller au contenu principal

MCP et Connectors : le standard universel

MCP et Connectors : le standard universel

Le Model Context Protocol est un standard ouvert qui permet aux modèles d’interagir avec des services externes via un protocole unifié. Les Connectors d’OpenAI implémentent ce standard pour connecter les modèles à des outils tiers directement dans la Responses API.

Le problème que MCP résout

Le problème est celui du produit croisé : N modèles à connecter à M services demandent N×M intégrations, chacune à écrire et à maintenir. Chaque nouveau service impose de refaire le travail pour chaque application, et chaque changement d’API casse potentiellement plusieurs d’entre elles.

MCP transforme ce produit en somme : le service expose ses capacités une fois selon le protocole, et n’importe quel client compatible les consomme. C’est exactement le raisonnement qui a donné les pilotes d’imprimante ou le protocole LSP dans les éditeurs de code — la standardisation ne rend pas les intégrations plus puissantes, elle les rend économiquement soutenables.

# 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 capacités via un protocole standard, et le modèle les consomme directement.

Architecture MCP

Le protocole définit trois concepts :

  • Serveur MCP : un service qui expose des outils, des ressources et des prompts
  • Client MCP : le système qui consomme les capacités du serveur
  • Transport : le canal de communication entre client et serveur
# Un serveur MCP expose :
# - Tools : actions que le modèle peut exécuter
# - Resources : données que le modèle peut lire
# - Prompts : templates de prompts prédéfinies

Utiliser les Connectors OpenAI

Les Connectors sont des serveurs MCP déjà hébergés et maintenus : vous les déclarez, vous authentifiez, vous consommez. C’est la porte d’entrée naturelle — inutile d’écrire un serveur MCP pour parler à un service courant que quelqu’un a déjà connecté.

from openai import OpenAI

client = OpenAI()

# Exemple conceptuel : connecteur vers un service externe
response = client.responses.create(
    model="gpt-5.6-terra",
    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 paramètre require_approval contrôle la validation humaine :

  • "always" : chaque action nécessite une approbation
  • "never" : exécution automatique

Créer un serveur MCP en Python

Écrire son propre serveur devient intéressant dès qu’un service interne doit être joignable par plusieurs applications. Le raisonnement est le même que pour une API interne : on l’écrit une fois, proprement, avec ses règles d’accès — et toutes les applications en bénéficient sans que chacune réinvente sa couche d’intégration.

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

MCP distingue les outils, qui font quelque chose, et les ressources, qui donnent quelque chose à lire. La distinction est utile parce qu’elle porte le risque : une ressource se consulte sans effet de bord, un outil peut modifier l’état du monde. C’est sur les seconds que se concentre naturellement le contrôle d’approbation.

@server.resource("crm://pipeline")
async def pipeline_commercial() -> str:
    """État 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 à la Responses API

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

Pattern : hub multi-connecteurs

C’est là que le standard prend tout son sens : plusieurs serveurs déclarés côte à côte, et le modèle qui compose entre eux — lire un ticket ici, chercher un client là, écrire une réponse ailleurs. Sans protocole commun, ce même flux demanderait trois intégrations spécifiques et leur maintenance.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Vérifie 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"
        }
    ]
)

Sécurité et authentification

# Les serveurs MCP gèrent 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 clés à retenir

  • MCP est un standard ouvert pour connecter les modèles aux services externes
  • Les Connectors OpenAI intègrent MCP directement dans la Responses API
  • Créez vos propres serveurs MCP pour exposer vos services internes
  • Utilisez require_approval pour contrôler la validation humaine
  • Connectez plusieurs serveurs MCP dans un même appel pour des workflows transversaux
← Lecon precedenteTool Search : outils dynamiquesLecon suivante →Skills : encapsuler des capacités