OAuth 2.0 pro servery MCP
Na této stránce
Aktualizace 2. listopadu 2026 — Le Chat je nyní Vibe. Od 28. května 2026 byl Le Chat přejmenován na Vibe (stále na chat.mistral.ai): jediný agent pro práci i kód, který si ponechává vaše konverzace, nastavení a předplatná. Původní prostředí Le Chat zůstává dostupné v režimu Chat; v režimu Work se agenti stali dovednostmi (vyvolávanými pomocí
@), paměť se nyní nazývá znalostní báze a hluboké vyhledávání je dovednost Deep Research. Plány se nyní jmenují Mistral Free, Pro, Team a Enterprise. Tato lekce používá název Vibe; některá zde popsaná menu mohla změnit názvy nebo umístění. Dodatek ze 3. listopadu: Předchozí příklad volal metodyrequires_auth,set_oauth_paramsneboget_token_from_auth_responsenaMCPClientStreamableHTTP, které však v SDKmistralaiverze 3.7.0 neexistují; nyní následuje oficiální příkladasync_conversation_run_mcp_remote_auth.pyvyužívajícíMCPClientSSE. Zdroj: client-python, MCP examples.
Proč OAuth v MCP?
Dokud váš server MCP pouze převádí měny nebo dotazuje veřejnou databázi, identita není problémem. Kritickým se stává v okamžiku, kdy server sahá po e-mailech, kalendářích, repozitářích GitHub nebo ticketech v Linearu: již nefunguje sám za sebe, ale jedná jménem konkrétního uživatele. Statický token ležící v konfiguračním souboru o tomto souhlasu nic neříká. Neudává, kdo co autorizoval, na jak dlouho ani jak daleko sahají udělená práva. OAuth 2.0 přesně zaplňuje tyto tři mezery: explicitní souhlas, práva omezená rozsahy (scopes) a bezpečné obnovování.
Vzpomeňme si na tři úrovně autentizace probírané dříve. První, žádná autentizace, vyhovuje veřejné URL bez citlivých dat. Druhá, statický token, odpovídá API klíči vygenerovanému ručně, jako je GitHub Personal Access Token. Třetí, OAuth 2.0, přidává celý tok souhlasu s rozsahy a obnovovacími tokeny. Přechod z druhé na třetí úroveň není otázkou technické vyspělosti, ale odpovědnosti: jakmile váš server využívá více lidí na svých vlastních datech, sdílený token se stává bezpečnostní dírou.
Jak tok funguje
Když uživatel připojí server MCP s OAuth ve Vibe, řetězí se sedm kroků. Stojí za to si je jednou provždy vizualizovat:
1. Uživatel klikne na „Připojit“ ve Vibe
↓
2. Vibe přesměruje na autorizační stránku služby
(např. GitHub, Google, Linear)
↓
3. Uživatel udělí požadovaná oprávnění (scopes)
↓
4. Služba vrátí autorizační kód zpět na callback
↓
5. Klient vymění kód za přístupový token + obnovovací token
↓
6. Přístupový token se použije pro každý volání MCP
↓
7. Když přístupový token vyprší, obnovovací token získá nový
V této choreografii cirkulují tři různé tokeny, které se často zaměňují. Autorizační kód je dočasný a jednorázový: okamžitě se vymění za skutečné tokeny. Přístupový token pak doprovází každý požadavek a žije krátce, typicky hodinu. Obnovovací token konečně slouží pouze k získání nového přístupového tokenu, aniž by bylo třeba znovu žádat uživatele o souhlas. Tato krátká životnost přístupového tokenu je pojistkou: pokud token unikne, okno pro jeho zneužití zůstává úzké.
Konfigurace OAuth na Python klientovi
SDK Mistral tento tok podporuje pomocí pomocné funkce build_oauth_params a několika metod klienta MCP. Dejte si pozor na výběr klienta: v SDK mistralai verze 3.7.0 existují tyto metody OAuth pouze u SSE klienta, MCPClientSSE, který oficiální příklad SDK používá se serverem Linear; MCPClientStreamableHTTP žádnou 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 otevřený: nic není třeba dělat
# 1. Objev OAuth endpointy serveru
# (a dynamicky zaregistruj klienta, pokud není poskytnuto 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. Sestav URL pro souhlas a otevři ji v prohlížeči
login_url, state = await mcp_client.get_auth_url_and_state(REDIRECT_URL)
print(f"Autorizuj přístup: {login_url}")
# 3. Zachyť callback a poté vyměň kód za token,
# pomocí klienta znovu vytvořeného z uložených OAuth parametrů
auth_response = await wait_for_callback() # malý lokální 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 dělá dvě a jen dvě věci: čte OAuth metadata publikovaná serverem MCP a dynamicky registruje klienta, pokud nepředáte ani client_id, ani client_secret. Zbytek toku je na vás – otevření URL pro souhlas, zachycení callbacku na portu vašeho redirect_url, výměna kódu za token. SDK tyto kroky neskrývá; poskytuje pro ně nástroje a právě toto rozdělení vám umožňuje napojit callback do webové aplikace místo skriptu.
Minimální privilegia aplikovaná na rozsahy (scopes)
Rozsahy definují, co může váš server dělat po udělení souhlasu, a obrazovka souhlasu je zobrazuje uživateli. Lákat může žádost o široká oprávnění: vyhnete se tak návratu, pokud vyvstane potřeba. Je to však nejlepší způsob, jak vyděsit obezřetného uživatele a zbytečně vystavit jeho účet účinkům. Porovnejte:
# Špatně: příliš mnoho oprávnění
scope=["repo", "admin:org", "delete_repo", "user"]
# Dobře: jen tolik, kolik stačí k vytváření issue
scope=["repo:issues", "read:user"]
Server, který vytváří issue, nemá žádný důvod mazat repozitáře nebo spravovat organizaci. Každá služba publikuje vlastní názvosloví rozsahů: konzultujte dokumentaci OAuth cílové služby, místo abyste tipovali podle analogie.
Ukládání a obnovování tokenů
Tokeny, které získáte, mají stejnou hodnotu jako pověření, která nahrazují, a zaslouží si stejnou péči. Zapište je do vyhrazeného souboru s omezenými systémovými oprávněními:
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čně 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))
# Omez oprávnění k souboru
os.chmod(TOKEN_FILE, 0o600)
chmod na 0o600 není dekorace: bez něj si na sdíleném stroji může váš token přečíst kterýkoli účet. Obnovování se mezitím redukuje na POST požadavek na token_url služby s obnovovacím tokenem v ruce. Uživatel nic nevidí probíhat, což je přesně pointa:
import httpx
async def refresh_access_token(
token_url: str,
client_id: str,
client_secret: str,
refresh_token: str,
) -> dict:
"""Obnov přístupový token pomocí obnovovacího 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()
Kdy stačí jednoduchý token
Ne každý server ospravedlňuje tento mechanismus. Pro interní nástroj využívaný hrstkou vývojářů funguje API klíč předaný v HTTP hlavičce naprosto dobře a klient MCP jej přijímá přímo:
from mistralai.extra.mcp.streamable_http import (
MCPClientStreamableHTTP,
StreamableHTTPServerParams,
)
# Server s jednoduchým tokenem
mcp_client = MCPClientStreamableHTTP(
params=StreamableHTTPServerParams(
url="https://my-server.com/mcp",
headers={"Authorization": "Bearer my_secret_api_token"},
timeout=60,
)
)
Na straně serveru se ověření vejde do middleware, který zachytí příslušné trasy, než dorazí k vaší obchodní logice:
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)
Co za vás vyřizuje Vibe
Ve Vibe mají přednastavené konektory – GitHub, Gmail, Linear – OAuth již zapojené: uživatel klikne, odsouhlasí a je hotovo. Pro vaše vlastní konektory nabízí konfigurace stejné tři možnosti popsané výše: Žádná autentizace pro veřejnou URL, Token, pokud klíč vložíte ručně, a OAuth 2.0 pro celý tok. Jeden detail má důležité praktické důsledky: token se ukládá na uživatele, nikoliv na organizaci. V týmu Mistral tedy každý člen projde vlastním souhlasem a pracuje s vlastními pověřeními – což zabraňuje tomu, aby odchod nebo odvolání přístupu jednoho člověka zlomilo přístup všem ostatním.
Klíčové poznatky
- OAuth 2.0 umožňuje explicitní souhlas s omezenými právy (scopes)
- Tok: autorizace → kód → tokeny (přístupový + obnovovací)
- Aplikuj princip minimálních privilegií na rozsahy
- Tokeny musí být bezpečně uloženy a automaticky obnovovány
- Pro jednoduché případy stačí statický token v HTTP hlavičkách
- Ve Vibe se tokeny ukládají na uživatele