Lähe põhisisu juurde
Eesti— Vali keel
Menüü

OAuth 2.0 pour les serveurs MCP

Õppetund 8 / 14 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Pourquoi OAuth dans MCP ?
  2. Comment fonctionne le flux
  3. Configuration d’OAuth sur le client Python
  4. Le moindre privilège, appliqué aux scopes
  5. Stockage et renouvellement des jetons
  6. Quand un simple jeton suffit
  7. Ce que Vibe gère pour vous
  8. Peamised punktid

Mise à jour du 2 novembre 2026 — Le Chat devient Vibe. Depuis le 28 mai 2026, Le Chat a été rebaptisé Vibe (toujours sur chat.mistral.ai) : un agent unique pour le travail et le code, conservant vos conversations, paramètres et abonnements. L’expérience historique de Le Chat reste accessible en mode Chat ; en mode Work, les agents sont devenus des compétences (appelées avec @), les mémoires constituent désormais la base de connaissances, et la recherche approfondie est la compétence Deep Research. Les formules s’appellent désormais Mistral Free, Pro, Team et Enterprise. Cette leçon utilise le nom Vibe ; certains menus décrits ici peuvent avoir changé de nom ou d’emplacement. Addendum du 3 novembre : L’exemple précédent appelait requires_auth, set_oauth_params ou get_token_from_auth_response sur MCPClientStreamableHTTP, qui ne possède aucune de ces méthodes dans le SDK mistralai 3.7.0 ; il suit désormais l’exemple officiel async_conversation_run_mcp_remote_auth.py, en utilisant MCPClientSSE. Source : client-python, exemples MCP.

Pourquoi OAuth dans MCP ?

Tant que votre serveur MCP se contente de convertir des devises ou d’interroger une base de données publique, l’identité n’est pas un problème. Cela devient critique dès que le serveur touche aux e-mails, aux calendriers, aux dépôts GitHub ou aux tickets Linear : il ne travaille plus pour lui-même, il agit pour le compte d’un utilisateur spécifique. Un jeton statique dormant dans un fichier de configuration ne dit rien de ce consentement. Il n’indique pas qui a autorisé quoi, pour combien de temps, ni jusqu’où s’étendent les droits accordés. OAuth 2.0 comble exactement ces trois lacunes : consentement explicite, droits limités par des scopes et renouvellement sécurisé.

Rappelez-vous les trois niveaux d’authentification abordés précédemment. Le premier, pas d’authentification, convient à une URL publique sans données sensibles. Le deuxième, jeton statique, correspond à une clé API générée manuellement, comme un jeton d’accès personnel GitHub. Le troisième, OAuth 2.0, ajoute le flux complet de consentement avec des scopes et des jetons de rafraîchissement. Passer du deuxième au troisième niveau ne relève pas de la sophistication technique, mais de la responsabilité : dès que plusieurs personnes utilisent votre serveur sur leurs propres données, un jeton partagé devient une faille de sécurité.

Comment fonctionne le flux

Lorsqu’un utilisateur connecte un serveur MCP avec OAuth dans Vibe, sept étapes s’enchaînent. Il vaut la peine de les visualiser une fois pour toutes :

1. L'utilisateur clique sur "Connecter" dans Vibe
       ↓
2. Vibe redirige vers la page d'autorisation du service
   (par ex. GitHub, Google, Linear)
       ↓
3. L'utilisateur accorde les permissions demandées (scopes)
       ↓
4. Le service renvoie un code d'autorisation au callback
       ↓
5. Le client échange le code contre un jeton d'accès + un jeton de rafraîchissement
       ↓
6. Le jeton d'accès est utilisé pour chaque appel MCP
       ↓
7. Lorsque le jeton d'accès expire, le jeton de rafraîchissement en obtient un nouveau

Trois jetons différents circulent dans cette chorégraphie, et on les confond souvent. Le code d’autorisation est temporaire et à usage unique : il est échangé immédiatement contre les vrais jetons. Le jeton d’accès accompagne ensuite chaque requête et vit brièvement, typiquement une heure. Le jeton de rafraîchissement, enfin, sert uniquement à obtenir un nouveau jeton d’accès sans demander à nouveau le consentement de l’utilisateur. Cette courte durée de vie du jeton d’accès est une mesure de sécurité : si un jeton fuit, sa fenêtre d’exploitation reste étroite.

Configuration d’OAuth sur le client Python

Le SDK Mistral prend en charge ce flux avec l’assistant build_oauth_params et quelques méthodes du client MCP. Soyez vigilant sur le choix de votre client : dans le SDK mistralai 3.7.0, ces méthodes OAuth existent uniquement sur le client SSE, MCPClientSSE, que l’exemple officiel du SDK utilise avec le serveur Linear ; MCPClientStreamableHTTP n’en possède aucune.

from mistralai.extra.mcp.auth import build_oauth_params
from mistralai.extra.mcp.sse import MCPClientSSE, SSEServerParams

REDIRECT_URL = "http://localhost:16010/oauth/callback"
SERVER_URL = "https://mcp.linear.app/sse"

mcp_client = MCPClientSSE(sse_params=SSEServerParams(url=SERVER_URL))

async def connect():
    global mcp_client
    if not await mcp_client.requires_auth():
        return mcp_client  # Le serveur est ouvert : rien à faire

    # 1. Découvrir les points de terminaison OAuth du serveur
    #    (et enregistrer dynamiquement le client si aucun client_id n'est fourni)
    oauth_params = await build_oauth_params(
        mcp_client.base_url,
        redirect_url=REDIRECT_URL,
    )
    mcp_client.set_oauth_params(oauth_params=oauth_params)

    # 2. Construire l'URL de consentement et l'ouvrir dans le navigateur
    login_url, state = await mcp_client.get_auth_url_and_state(REDIRECT_URL)
    print(f"Autoriser l'accès : {login_url}")

    # 3. Intercepter le callback, puis échanger le code contre un jeton,
    #    en utilisant un client recréé à partir des paramètres OAuth sauvegardés
    auth_response = await wait_for_callback()  # petit serveur HTTP local
    mcp_client = MCPClientSSE(sse_params=SSEServerParams(url=SERVER_URL), oauth_params=oauth_params)
    token = await mcp_client.get_token_from_auth_response(
        auth_response["url"],
        redirect_url=REDIRECT_URL,
        state=state,
    )
    mcp_client.set_auth_token(token)
    return mcp_client

build_oauth_params fait deux choses et rien d’autre : il lit les métadonnées OAuth publiées par le serveur MCP, et il enregistre dynamiquement un client si vous ne passez ni client_id ni client_secret. Le reste du flux vous incombe : ouvrir l’URL de consentement, collecter le callback sur votre port redirect_url, échanger le code contre un jeton. Le SDK ne masque pas ces étapes ; il les outille, et c’est précisément cette décomposition qui vous permet de brancher le callback sur une application web plutôt que sur un script.

Le moindre privilège, appliqué aux scopes

Les scopes définissent ce que votre serveur peut faire une fois le consentement accordé, et l’écran de consentement les affiche à l’utilisateur. Il est tentant de demander largement : cela évite de revenir en arrière si un besoin survient. C’est aussi le meilleur moyen d’effrayer un utilisateur prudent et d’exposer inutilement son compte. Comparez :

# Mauvais : trop de permissions
scope=["repo", "admin:org", "delete_repo", "user"]

# Bon : juste assez pour créer des issues
scope=["repo:issues", "read:user"]

Un serveur qui crée des issues n’a aucune raison de supprimer des dépôts ou d’administrer l’organisation. Chaque service publie sa propre nomenclature de scopes : consultez la documentation OAuth du service cible plutôt que de deviner par analogie.

Stockage et renouvellement des jetons

Les jetons que vous obtenez valent les identifiants qu’ils remplacent et méritent le même soin. Écrivez-les dans un fichier dédié avec des permissions système restreintes :

import os
import json
from pathlib import Path

TOKEN_FILE = Path.home() / ".mcp" / "tokens.json"

def save_tokens(service: str, access_token: str, refresh_token: str):
    """Sauvegarde sécurisée des jetons."""
    TOKEN_FILE.parent.mkdir(parents=True, exist_ok=True)
    tokens = {}
    if TOKEN_FILE.exists():
        tokens = json.loads(TOKEN_FILE.read_text())
    tokens[service] = {
        "access_token": access_token,
        "refresh_token": refresh_token,
    }
    TOKEN_FILE.write_text(json.dumps(tokens))
    # Restreindre les permissions du fichier
    os.chmod(TOKEN_FILE, 0o600)

Le chmod à 0o600 n’est pas décoratif : sans lui, sur une machine partagée, n’importe quel compte peut lire vos jetons. Le renouvellement, quant à lui, se résume à un appel POST à l’URL token_url du service avec le jeton de rafraîchissement en main. L’utilisateur ne voit rien passer, ce qui est précisément le but :

import httpx

async def refresh_access_token(
    token_url: str,
    client_id: str,
    client_secret: str,
    refresh_token: str,
) -> dict:
    """Renouvelle le jeton d'accès via le jeton de rafraîchissement."""
    async with httpx.AsyncClient() as http:
        response = await http.post(
            token_url,
            data={
                "grant_type": "refresh_token",
                "refresh_token": refresh_token,
                "client_id": client_id,
                "client_secret": client_secret,
            },
        )
        response.raise_for_status()
        return response.json()

Quand un simple jeton suffit

Tous les serveurs ne justifient pas cette machinerie. Pour un outil interne consommé par une poignée de développeurs, une clé API passée dans un en-tête HTTP fonctionne très bien, et le client MCP l’accepte directement :

from mistralai.extra.mcp.streamable_http import (
    MCPClientStreamableHTTP,
    StreamableHTTPServerParams,
)

# Serveur avec simple jeton
mcp_client = MCPClientStreamableHTTP(
    params=StreamableHTTPServerParams(
        url="https://my-server.com/mcp",
        headers={"Authorization": "Bearer my_secret_api_token"},
        timeout=60,
    )
)

Côté serveur, la vérification tient dans un middleware qui intercepte les routes concernées avant qu’elles n’atteignent votre logique métier :

from fastapi import FastAPI, Request, HTTPException

api = FastAPI()

@api.middleware("http")
async def verify_token(request: Request, call_next):
    if request.url.path.startswith("/mcp"):
        token = request.headers.get("Authorization", "")
        if token != "Bearer my_secret_api_token":
            raise HTTPException(status_code=401, detail="Unauthorized")
    return await call_next(request)

Ce que Vibe gère pour vous

Dans Vibe, les connecteurs vedettes — GitHub, Gmail, Linear — sont livrés avec OAuth déjà câblé : l’utilisateur clique, consent, et c’est fini. Pour vos connecteurs personnalisés, la configuration offre les mêmes trois options décrites ci-dessus : Pas d’authentification pour une URL publique, Jeton si vous collez la clé à la main, et OAuth 2.0 pour le flux complet. Un détail a d’importantes conséquences pratiques : le jeton est stocké par utilisateur, et non par organisation. Dans une équipe Mistral, chaque membre passe donc par son propre consentement et travaille avec ses propres identifiants — ce qui empêche un départ ou une révocation de bloquer l’accès pour tout le monde.

Peamised punktid

  • OAuth 2.0 permet un consentement explicite avec des droits limités (scopes)
  • Le flux : autorisation → code → jetons (accès + rafraîchissement)
  • Appliquez le principe du moindre privilège aux scopes
  • Les jetons doivent être stockés de manière sécurisée et renouvelés automatiquement
  • Pour les cas simples, un jeton statique dans les en-têtes HTTP suffit
  • Dans Vibe, les jetons sont stockés par utilisateur