Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

OAuth 2.0 za strežnike MCP

Lekcija 8 od 14 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Zakaj OAuth v MCP?
  2. Kako poteka proces
  3. Konfiguracija OAuth na odjemalcu Python
  4. Najmanjši privilegiji, uporabljeni za obsege
  5. Shranjevanje in obnavljanje žetonov
  6. Kadar zadostuje preprost žeton
  7. Kaj Vibe opravi namesto tebe
  8. Ključne ugotovitve

Posodobitev 2. novembra 2026 — Le Chat je zdaj Vibe. Od 28. maja 2026 dalje je bil Le Chat preimenovan v Vibe (še vedno na chat.mistral.ai): en sam agent za delo in kodo, ki ohranja tvoja pogovora, nastavitve in naročnine. Stara izkušnja Le Chat ostaja dostopna v načinu Chat; v načinu Work so agenti postali veščine (priklicane z @), spomini so zdaj baza znanja, globoko iskanje pa veščina Deep Research. Načrti se zdaj imenujejo Mistral Free, Pro, Team in Enterprise. Ta lekcija uporablja ime Vibe; nekateri meniji, opisani tukaj, so morda spremenili imena ali lokacije. Dodatek 3. novembra: Prejšnji primer je klical requires_auth, set_oauth_params ali get_token_from_auth_response na MCPClientStreamableHTTP, ki v SDK mistralai različice 3.7.0 nima nobene od teh metod; zdaj sledi uradnemu primeru async_conversation_run_mcp_remote_auth.py, ki uporablja MCPClientSSE. Vir: client-python, MCP examples.

Zakaj OAuth v MCP?

Dokler tvoj strežnik MCP samo pretvarja valute ali poizveduje v javni bazi podatkov, identiteta ni težava. Postane ključna v trenutku, ko se strežnik dotakne e-pošte, koledarjev, repozitorijev GitHub ali kartic Linear: ne deluje več zase, ampak deluje v imenu določenega uporabnika. Statični žeton, ki čepi v konfiguracijski datoteki, o tem soglasju ne pove ničesar. Ne pove, kdo je kaj odobril, za kako dolgo in kako daleč segajo podeljene pravice. OAuth 2.0 naslavlja prav te tri vrzeli: izrecno soglasje, pravice, omejene z obsegi (scopes), in varno obnavljanje.

Spomni se treh ravni avtentikacije, obravnavanih prej. Prva, brez avtentikacije, ustreza javnemu URL-ju brez občutljivih podatkov. Druga, statični žeton, ustreza ključu API, ustvarjenemu ročno, kot je osebni dostopni žeton GitHub (Personal Access Token). Tretja, OAuth 2.0, doda celoten potek soglasja z obsegi in žetoni za osveževanje. Prehod z druge na tretjo raven ni stvar tehnične sofisticiranosti, ampak odgovornosti: ko tvoj strežnik uporablja več ljudi na svojih podatkih, skupni žeton postane varnostna luknja.

Kako poteka proces

Ko uporabnik v Vibeu poveže strežnik MCP z OAuth, se veriži sedem korakov. Vredno si jih je enkrat za vselej vizualizirati:

1. Uporabnik klikne "Connect" v Vibeu
       ↓
2. Vibe preusmeri na stran za avtorizacijo storitve
   (npr. GitHub, Google, Linear)
       ↓
3. Uporabnik odobri zahtevana dovoljenja (obsegi/scopes)
       ↓
4. Storitev vrne kodo za avtorizacijo povratnemu klicu (callback)
       ↓
5. Odjemalec zamenja kodo za žeton za dostop + žeton za osveževanje
       ↓
6. Žeton za dostop se uporabi za vsak klic MCP
       ↓
7. Ko žeton za dostop poteče, žeton za osveževanje pridobi novega

V tej koreografiji krožijo trije različni žetoni, ki jih pogosto zamenjujejo. Koda za avtorizacijo je začasna in za enkratno uporabo: takoj se zamenja za prave žetone. Žeton za dostop nato spremlja vsako zahtevo in živi kratko, običajno eno uro. Žeton za osveževanje nazadnje služi le pridobivanju novega žetona za dostop, ne da bi ponovno prosili uporabnika za soglasje. Ta kratka življenjska doba žetona za dostop je varnostni ukrep: če žeton uhaja, ostane okno za izkoriščanje ozko.

Konfiguracija OAuth na odjemalcu Python

SDK Mistral podpira ta potek s pomočnikom build_oauth_params in nekaj metodami odjemalca MCP. Bodite pozorni na izbiro odjemalca: v SDK mistralai različice 3.7.0 te metode OAuth obstajajo le na odjemalcu SSE, MCPClientSSE, ki ga uradni primer SDK uporablja s strežnikom Linear; MCPClientStreamableHTTP nima nobene od njih.

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  # Strežnik je odprt: ničesar ni treba storiti

    # 1. Odkrij končne točke OAuth strežnika
    #    (in dinamično registriraj odjemalca, če client_id ni podan)
    oauth_params = await build_oauth_params(
        mcp_client.base_url,
        redirect_url=REDIRECT_URL,
    )
    mcp_client.set_oauth_params(oauth_params=oauth_params)

    # 2. Sestavi URL za soglasje in ga odpri v brskalniku
    login_url, state = await mcp_client.get_auth_url_and_state(REDIRECT_URL)
    print(f"Avtoriziraj dostop: {login_url}")

    # 3. Ujemi povratni klic, nato zamenjaj kodo za žeton,
    #    z uporabo odjemalca, znova ustvarjenega iz shranjenih parametrov OAuth
    auth_response = await wait_for_callback()  # majhen lokalni HTTP strežnik
    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 naredi dve stvari in samo dve stvari: prebere metapodatke OAuth, ki jih objavi strežnik MCP, in dinamično registrira odjemalca, če ne podaš niti client_id niti client_secret. Preostanek poteka je prepuščen tebi – odpiranje URL-ja za soglasje, zbiranje povratnega klica na vratih tvoje redirect_url, zamenjava kode za žeton. SDK teh korakov ne skriva; opremi te z orodji zanje, in prav ta razčlenitev ti omogoča, da povratni klic vključiš v spletno aplikacijo namesto v skripto.

Najmanjši privilegiji, uporabljeni za obsege

Obsegi (scopes) opredeljujejo, kaj lahko tvoj strežnik stori, ko je soglasje dano, in zaslon za soglasje jih prikaže uporabniku. Široko zahtevanje je zapeljivo: izogneš se vračanju, če se pojavi potreba. Je pa tudi najboljši način, da prestrašiš previdnega uporabnika in nepotrebno izpostaviš njegov račun. Primerjaj:

# Slabo: preveč dovoljenj
scope=["repo", "admin:org", "delete_repo", "user"]

# Dobro: ravno dovolj za ustvarjanje težav (issues)
scope=["repo:issues", "read:user"]

Strežnik, ki ustvarja težave, nima razloga za brisanje repozitorijev ali upravljanje organizacije. Vsaka storitev objavlja svojo nomenklaturo obsegov: posvetuj se z dokumentacijo OAuth ciljne storitve, namesto da bi ugibal po analogiji.

Shranjevanje in obnavljanje žetonov

Žetoni, ki jih pridobiš, so vredni poverilnic, ki jih nadomeščajo, in zaslužijo enako skrb. Zapiši jih v namensko datoteko z omejenimi sistemskimi dovoljenji:

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):
    """Varno shrani žetone."""
    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))
    # Omeji dovoljenja datoteke
    os.chmod(TOKEN_FILE, 0o600)

chmod na 0o600 ni okrasen: brez njega lahko na souporabnem računalniku vsak račun prebere tvoje žetone. Obnavljanje se medtem zreducira na klic POST na token_url storitve z žetonom za osveževanje v roki. Uporabnik ne vidi ničesar, kar poteka, kar je ravno bistvo:

import httpx

async def refresh_access_token(
    token_url: str,
    client_id: str,
    client_secret: str,
    refresh_token: str,
) -> dict:
    """Obnovi žeton za dostop prek žetona za osveževanje."""
    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()

Kadar zadostuje preprost žeton

Ne vsak strežnik upravičuje ta mehanizem. Za interno orodje, ki ga uporablja peščica razvijalcev, ključ API, poslan v glavi HTTP, deluje povsem v redu, in odjemalec MCP ga sprejme neposredno:

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

# Strežnik s preprostim žetonom
mcp_client = MCPClientStreamableHTTP(
    params=StreamableHTTPServerParams(
        url="https://my-server.com/mcp",
        headers={"Authorization": "Bearer my_secret_api_token"},
        timeout=60,
    )
)

Na strani strežnika preverjanje sodi v vmesno programsko opremo (middleware), ki prestreže ustrezne poti, preden dosežejo tvojo poslovno logiko:

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)

Kaj Vibe opravi namesto tebe

V Vibeu prihajajo izpostavljeni konektorji – GitHub, Gmail, Linear – z že vklopljenim OAuth: uporabnik klikne, potrdi soglasje in opravljeno je. Za tvoje prilagojene konektorje konfiguracija ponuja iste tri zgoraj opisane možnosti: Brez avtentikacije za javni URL, Žeton, če ključ prilepiš ročno, in OAuth 2.0 za celoten potek. Ena podrobnost ima pomembne praktične posledice: žeton je shranjen na uporabnika, ne na organizacijo. V ekipi Mistral zato vsak član opravi svoje soglasje in dela s svojimi poverilnicami – kar prepreči, da bi odhod ali preklic prekinil dostop vsem.

Ključne ugotovitve

  • OAuth 2.0 omogoča izrecno soglasje z omejenimi pravicami (obsegi)
  • Potek: avtorizacija → koda → žetoni (dostop + osveževanje)
  • Uporabi načelo najmanjših privilegijev za obsege
  • Žetone je treba varno shraniti in samodejno obnavljati
  • Za preproste primere zadostuje statični žeton v glavah HTTP
  • V Vibeu so žetoni shranjeni na uporabnika