Récapitulatif et mise en pratique

Ce que vous avez appris

Ce cours vous a guidé à travers l’ensemble du MCP distant avec Grok, du concept fondamental jusqu’à la configuration en production. Voici un récapitulatif structuré de chaque domaine couvert.

Le MCP en une phrase

Le Model Context Protocol permet à Grok de se connecter à des serveurs d’outils externes via HTTPS, découvrant et utilisant automatiquement les outils exposés sans configuration manuelle côté client.

Architecture et transports

• Le MCP distant fonctionne exclusivement sur HTTPS (pas de HTTP, localhost ou stdio)
• Deux transports supportés : Streaming HTTP (moderne, stateless) et SSE (connexion persistante)
• Le transport est déterminé par le serveur MCP, pas par votre configuration
• Trois SDK supportés : xAI natif (recommandé), OpenAI Responses (compatibilité), Voice Agent (vocal)

Les six paramètres de configuration

Checklist de mise en production

Avant de déployer une configuration MCP en production, vérifiez chaque point :

Sécurité

• Les URL sont en HTTPS avec certificats valides
• Chaque serveur interne a un token d’authentification
• Les tokens sont stockés en variables d’environnement
• Les outils sont restreints avec allowed_tool_names au minimum nécessaire
• Les tokens sont programmés pour une rotation régulière

Configuration

• Chaque serveur a un server_label unique et descriptif
• Les server_description sont précises et à jour
• Le nombre total d’outils est raisonnable (visez 10-20 max par session)
• Les serveurs inutiles sont retirés de la configuration

Monitoring

• Les appels d’outils sont tracés dans vos logs
• Les erreurs de connexion MCP sont alertées
• L’utilisation des tokens par serveur est surveillée
• La latence des appels MCP est mesurée

Mise en pratique : votre premier agent MCP

Pour passer de la théorie à la pratique, voici un exercice progressif.

Étape 1 — Serveur public

Commencez par connecter Grok à DeepWiki, un serveur MCP public sans authentification :

from xai_sdk import Client
from xai_sdk.tools import mcp
import os

client = Client(api_key=os.getenv("XAI_API_KEY"))

chat = client.chat.create(
    model="grok-4.20-reasoning",
    tools=[
        mcp(
            server_url="https://mcp.deepwiki.com/mcp",
            server_label="deepwiki"
        )
    ],
)

Testez avec des requêtes comme “Explique-moi l’architecture du projet fastapi/fastapi”.

Étape 2 — Ajout d’outils natifs

Enrichissez votre agent en ajoutant la recherche web :

tools=[
    mcp(
        server_url="https://mcp.deepwiki.com/mcp",
        server_label="deepwiki",
        server_description="Documentation de projets GitHub open-source"
    ),
    {"type": "web_search"},
]

Étape 3 — Multi-serveur avec authentification

Quand vous aurez un serveur MCP interne, ajoutez-le avec authentification et restriction :

tools=[
    mcp(server_url="https://mcp.deepwiki.com/mcp", server_label="deepwiki"),
    mcp(
        server_url="https://api.votre-serveur.com/mcp",
        server_label="interne",
        server_description="Données et outils internes de l'entreprise",
        authorization=f"Bearer {os.getenv('INTERNAL_TOKEN')}",
        allowed_tool_names=["search", "get_document"]
    ),
    {"type": "web_search"},
]

Limitations à garder en tête

• L’API Responses (format OpenAI) ne supporte pas require_approval ni connector_id
• Le transport stdio (serveurs MCP locaux) n’est pas supporté — HTTPS uniquement
• Chaque outil consomme du contexte — surveillez la charge totale
• La latence réseau s’ajoute à chaque appel d’outil MCP distant

Points clés à retenir

• Le MCP distant connecte Grok à des outils externes via HTTPS en quelques lignes de configuration
• Six paramètres suffisent pour configurer un serveur MCP (deux obligatoires, quatre optionnels)
• La sécurité repose sur le trio HTTPS + authentification + restriction d’outils
• Commencez par un serveur public (DeepWiki) puis progressez vers le multi-serveur authentifié
• Combinez MCP et outils natifs pour créer des agents polyvalents