Spring til hovedindhold
Dansk— Vælg et sprog
Menu

OAuth 2.0 til MCP-servere

Lektion 8 af 14 Opdateret 3. november 2026 Udvikler
På denne side
  1. Hvorfor OAuth i MCP?
  2. Hvordan flowet fungerer
  3. Konfiguration af OAuth på Python-klienten
  4. Mindste privilegium, anvendt på scopes
  5. Lagring og fornyelse af tokens
  6. Når et simpelt token er nok
  7. Hvad Vibe håndterer for dig
  8. Vigtige pointer

Opdatering 2. november 2026 — Le Chat er nu Vibe. Fra den 28. maj 2026 er Le Chat blevet omdøbt til Vibe (stadig på chat.mistral.ai): en enkelt agent til arbejde og kode, der viderefører dine samtaler, indstillinger og abonnementer. Den ældre Le Chat-oplevelse er stadig tilgængelig i Chat-tilstand; i Work-tilstand er agenter blevet til færdigheder (kaldes med @), hukommelse er nu vidensbasen, og dyb søgning er færdigheden Deep Research. Abonnementerne hedder nu Mistral Free, Pro, Team og Enterprise. Denne lektion bruger navnet Vibe; nogle menuer beskrevet her kan have ændret navn eller placering. Tillæg 3. november: Det tidligere eksempel kaldte requires_auth, set_oauth_params eller get_token_from_auth_response på MCPClientStreamableHTTP, som ikke har nogen af disse metoder i mistralai SDK 3.7.0; det følger nu det officielle eksempel async_conversation_run_mcp_remote_auth.py, der bruger MCPClientSSE. Kilde: client-python, MCP examples.

Hvorfor OAuth i MCP?

Så længe din MCP-server kun konverterer valutaer eller spørger en offentlig database, er identitet ikke et problem. Det bliver kritisk i det øjeblik, serveren rører ved e-mails, kalendere, GitHub-repositories eller Linear-billetter: den arbejder ikke længere for sig selv, men handler på vegne af en specifik bruger. Et statisk token, der ligger i en konfigurationsfil, siger intet om dette samtykke. Det fortæller ikke, hvem der har godkendt hvad, hvor længe, eller hvor langt de tildelte rettigheder rækker. OAuth 2.0 adresserer præcis disse tre huller: eksplicit samtykke, rettigheder begrænset af scopes og sikker fornyelse.

Husk på de tre autentificeringsniveauer, vi dækkede tidligere. Det første, ingen auth, passer til en offentlig URL uden følsomme data. Det andet, statisk token, svarer til en API-nøgle genereret manuelt, som en GitHub Personal Access Token. Det tredje, OAuth 2.0, tilføjer hele samtykkeflowet med scopes og refresh-tokens. At rykke fra det andet til det tredje niveau handler ikke om teknisk sofistikering, men om ansvar: når flere personer bruger din server på deres egne data, bliver et delt token et sikkerhedshul.

Hvordan flowet fungerer

Når en bruger forbinder en MCP-server med OAuth i Vibe, kædes syv trin sammen. Det er værd at visualisere dem én gang for alle:

1. Brugeren klikker på "Connect" i Vibe
       ↓
2. Vibe omdirigerer til tjenestens autorisationsside
   (f.eks. GitHub, Google, Linear)
       ↓
3. Brugeren giver de anmodede tilladelser (scopes)
       ↓
4. Tjenesten returnerer en autorisationskode til callback'en
       ↓
5. Klienten bytter koden mod et access-token + refresh-token
       ↓
6. Access-tokenet bruges til hvert MCP-kald
       ↓
7. Når access-tokenet udløber, skaffer refresh-tokenet et nyt

Tre forskellige tokens cirkulerer i denne koreografi, og de bliver ofte forvekslet. Autorisationskoden er midlertidig og kan kun bruges én gang: den byttes straks til de rigtige tokens. Access-tokenet ledsager derefter hver anmodning og lever kort, typisk en time. Refresh-tokenet endelig bruges kun til at skaffe et nyt access-token uden at bede brugeren om samtykke igen. Denne korte levetid for access-tokenet er en sikkerhedsforanstaltning: hvis et token lækker, forbliver vinduet for udnyttelse smalt.

Konfiguration af OAuth på Python-klienten

Mistral SDK understøtter dette flow med hjælperen build_oauth_params og et par MCP-klientmetoder. Pas på dit klientvalg: i mistralai SDK 3.7.0 findes disse OAuth-metoder kun på SSE-klienten, MCPClientSSE, hvilket er det, SDK’ets officielle eksempel bruger med Linear-serveren; MCPClientStreamableHTTP har ingen af dem.

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  # Serveren er åben: intet at gøre

    # 1. Opdag serverens OAuth-endpoints
    #    (og registrer klienten dynamisk, hvis ingen client_id er angivet)
    oauth_params = await build_oauth_params(
        mcp_client.base_url,
        redirect_url=REDIRECT_URL,
    )
    mcp_client.set_oauth_params(oauth_params=oauth_params)

    # 2. Byg samtykke-URL'en og åbn den i browseren
    login_url, state = await mcp_client.get_auth_url_and_state(REDIRECT_URL)
    print(f"Godkend adgang: {login_url}")

    # 3. Fang callback'en, og byt derefter koden mod et token,
    #    ved hjælp af en klient genoprettet fra de gemte OAuth-parametre
    auth_response = await wait_for_callback()  # lille lokal 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 gør to ting og kun to ting: den læser OAuth-metadata udgivet af MCP-serveren, og den registrerer dynamisk en klient, hvis du hverken sender client_id eller client_secret. Resten af flowet overlades til dig – at åbne samtykke-URL’en, indsamle callback’en på din redirect_url-port, og bytte koden mod et token. SDK’et skjuler ikke disse trin; det værktøjsdanner dem, og netop denne opdeling lader dig forbinde callback’en til en webapp frem for et script.

Mindste privilegium, anvendt på scopes

Scopes definerer, hvad din server kan gøre, når samtykke er givet, og samtykkeskærmen viser dem for brugeren. Det er fristende at anmode bredt: det undgår tilbagevendende arbejde, hvis et behov opstår. Det er også den bedste måde at skræmme en forsigtig bruger væk og unødigt eksponere deres konto. Sammenlign:

# Dårligt: for mange tilladelser
scope=["repo", "admin:org", "delete_repo", "user"]

# Godt: lige nok til at oprette issues
scope=["repo:issues", "read:user"]

En server, der opretter issues, har ingen grund til at slette repositories eller administrere organisationen. Hver tjeneste publicerer sin egen scope-navngivning: konsulter mål-tjenestens OAuth-dokumentation i stedet for at gætte ved analogi.

Lagring og fornyelse af tokens

De tokens, du opnår, er lige så meget værd som de legitimationsoplysninger, de erstatter, og fortjener samme omhu. Skriv dem til en dedikeret fil med begrænsede systemtilladelser:

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):
    """Gem tokens sikkert."""
    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))
    # Begræns filtilladelser
    os.chmod(TOKEN_FILE, 0o600)

chmod til 0o600 er ikke dekorativt: uden det kan enhver konto på en delt maskine læse dine tokens. Fornyelse reduceres i mellemtiden til et POST-kald til tjenestens token_url med refresh-tokenet i hånden. Brugeren ser intet passere, hvilket er netop pointen:

import httpx

async def refresh_access_token(
    token_url: str,
    client_id: str,
    client_secret: str,
    refresh_token: str,
) -> dict:
    """Forny access-tokenet via refresh-tokenet."""
    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()

Når et simpelt token er nok

Ikke enhver server berettiger dette maskineri. Til et internt værktøj, der bruges af en håndfuld udviklere, fungerer en API-nøgle sendt i en HTTP-header fint, og MCP-klienten accepterer den direkte:

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

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

På serversiden passer verifikationen ind i en middleware, der afbryder de relevante ruter, før de når din forretningslogik:

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)

Hvad Vibe håndterer for dig

I Vibe kommer fremhævede connectors – GitHub, Gmail, Linear – med OAuth allerede forbundet: brugeren klikker, giver samtykke, og så er det gjort. Til dine egne connectors tilbyder konfigurationen de samme tre muligheder beskrevet ovenfor: Ingen autentificering til en offentlig URL, Token, hvis du indsætter nøglen manuelt, og OAuth 2.0 til det fulde flow. Én detalje har vigtige praktiske konsekvenser: tokenet gemmes pr. bruger, ikke pr. organisation. I et Mistral-team gennemgår hvert medlem derfor sit eget samtykke og arbejder med sine egne legitimationsoplysninger – hvilket forhindrer, at en afgang eller tilbagekaldelse bryder adgangen for alle.

Vigtige pointer

  • OAuth 2.0 muliggør eksplicit samtykke med begrænsede rettigheder (scopes)
  • Flowet: autorisation → kode → tokens (access + refresh)
  • Anvend princippet om mindste privilegium på scopes
  • Tokens skal gemmes sikkert og fornyes automatisk
  • Til simple tilfælde er et statisk token i HTTP-headers nok
  • I Vibe gemmes tokens pr. bruger