Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Authentification et en-têtes

Paskaita 6 iš 12 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Prouve qui appelle
  2. Le paramètre authorization
  3. headers et extra_headers
  4. Une configuration de production complète
  5. Svarbiausi punktai

Prouve qui appelle

DeepWiki et d’autres serveurs MCP publics acceptent n’importe quel appelant, ce qui correspond à leur objectif. Dès que tu exposes tes propres outils, la donne change : sans authentification, quiconque devine l’URL peut interroger ton CRM ou déclencher tes processus. xAI fournit deux paramètres pour y remédier : authorization pour le jeton d’accès, et headers ou extra_headers pour tout le reste.

Le paramètre authorization

Il envoie un jeton d’authentification au serveur MCP. Concrètement, la chaîne que tu fournis est placée telle quelle dans l’en-tête HTTP Authorization de chaque requête envoyée à ce serveur.

mcp(
    server_url="https://api.example.com/mcp",
    server_label="internal",
    authorization="Bearer sk-your-token-here"
)

Le format attendu dépend entièrement du serveur cible, car authorization accepte n’importe quelle chaîne : c’est le serveur MCP qui la valide, pas xAI. Trois formes couvrent presque tous les cas que tu rencontreras.

  • Jeton Bearer : "Bearer sk-xxxx" — le plus courant, utilisé par la majorité des API REST
  • Clé API : "ApiKey your-key" — certains services utilisent un préfixe personnalisé
  • Authentification de base : "Basic base64(user:password)" — authentification de base encodée en base64

Puisque ce jeton accompagne chaque requête, sa manipulation exige de la prudence. Ne le code jamais en dur dans ta source : un secret écrit dans un fichier versionné finit inévitablement dans un dépôt, un journal ou une capture d’écran. Utilise toujours une variable d’environnement. Si le serveur le permet, privilégie un jeton scoped qui n’ouvre que les outils dont tu as réellement besoin : c’est le pendant côté serveur de la restriction allowed_tool_names. Et prévois une rotation régulière, surtout en production, où un jeton éternel est un jeton qui finira par fuiter.

import os

mcp(
    server_url="https://api.example.com/mcp",
    server_label="internal",
    authorization=f"Bearer {os.getenv('MCP_SERVER_TOKEN')}"
)

headers et extra_headers

Le jeton répond à la question « qui es-tu ». De nombreux serveurs ont besoin de réponses supplémentaires : pour quelle organisation, sur quel environnement, avec quelle version d’API. Ces informations transitent via le paramètre headers, ou extra_headers selon le SDK.

mcp(
    server_url="https://api.example.com/mcp",
    server_label="internal",
    authorization="Bearer sk-token",
    headers={
        "X-Organization-Id": "org-123",
        "X-Project-Id": "proj-456"
    }
)

Le cas le plus fréquent concerne les plateformes multi-locataires, où le même point de terminaison sert plusieurs clients et s’appuie sur un en-tête pour router la requête vers les bonnes données. Vient ensuite le versionnement de l’API, avec un en-tête comme "X-API-Version": "2024-01" qui fige une version spécifique et te protège des changements serveur. Certains systèmes attendent aussi des métadonnées de suivi — ID de session, ID d’agent — pour tracer l’origine des appels, ou des en-têtes de limitation de débit qui déterminent le plan de facturation appliqué.

Le nom du paramètre varie selon l’interface que tu utilises. Le SDK natif xAI utilise headers dans la plupart des cas ; l’API Responses au format OpenAI peut exiger extra_headers, pour éviter toute collision avec les en-têtes que ce SDK gère automatiquement pour lui-même. Le comportement est toutefois exactement le même : les en-têtes sont ajoutés à chaque requête vers le serveur MCP. Si tes requêtes partent sans tes en-têtes, vérifie d’abord ce nom de paramètre avant de chercher ailleurs.

Une configuration de production complète

Voici comment ces paramètres s’assemblent avec ceux des leçons précédentes, dans un cas réaliste de serveur interne.

from xai_sdk.tools import mcp
import os

tools = [
    mcp(
        server_url="https://api.monentreprise.com/mcp",
        server_label="internal",
        server_description="Internal tools: CRM, documentation, tickets",
        authorization=f"Bearer {os.getenv('INTERNAL_MCP_TOKEN')}",
        headers={
            "X-Organization-Id": os.getenv("ORG_ID"),
            "X-Environment": "production"
        },
        allowed_tool_names=["search_docs", "get_ticket", "search_contacts"]
    )
]

Cette configuration se connecte au serveur MCP interne via HTTPS, s’authentifie avec un jeton Bearer stocké dans une variable d’environnement, envoie l’ID de l’organisation dans un en-tête et restreint l’accès à trois opérations de lecture. Note que chaque ligne verrouille un aspect différent : le chiffrement protège le transport, le jeton prouve l’identité, l’en-tête définit le périmètre des données et la liste blanche limite les dégâts potentiels. Aucune de ces couches ne remplace les autres.

Svarbiausi punktai

  • authorization envoie le jeton d’accès au serveur MCP via l’en-tête HTTP Authorization
  • Stocke toujours tes jetons dans des variables d’environnement, jamais en dur dans le code
  • headers / extra_headers ajoutent des en-têtes HTTP supplémentaires à chaque requête
  • Les en-têtes servent à l’identification multi-locataire, au versionnement de l’API et au suivi
  • Combine authentification et restriction des outils pour une sécurité maximale