OAuth 2.0 għas-Servers MCP
F'din il-paġna
Aġġornament 2 ta’ Novembru, 2026 — Le Chat issa huwa Vibe. Mill-28 ta’ Mejju, 2026, Le Chat ġie mibdul għal Vibe (għadu f’chat.mistral.ai): aġent wieħed għax-xogħol u l-kodiċi, li jżomm il-konversazzjonijiet, l-issettjar u s-sottoskrizzjonijiet tiegħek. L-esperjenza antika ta’ Le Chat tibqa’ aċċessibbli fil-modalità Chat; fil-modalità Work, l-aġenti saru ħiliet (invokati b’
@), il-memorji saru l-bażi tal-għarfien, u t-tfittxija profonda hija l-ħila Deep Research. Il-pjanijiet issa jissejħu Mistral Free, Pro, Team, u Enterprise. Din il-lezzjoni tuża l-isem Vibe; xi menus deskritti hawnhekk jistgħu biddlu l-ismijiet jew il-postijiet tagħhom. Addendum 3 ta’ Novembru: L-eżempju preċedenti sejjaħrequires_auth,set_oauth_params, jewget_token_from_auth_responsefuqMCPClientStreamableHTTP, li m’għandux dawn il-metodi fl-SDKmistralai3.7.0; issa jsegwi l-eżempju uffiċjaliasync_conversation_run_mcp_remote_auth.py, billi jużaMCPClientSSE. Sors: client-python, MCP examples.
Għaliex OAuth f’MCP?
Sakemm is-server MCP tiegħek jikkonverti biss muniti jew jistaqsi bażi tad-data pubblika, l-identità mhix kwistjoni. Issir kritika fil-mument li s-server imiss emails, kalendari, repositories ta’ GitHub, jew tickets ta’ Linear: ma jaħdimx għalih innifsu, jaġixxi f’isem utent speċifiku. Token statiku li joqgħod f’fajl ta’ konfigurazzjoni ma jgħid xejn dwar dan il-kunsens. Ma jgħidx min awtorizza xiex, għal kemm żmien, jew sa fejn jestendu d-drittijiet mogħtija. OAuth 2.0 tindirizza eżattament dawn it-tliet lakuni: kunsens espliċitu, drittijiet limitati minn scopes, u tiġdid sigur.
Ftakar fit-tliet livelli ta’ awtentikazzjoni koperti qabel. L-ewwel, l-ebda awt, tajjeb għal URL pubbliku mingħajr data sensittiva. It-tieni, token statiku, jikkorrispondi għal API key iġġenerata manwalment, bħal GitHub Personal Access Token. It-tielet, OAuth 2.0, iżid il-fluss sħiħ tal-kunsens b’scopes u refresh tokens. Il-moviment mit-tieni għat-tielet livell mhuwiex dwar sofistikazzjoni teknika iżda dwar responsabbiltà: ladarba ħafna nies jużaw is-server tiegħek fuq id-data tagħhom stess, token kondivent isir toqba fis-sigurtà.
Kif jaħdem il-fluss
Meta utent jikkonnettja server MCP b’OAuth f’Vibe, seba’ passi jingħaqdu flimkien. Jiswa li tivviżwalizzahom darba għal dejjem:
1. L-utent jikklikkja "Connect" f'Vibe
↓
2. Vibe jirridirezzjona lejn il-paġna ta' awtorizzazzjoni tas-servizz
(eż. GitHub, Google, Linear)
↓
3. L-utent jagħti l-permessi mitluba (scopes)
↓
4. Is-servizz jirritorna kodiċi ta' awtorizzazzjoni lill-callback
↓
5. Il-klijent jiskambja l-kodiċi għal access token + refresh token
↓
6. L-access token jintuża għal kull sejħa MCP
↓
7. Meta l-access token jiskadi, ir-refresh token iġib wieħed ġdid
Tliet tokens differenti jiċċirkolaw f’din il-koreografija, u spiss jiġu konfużi. Il-kodiċi ta’ awtorizzazzjoni huwa temporanju u għal użu wieħed: jiġi skambjat immedjatament għat-tokens reali. L-access token imbagħad jakkumpanja kull talba u jgħix ftit, tipikament siegħa. Ir-refresh token, finalment, iservi biss biex jikseb access token ġdid mingħajr ma titlob lill-utent għal kunsens mill-ġdid. Din il-ħajja qasira tal-access token hija salvagwardja: jekk token jitħalla barra, it-tieqa ta’ sfruttament tiegħu tibqa’ dejqa.
Konfigurazzjoni ta’ OAuth fuq il-klijent Python
L-SDK ta’ Mistral jappoġġja dan il-fluss bl-għajnuna build_oauth_params u ftit metodi tal-klijent MCP. Ara liema klijent qed tuża: fl-SDK mistralai 3.7.0, dawn il-metodi OAuth jeżistu biss fuq il-klijent SSE, MCPClientSSE, li huwa dak li l-eżempju uffiċjali tal-SDK juża mas-server Linear; MCPClientStreamableHTTP m’għandux waħda minnhom.
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 # Is-server huwa miftuħ: xejn x'tagħmel
# 1. Skopri l-endpoints OAuth tas-server
# (u rreġistra l-klijent b'mod dinamiku jekk ma jingħatax 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. Ibni l-URL tal-kunsens u ftaħlu fil-browser
login_url, state = await mcp_client.get_auth_url_and_state(REDIRECT_URL)
print(f"Awtorizza l-aċċess: {login_url}")
# 3. Laqa' l-callback, imbagħad skambja l-kodiċi għal token,
# billi tuża klijent maħluq mill-ġdid mill-parametri OAuth salvati
auth_response = await wait_for_callback() # server HTTP lokali żgħir
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 tagħmel żewġ affarijiet u żewġ affarijiet biss: taqra l-metadejta OAuth ippubblikata mis-server MCP, u tirreġistra klijent b’mod dinamiku jekk ma tgħaddix la client_id u lanqas client_secret. Il-bqija tal-fluss tiddependi fuqek—tiftaħ l-URL tal-kunsens, tiġbor il-callback fuq il-port redirect_url tiegħek, tiskambja l-kodiċi għal token. L-SDK ma jaħbix dawn il-passi; jgħinek tagħmilhom, u eżattament din il-ħsara tippermettilek twaħħal il-callback f’web app minflok f’script.
Privileġġ minimu, applikat għas-scopes
Is-scopes jiddefinixxu x’jista’ jagħmel is-server tiegħek ladarba jingħata l-kunsens, u l-iskrin tal-kunsens jurihom lill-utent. Huwa tentanti li titlob b’mod wiesa’: dan jevita li tmur lura jekk tinħtieġ ħaġa. Huwa wkoll l-aħjar mod biex tibża’ utent kawt u tesponi l-kont tiegħu mingħajr bżonn. Qabbel:
# Ħażin: wisq permessi
scope=["repo", "admin:org", "delete_repo", "user"]
# Tajjeb: biżżejjed biss biex toħloq issues
scope=["repo:issues", "read:user"]
Server li joħloq issues m’għandux raġuni biex iħassar repositories jew jamministra l-organizzazzjoni. Kull servizz jippubblika n-nomenklatura tas-scopes tiegħu stess: ikkonsulta d-dokumentazzjoni OAuth tas-servizz fil-mira minflok ma tissuspetta b’analoġija.
Ħżin u tiġdid tat-tokens
It-tokens li tiksbu jiswew daqs il-kredenzjali li jissostitwixxu, u jistħoqqilhom l-istess kura. Iktebhom f’fajl dedikat b’permessi tas-sistema ristretti:
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):
"""Salva t-tokens b'mod sigur."""
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))
# Irrestrinġi l-permessi tal-fajl
os.chmod(TOKEN_FILE, 0o600)
Il-chmod għal 0o600 mhuwiex dekorattiv: mingħajru, fuq magna kondiviża, kwalunkwe kont jista’ jaqra t-tokens tiegħek. It-tiġdid, min-naħa l-oħra, jinżel għal sejħa POST lejn it-token_url tas-servizz bir-refresh token f’iddek. L-utent ma jara xejn jgħaddi, li huwa eżattament il-punt:
import httpx
async def refresh_access_token(
token_url: str,
client_id: str,
client_secret: str,
refresh_token: str,
) -> dict:
"""Ġedded l-access token permezz tar-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()
Meta token sempliċi jkun biżżejjed
Mhux kull server jiġġustifika din il-makkinarja. Għal għodda interna użata minn ftit żviluppaturi, API key mgħoddija f’header HTTP taħdem tajjeb ħafna, u l-klijent MCP jaċċettaha direttament:
from mistralai.extra.mcp.streamable_http import (
MCPClientStreamableHTTP,
StreamableHTTPServerParams,
)
# Server b'token sempliċi
mcp_client = MCPClientStreamableHTTP(
params=StreamableHTTPServerParams(
url="https://my-server.com/mcp",
headers={"Authorization": "Bearer my_secret_api_token"},
timeout=60,
)
)
Fuq in-naħa tas-server, il-verifika tidħol f’middleware li jinterċetta r-rotot rilevanti qabel ma jilħqu l-loġika tan-negozju tiegħek:
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)
X’jittratta Vibe għalik
F’Vibe, il-konnetturiFeatured—GitHub, Gmail, Linear—jiġu b’OAuth diġà konness: l-utent jikklikkja, jagħti l-kunsens, u lest. Għall-konnetturi personalizzati tiegħek, il-konfigurazzjoni toffri l-istess tliet għażliet deskritti hawn fuq: L-ebda awtentikazzjoni għal URL pubbliku, Token jekk twaħħal iċ-ċavetta bl-idejn, u OAuth 2.0 għall-fluss sħiħ. Dettall wieħed għandu konsegwenzi prattiċi importanti: it-token jinħażen kull utent, mhux kull organizzazzjoni. F’tim ta’ Mistral, għalhekk kull membru jgħaddi mill-kunsens tiegħu stess u jaħdem bil-kredenzjali tiegħu stess—li jipprevjeni li tluq jew revoka tkisser l-aċċess għal kulħadd.
Punti Ewlenin
- OAuth 2.0 jippermetti kunsens espliċitu b’drittijiet limitati (scopes)
- Il-fluss: awtorizzazzjoni → kodiċi → tokens (access + refresh)
- Applika l-prinċipju tal-privileġġ minimu għas-scopes
- It-tokens iridu jinħażnu b’mod sigur u jiġġeddu awtomatikament
- Għal każijiet sempliċi, token statiku f’headers HTTP jkun biżżejjed
- F’Vibe, it-tokens jinħażnu kull utent