Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

OAuth 2.0 pre servery MCP

Lekcia 8 z 14 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Prečo OAuth v MCP?
  2. Ako tok funguje
  3. Konfigurácia OAuth v Python klientovi
  4. Minimálne privilégiá aplikované na rozsahy
  5. Ukladanie a obnova tokenov
  6. Keď stačí jednoduchý token
  7. Čo Vibe vybaví za teba
  8. Kľúčové poznatky

Aktualizácia z 2. novembra 2026 — Le Chat je teraz Vibe. Od 28. mája 2026 prešiel Le Chat rebrandingom na Vibe (stále na chat.mistral.ai): jediný agent pre prácu a kód, ktorý si zachováva tvoje konverzácie, nastavenia a predplatné. Pôvodné prostredie Le Chat zostáva dostupné v režime Chat; v režime Work sa agenti stali zručnosťami (vyvolávajú sa pomocou @), spomienky sú teraz znalostnou databázou a hĺbkové vyhľadávanie je zručnosťou Deep Research. Plány sa teraz nazývajú Mistral Free, Pro, Team a Enterprise. Táto lekcia používa názov Vibe; niektoré tu opísané ponuky mohli zmeniť názvy alebo umiestnenie. Dodatok z 3. novembra: Predchádzajúci príklad volal requires_auth, set_oauth_params alebo get_token_from_auth_response na MCPClientStreamableHTTP, čo sú metódy, ktoré SDK mistralai verzie 3.7.0 vôbec neobsahuje; teraz nasleduje oficiálny príklad async_conversation_run_mcp_remote_auth.py využívajúci MCPClientSSE. Zdroj: client-python, MCP examples.

Prečo OAuth v MCP?

Pokiaľ tvoj server MCP iba prevádza meny alebo dopytuje verejnú databázu, identita nie je problémom. Kritickým sa stáva v momente, keď server pracuje s e-mailmi, kalendármi, repozitármi GitHub alebo ticketmi v Lineare: už nefunguje sám za seba, ale koná menom konkrétneho používateľa. Statický token uložený v konfiguračnom súbore o tomto súhlase nič nehovorí. Neudáva, kto čo autorizoval, na ako dlho ani aký ďaleko siahajú udelené práva. OAuth 2.0 rieši presne tieto tri medzery: explicitný súhlas, práva obmedzené rozsahmi (scopes) a bezpečnú obnovu.

Spomeň si na tri úrovne autentifikácie, ktoré sme prebrali skôr. Prvá, žiadna autentifikácia, vyhovuje verejnej URL bez citlivých údajov. Druhá, statický token, zodpovedá API kľúču vygenerovanému manuálne, ako je GitHub Personal Access Token. Tretia, OAuth 2.0, pridáva celý tok súhlasu s rozsahmi a obnovovacími tokenmi. Prechod z druhej na tretiu úroveň nie je otázkou technickej vyspelosti, ale zodpovednosti: akonáhle tvoj server využíva viacero ľudí na svojich vlastných dátach, zdieľaný token sa stáva bezpečnostnou dierou.

Ako tok funguje

Keď používateľ pripojí server MCP s OAuth vo Vibe, prepojí sa sedem krokov. Stojí za to si ich raz navždy vizualizovať:

1. Používateľ klikne na „Pripojiť“ vo Vibe
       ↓
2. Vibe presmeruje na autorizačnú stránku služby
   (napr. GitHub, Google, Linear)
       ↓
3. Používateľ udelí požadované povolenia (rozsahy)
       ↓
4. Služba vráti autorizačný kód späť na callback URL
       ↓
5. Klient vymení kód za prístupový token + obnovovací token
       ↓
6. Prístupový token sa použije pri každom volaní MCP
       ↓
7. Keď prístupový token vyprší, obnovovací token získava nový

V tejto choreografii cirkulujú tri rôzne tokeny, ktoré sa často zamieňajú. Autorizačný kód je dočasný a jednorazový: okamžite sa vymení za skutočné tokeny. Prístupový token potom sprevádza každú požiadavku a žije krátko, zvyčajne hodinu. Obnovovací token napokon slúži len na získanie nového prístupového tokenu bez toho, aby sa používateľ musel znovu prihlasovať. Táto krátka životnosť prístupového tokenu je bezpečnostnou poistkou: ak token unikne, okno na jeho zneužitie zostáva úzke.

Konfigurácia OAuth v Python klientovi

Mistral SDK podporuje tento tok pomocou funkcie build_oauth_params a niekoľkých metód klienta MCP. Dávaj pozor na výber klienta: v SDK mistralai verzii 3.7.0 existujú tieto OAuth metódy len pre SSE klienta, MCPClientSSE, ktorý oficiálny príklad SDK používa so serverom Linear; MCPClientStreamableHTTP žiadnu z nich nemá.

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 je otvorený: nič netreba robiť

    # 1. Objav OAuth endpointy servera
    #    (a dynamicky zaregistruj klienta, ak nie je poskytnutý client_id)
    oauth_params = await build_oauth_params(
        mcp_client.base_url,
        redirect_url=REDIRECT_URL,
    )
    mcp_client.set_oauth_params(oauth_params=oauth_params)

    # 2. Vytvor URL súhlasu a otvor ju v prehliadači
    login_url, state = await mcp_client.get_auth_url_and_state(REDIRECT_URL)
    print(f"Autorizuj prístup: {login_url}")

    # 3. Zachyť callback a potom vymeň kód za token,
    #    pomocou klienta vytvoreného z uložených OAuth parametrov
    auth_response = await wait_for_callback()  # malý lokálny 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 robí dve veci a len dve veci: číta OAuth metadáta publikované serverom MCP a dynamicky registruje klienta, ak neposkytneš ani client_id, ani client_secret. Zvyšok toku je na tebe — otvorenie URL súhlasu, zachytenie callbacku na porte tvojej redirect_url, výmena kódu za token. SDK tieto kroky neskrýva; poskytuje na ne nástroje a práve toto rozdelenie ti umožňuje napojiť callback skôr do webovej aplikácie než do skriptu.

Minimálne privilégiá aplikované na rozsahy

Rozsahy (scopes) definujú, čo môže tvoj server robiť po udelení súhlasu, a obrazovka súhlasu ich zobrazuje používateľovi. Je lákavé pýtať sa broadly: vyhneš sa tak návratu, ak vznikne nová potreba. Je to však najlepší spôsob, ako vystrašiť opatrného používateľa a zbytočne vystaviť jeho účet riziku. Porovnaj:

# Zle: príliš veľa povolení
scope=["repo", "admin:org", "delete_repo", "user"]

# Dobre: len toľko, koľko stačí na vytváranie issue
scope=["repo:issues", "read:user"]

Server, ktorý vytvára issue, nemá dôvod mazať repozitáre alebo spravovať organizáciu. Každá služba publikuje vlastnú nomenklatúru rozsahov: konzultuj OAuth dokumentáciu cieľovej služby, namiesto toho, aby si hádal podľa analógie.

Ukladanie a obnova tokenov

Tokeny, ktoré získaš, majú hodnotu poverení, ktoré nahrádzajú, a zaslúžia si rovnakú starostlivosť. Zapíš ich do vyhradeného súboru s obmedzenými systémovými právami:

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):
    """Bezpečne ulož tokeny."""
    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))
    # Obmedz oprávnenia súboru
    os.chmod(TOKEN_FILE, 0o600)

Príkaz chmod na 0o600 nie je dekoratívny: bez neho si na zdieľanom stroji môžu tvoje tokeny prečítať akékoľvek účty. Obnova sa medzitým redukuje na POST volanie na token_url služby s obnovovacím tokenom v ruke. Používateľ nič nevidí prebiehať, čo je presne pointa:

import httpx

async def refresh_access_token(
    token_url: str,
    client_id: str,
    client_secret: str,
    refresh_token: str,
) -> dict:
    """Obnov prístupový token pomocou obnovovacieho tokenu."""
    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()

Keď stačí jednoduchý token

Nie každý server ospravedlňuje tento mechanizmus. Pre interný nástroj využívaný handfulom vývojárov stačí API kľúč odovzdaný v HTTP hlavičke a klient MCP ho prijíma priamo:

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

# Server s jednoduchým tokenom
mcp_client = MCPClientStreamableHTTP(
    params=StreamableHTTPServerParams(
        url="https://my-server.com/mcp",
        headers={"Authorization": "Bearer my_secret_api_token"},
        timeout=60,
    )
)

Na strane servera sa overenie zmestí do middleware, ktorý zachytí príslušné trasy skôr, než sa dostanú k tvojej business logike:

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)

Čo Vibe vybaví za teba

Vo Vibe majú featured konektory — GitHub, Gmail, Linear — OAuth už predpripravené: používateľ klikne, odsúhlasí a je vybavené. Pre tvoje vlastné konektory ponúka konfigurácia rovnaké tri možnosti opísané vyššie: Žiadna autentifikácia pre verejnú URL, Token, ak kľúč vložíš ručne, a OAuth 2.0 pre celý tok. Jeden detail má dôležité praktické dôsledky: token sa ukladá na používateľa, nie na organizáciu. V tíme Mistral preto každý člen prejde vlastným súhlasom a pracuje s vlastnými povereniami — čo zabraňuje tomu, aby odchod alebo odvolanie prístupov prerušilo prístup všetkým.

Kľúčové poznatky

  • OAuth 2.0 umožňuje explicitný súhlas s obmedzenými právami (rozsahmi)
  • Tok: autorizácia → kód → tokeny (prístupový + obnovovací)
  • Aplikuj zásadu minimálnych privilégií na rozsahy
  • Tokeny sa musia ukladať bezpečne a automaticky obnovovať
  • Pre jednoduché prípady stačí statický token v HTTP hlavičkách
  • Vo Vibe sa tokeny ukladajú na používateľa