Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

OAuth 2.0 für MCP-Server

Lektion 8 von 14 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Warum OAuth in MCP?
  2. Wie der Ablauf funktioniert
  3. OAuth auf dem Python-Client konfigurieren
  4. Least Privilege, angewendet auf Scopes
  5. Speichern und Erneuern von Tokens
  6. Wenn ein einfacher Token ausreicht
  7. Was Vibe für Sie übernimmt
  8. Kernaussagen

Update vom 2. November 2026 — Le Chat ist nun Vibe. Seit dem 28. Mai 2026 wurde Le Chat in Vibe umbenannt (immer noch unter chat.mistral.ai): ein einzelner Agent für Arbeit und Code, der Ihre Gespräche, Einstellungen und Abonnements übernimmt. Die klassische Le Chat-Erfahrung bleibt im Chat-Modus verfügbar; im Work-Modus sind Agenten zu Fähigkeiten geworden (mit @ aufgerufen), Erinnerungen bilden nun die Wissensbasis und die Deep Search ist die Fähigkeit Deep Research. Pläne werden nun Mistral Free, Pro, Team und Enterprise genannt. Diese Lektion verwendet den Namen Vibe; einige hier beschriebene Menüs können andere Namen oder Standorte haben. Ergänzung vom 3. November: Das vorherige Beispiel rief requires_auth, set_oauth_params oder get_token_from_auth_response auf MCPClientStreamableHTTP auf, was in der mistralai SDK 3.7.0 keine dieser Methoden hat; es folgt nun dem offiziellen Beispiel async_conversation_run_mcp_remote_auth.py unter Verwendung von MCPClientSSE. Quelle: client-python, MCP-Beispiele.

Warum OAuth in MCP?

Solange Ihr MCP-Server nur Währungen umrechnet oder eine öffentliche Datenbank abfragt, ist Identität kein Problem. Es wird kritisch, sobald der Server E-Mails, Kalender, GitHub-Repositories oder Linear-Tickets berührt: Er arbeitet nicht mehr für sich selbst, sondern im Namen eines bestimmten Benutzers. Ein statischer Token in einer Konfigurationsdatei sagt nichts über diese Zustimmung aus. Er verrät nicht, wer was genehmigt hat, für wie lange oder wie weit die erteilten Rechte reichen. OAuth 2.0 schließt genau diese drei Lücken: explizite Zustimmung, Rechte, die durch Scopes begrenzt sind, und sichere Erneuerung.

Erinnern Sie sich an die drei Authentifizierungsebenen, die zuvor behandelt wurden. Die erste, keine Authentifizierung, eignet sich für eine öffentliche URL ohne sensible Daten. Die zweite, statischer Token, entspricht einem API-Schlüssel, der manuell generiert wurde, wie ein GitHub Personal Access Token. Die dritte, OAuth 2.0, fügt den vollständigen Zustimmungsablauf mit Scopes und Refresh-Tokens hinzu. Der Übergang von der zweiten zur dritten Ebene geht nicht um technische Raffinesse, sondern um Verantwortung: Sobald mehrere Personen Ihren Server auf ihren eigenen Daten nutzen, wird ein geteilter Token zu einer Sicherheitslücke.

Wie der Ablauf funktioniert

Wenn ein Benutzer einen MCP-Server mit OAuth in Vibe verbindet, verketten sich sieben Schritte. Es lohnt sich, sie einmal und für alle Zeit zu visualisieren:

1. Benutzer klickt "Verbinden" in Vibe
       ↓
2. Vibe leitet an die Autorisierungsseite des Dienstes weiter
   (z. B. GitHub, Google, Linear)
       ↓
3. Benutzer gewährt die angeforderten Berechtigungen (Scopes)
       ↓
4. Dienst sendet einen Autorisierungscode an den Callback zurück
       ↓
5. Client tauscht den Code gegen einen Zugriffstoken + Refresh-Token ein
       ↓
6. Zugriffstoken wird für jeden MCP-Aufruf verwendet
       ↓
7. Wenn das Zugriffstoken abläuft, erhält der Refresh-Token ein neues

In dieser Choreografie kreisen drei verschiedene Token, die oft verwechselt werden. Der Autorisierungscode ist temporär und einmalig gültig: Er wird sofort gegen die echten Token eingetauscht. Der Zugriffstoken begleitet dann jeden Aufruf und lebt kurz, typischerweise eine Stunde. Der Refresh-Token dient schließlich nur dazu, einen neuen Zugriffstoken zu erhalten, ohne den Benutzer erneut um Zustimmung zu bitten. Diese kurze Lebensdauer des Zugriffstokens ist eine Sicherheitsmaßnahme: Wenn ein Token geleakt wird, bleibt das Fenster für die Ausbeutung schmal.

OAuth auf dem Python-Client konfigurieren

Die Mistral SDK unterstützt diesen Ablauf mit dem Helfer build_oauth_params und einigen MCP-Client-Methoden. Achten Sie auf Ihre Client-Wahl: In der mistralai SDK 3.7.0 existieren diese OAuth-Methoden nur beim SSE-Client, MCPClientSSE, den das offizielle Beispiel der SDK mit dem Linear-Server verwendet; MCPClientStreamableHTTP hat keine davon.

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  # Server ist offen: nichts zu tun

    # 1. Entdecken Sie die OAuth-Endpunkte des Servers
    #    (und registrieren Sie den Client dynamisch, wenn kein client_id angegeben wurde)
    oauth_params = await build_oauth_params(
        mcp_client.base_url,
        redirect_url=REDIRECT_URL,
    )
    mcp_client.set_oauth_params(oauth_params=oauth_params)

    # 2. Erstellen Sie die Zustimmung-URL und öffnen Sie sie im Browser
    login_url, state = await mcp_client.get_auth_url_and_state(REDIRECT_URL)
    print(f"Zugriff autorisieren: {login_url}")

    # 3. Fangen Sie den Callback ab, tauschen Sie dann den Code gegen einen Token ein,
    #    indem Sie einen Client neu erstellen, der aus den gespeicherten OAuth-Parametern erstellt wurde
    auth_response = await wait_for_callback()  # kleiner lokaler HTTP-Server
    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 tut zwei Dinge und nur zwei Dinge: Es liest die OAuth-Metadaten, die vom MCP-Server veröffentlicht werden, und registriert den Client dynamisch, wenn Sie weder client_id noch client_secret übergeben. Der Rest des Ablaufs liegt in Ihrer Hand – die Zustimmung-URL öffnen, den Callback auf Ihrem redirect_url-Port sammeln, den Code gegen einen Token tauschen. Die SDK verbirgt diese Schritte nicht; es instrumentiert sie, und genau diese Aufschlüsselung ermöglicht es Ihnen, den Callback in eine Webanwendung statt in ein Skript einzubinden.

Least Privilege, angewendet auf Scopes

Scopes definieren, was Ihr Server tun kann, sobald Zustimmung erteilt wurde, und der Zustimmungsbildschirm zeigt sie dem Benutzer an. Weit gefasst zu fragen ist verlockend: Es vermeidet Rückfragen, falls ein Bedarf entsteht. Es ist auch der beste Weg, um einen vorsichtigen Benutzer zu erschrecken und sein Konto unnötig zu gefährden. Vergleichen Sie:

# Schlecht: zu viele Berechtigungen
scope=["repo", "admin:org", "delete_repo", "user"]

# Gut: genau das Nötigste, um Issues zu erstellen
scope=["repo:issues", "read:user"]

Ein Server, der Issues erstellt, hat keinen Grund, Repositories zu löschen oder die Organisation zu verwalten. Jeder Dienst veröffentlicht seine eigene Scopes-Nomenklatur: Konsultieren Sie die OAuth-Dokumentation des Zielservices, anstatt durch Analogie zu raten.

Speichern und Erneuern von Tokens

Die von Ihnen erhaltenen Token sind wertvoll, da sie Credentials ersetzen, und verdienen die gleiche Sorgfalt. Schreiben Sie sie in eine dedizierte Datei mit eingeschränkten Systemberechtigungen:

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):
    """Speichern Sie Tokens sicher."""
    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))
    # Dateiberechtigungen einschränken
    os.chmod(TOKEN_FILE, 0o600)

Das chmod auf 0o600 ist nicht dekorativ: Ohne es kann auf einer geteilten Maschine jeder Account Ihre Tokens lesen. Die Erneuerung reduziert sich meanwhile auf einen POST-Aufruf an den token_url des Dienstes mit dem Refresh-Token in der Hand. Der Benutzer sieht nichts passieren, was genau der Punkt ist:

import httpx

async def refresh_access_token(
    token_url: str,
    client_id: str,
    client_secret: str,
    refresh_token: str,
) -> dict:
    """Erneuern Sie den Zugriffstoken über den Refresh-Token."""
    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()

Wenn ein einfacher Token ausreicht

Nicht jeder Server rechtfertigt diese Mechanismen. Für ein internes Werkzeug, das von einer Handvoll Entwickler genutzt wird, funktioniert ein API-Schlüssel, der in einem HTTP-Header übergeben wird, ganz gut, und der MCP-Client akzeptiert ihn direkt:

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

# Server mit einfachem Token
mcp_client = MCPClientStreamableHTTP(
    params=StreamableHTTPServerParams(
        url="https://my-server.com/mcp",
        headers={"Authorization": "Bearer my_secret_api_token"},
        timeout=60,
    )
)

Auf der Server-Seite passt die Verifizierung in eine Middleware, die die relevanten Routen vor ihrem Erreichen Ihrer Geschäftslogik abfängt:

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)

Was Vibe für Sie übernimmt

In Vibe kommen Featured-Connectors wie GitHub, Gmail und Linear mit OAuth bereits verkabelt: Der Benutzer klickt, stimmt zu, und es ist erledigt. Für Ihre benutzerdefinierten Connectors bietet die Konfiguration die gleichen drei Optionen wie oben beschrieben: Keine Authentifizierung für eine öffentliche URL, Token, wenn Sie den Schlüssel manuell einfügen, und OAuth 2.0 für den vollständigen Ablauf. Eine Einzelheit hat wichtige praktische Konsequenzen: Der Token wird pro Benutzer gespeichert, nicht pro Organisation. In einem Mistral-Team durchläuft daher jedes Mitglied seine eigene Zustimmung und arbeitet mit eigenen Credentials – was verhindert, dass ein Ausscheiden oder eine Widerrufung den Zugriff für alle unterbricht.

Kernaussagen

  • OAuth 2.0 ermöglicht explizite Zustimmung mit begrenzten Rechten (Scopes)
  • Der Ablauf: Autorisierung → Code → Tokens (Zugriff + Erneuerung)
  • Das Prinzip der geringsten Rechte auf Scopes anwenden
  • Tokens müssen sicher gespeichert und automatisch erneuert werden
  • Für einfache Fälle reicht ein statischer Token in HTTP-Headern
  • In Vibe werden Tokens pro Benutzer gespeichert