Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

OAuth 2.0 għas-Servers MCP

Lezzjoni 8 / 14 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Għaliex OAuth f’MCP?
  2. Kif jaħdem il-fluss
  3. Konfigurazzjoni ta’ OAuth fuq il-klijent Python
  4. Privileġġ minimu, applikat għas-scopes
  5. Ħżin u tiġdid tat-tokens
  6. Meta token sempliċi jkun biżżejjed
  7. X’jittratta Vibe għalik
  8. Punti Ewlenin

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, jew get_token_from_auth_response fuq MCPClientStreamableHTTP, li m’għandux dawn il-metodi fl-SDK mistralai 3.7.0; issa jsegwi l-eżempju uffiċjali async_conversation_run_mcp_remote_auth.py, billi juża MCPClientSSE. 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