Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

OAuth 2.0 do fhreastalaithe MCP

Ceacht 8 as 14 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Cén fáth a bhfuil OAuth i MCP?
  2. Conas a oibríonn an sruth
  3. OAuth a chumrú ar an gcliant Python
  4. An phribhléid is lú, curtha i bhfeidhm ar scóip
  5. Comharthaí a stóráil agus a athnuachan
  6. Nuair a leorann comhartha simplí
  7. Cad a láimhseálann Vibe duitse
  8. Príomhphointí

Nuashonrú 2 Samhain 2026 — Is é Vibe anois é Le Chat. Ón 28 Bealtaine 2026 i leith, rinneadh athbhrandáil ar Le Chat mar Vibe (fós ag chat.mistral.ai): gníomhaire amháin don obair agus don chód, ag coimeád do chuid comhráite, socruithe, agus síntiúis. Tá an t-eispéireas Le Chat traidisiúnta fós inrochtana sa mhód Chat; sa mhód Obair, tá scileanna tagtha in ionad gníomhairí (glaofar orthu le @), is é an bonn eolais na cuimhní cinn anois, agus is é an scil Taighde Doimhin an cuardach doimhin. Tugtar Mistral Free, Pro, Team, agus Enterprise ar na pleananna anois. Úsáideann an ceacht seo an t-ainm Vibe; d’fhéadfadh roinnt rochláir cur síos anseo a bheith athraithe ó thaobh ainmneacha nó suíomhanna de. Forlíonadh 3 Samhain: D’iarr an sampla roimhe seo requires_auth, set_oauth_params, nó get_token_from_auth_response ar MCPClientStreamableHTTP, nach bhfuil aon cheann de na modhanna sin aige sa SDK mistralai 3.7.0; leanann sé an sampla oifigiúil async_conversation_run_mcp_remote_auth.py anois, ag úsáid MCPClientSSE. Foinse: client-python, samplaí MCP.

Cén fáth a bhfuil OAuth i MCP?

Fad is nach ndéanann do fhreastalaí MCP ach airgeadraí a thiontú nó bunachar sonraí poiblí a chuardach, ní fadhb í an chéannacht. Éiríonn sé ríthábhachtach an tsoicind a théann an freastalaí i dteagmháil le ríomhphoist, féilirí, stórtha GitHub, nó ticéid Linear: ní oibríonn sé dó féin a thuilleadh, gníomhaíonn sé thar ceann úsáideora ar leith. Ní luaann comhartha statach i gcomhad cumraíochta faoin gcomhaontú seo. Ní luaíonn sé cé a d’údaraigh cad, ar feadh cé chomh fada, nó cé chomh fada is a shíneann na cearta deonaithe. Pléann OAuth 2.0 go díreach leis na trí bhearna seo: comhaontú sainráite, cearta teoranta de réir scóip, agus athnuachan slán.

Cuimhnigh ar na trí leibhéal fíordheimhniú a pléadh cheana. An chéad cheann, gan fíordheimhniú, oiriúnach d’URL poiblí gan aon sonraí íogaire. An dara ceann, comhartha statach, freagraíonn sé d’eochair API a ghintear de láimh, cosúil le Comhartha Rochtana Pearsanta GitHub. An tríú ceann, OAuth 2.0, cuireann sé an sruth comhaontaithe iomlán leis scóip agus comharthaí athnuachana. Ní bhaineann an bogadh ón dara leibhéal go dtí an tríú leibhéal le sóifistictheacht theicniúil ach le freagracht: nuair a úsáideann daoine iolracha do fhreastalaí ar a gcuid sonraí féin, déanann comhartha roinnte poll slándála de.

Conas a oibríonn an sruth

Nuair a nascann úsáideoir freastalaí MCP le OAuth i Vibe, bíonn seacht gcéim nasctha le chéile. Fiú iad a shamhlú uair amháin agus do gach uile:

1. Cliceálann an t-úsáideoir "Nasc" i Vibe
       ↓
2. Atreoraíonn Vibe go dtí leathanach údaraithe an tseirbhís
   (m.sh. GitHub, Google, Linear)
       ↓
3. Deonaíonn an t-úsáideoir na ceadanna a iarradh (scóip)
       ↓
4. Seolann an tseirbhís cód údaraithe ar ais chuig an aisghlao
       ↓
5. Malartaíonn an cliant an cód le haghaidh comhartha rochtana + comhartha athnuachana
       ↓
6. Úsáidtear an comhartha rochtana do gach glaonna MCP
       ↓
7. Nuair a théann an comhartha rochtana in éag, faigheann an comhartha athnuachana ceann nua

Cuairclíonn trí chomhartha éagsúla sa choreagrafaíocht seo, agus bíonn mearbhall orthu go minic. Is sealadach agus d’aon úsáid amháin an cód údaraithe: malartaítear láithreach é le haghaidh na gcomharthaí fíor. Ansin bíonn an comhartha rochtana i ngach iarratas agus mairfidh sé go hachomair, uair an chloig de ghnáth. Ar deireadh, ní úsáidtear an comhartha athnuachana ach chun comhartha rochtana nua a fháil gan iarraidh ar an úsáideoir comhaontú arís. Is cosaint é saolré gairid an chomhartha rochtana: má sceitheann comhartha, fanann an fhuinneog leasaithe cúng.

OAuth a chumrú ar an gcliant Python

Tacaíonn an SDK Mistral leis an sruth seo leis an segabhálaí build_oauth_params agus cúpla modh cliant MCP. Bí airdeallach ar do rogha cliant: sa SDK mistralai 3.7.0, níl na modhanna OAuth seo ann ach ar an gcliant SSE, MCPClientSSE, rud a úsáideann sampla oifigiúil an SDK leis an bhfreastalaí Linear; níl aon cheann acu ag MCPClientStreamableHTTP.

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  # Freastalaí oscailte: gan dad le déanamh

    # 1. Faigh pointí deiridh OAuth an fhreastalaí amach
    #    (agus cláraigh an cliant go dinimiciúil mura soláthraítear 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. Tóg an URL comhaontaithe agus oscail é sa bhrabhsálaí
    login_url, state = await mcp_client.get_auth_url_and_state(REDIRECT_URL)
    print(f"Údaraigh rochtain: {login_url}")

    # 3. Gabh an t-aisghlao, ansin malartaigh an cód le comhartha,
    #    ag úsáid cliant athchruthaithe ó na paraiméadair OAuth shábháilte
    auth_response = await wait_for_callback()  # freastalaí HTTP beag áitiúil
    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

Déanann build_oauth_params dhá rud agus dhá rud amháin: léann sé meiteashonraí OAuth a fhoilsíonn an freastalaí MCP, agus cláraíonn sé cliant go dinimiciúil mura dtugann tú client_id ná client_secret seachad. Is fútse an chuid eile den sruth—oscail an URL comhaontaithe, bailigh an t-aisghlao ar do phort redirect_url, malartaigh an cód le comhartha. Ní cheileann an SDK na céimeanna seo; cuireann sé uirlisí ar fáil dóibh, agus ligeann an briseadh síos cruinn seo duit an t-aisghlao a nascadh le feidhmchlár gréasáin seachas script.

An phribhléid is lú, curtha i bhfeidhm ar scóip

Sainíonn scóip cad is féidir le do fhreastalaí a dhéanamh nuair a thugtar comhaontú, agus taispeántar iad don úsáideoir ar an scáileán comhaontaithe. Is mór an temptacht iarratas a dhéanamh go forleathan: seachnaíonn sé dul siar má thagann riachtanas chun cinn. Is é an bealach is fearr chun úsáideoir cúramach a scanrú agus a chuntas a nochtadh gan ghá freisin é. Déan comparáid:

# Droch: ró-mhórán ceadanna
scope=["repo", "admin:org", "delete_repo", "user"]

# Maith: díreach go leor chun saincheisteanna a chruthú
scope=["repo:issues", "read:user"]

Níl aon chúis le freastalaí a chruthaíonn saincheisteanna stórtha a scriosadh nó an eagraíocht a riar. Foilsíonn gach seirbhís a nómainclatúr scóip féin: comhairligh doiciméadacht OAuth na seirbhíse sprioc seachas buille faoi thuairim a dhéanamh trí analaí.

Comharthaí a stóráil agus a athnuachan

Is fiú na comharthaí a fhaigheann tú na dintiúir a athsholáthraíonn siad, agus tuilltear an chúram céanna dóibh. Scríobh iad chuig comhad tiomnaithe le ceadanna córais srianta:

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):
    """Sábháil comharthaí go slán."""
    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))
    # Srian ceadanna comhaid
    os.chmod(TOKEN_FILE, 0o600)

Níl an chmod go 0o600 maisiúil: gan é, ar mheaisín roinnte, is féidir le haon chuntas do chomharthaí a léamh. Maidir le hathnuachan, tagann sé anuas ar ghlao POST chuig token_url na seirbhíse leis an gcomhartha athnuachana i do sheilbh. Ní fheiceann an t-úsáideoir aon rud ag dul thart, rud atá díreach mar is ceart:

import httpx

async def refresh_access_token(
    token_url: str,
    client_id: str,
    client_secret: str,
    refresh_token: str,
) -> dict:
    """Athnuachan an chomhartha rochtana tríd an gcomhartha athnuachana."""
    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()

Nuair a leorann comhartha simplí

Ní gá don innealra seo gach freastalaí. Maidir le huirlis inmheánach a úsáideann cúpla forbróir, oibríonn eochair API a sheoltar i gceanntásc HTTP go maith, agus glacann an cliant MCP leis go díreach:

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

# Freastalaí le comhartha simplí
mcp_client = MCPClientStreamableHTTP(
    params=StreamableHTTPServerParams(
        url="https://my-server.com/mcp",
        headers={"Authorization": "Bearer my_secret_api_token"},
        timeout=60,
    )
)

Ar thaobh an fhreastalaí, oiriúnaíonn an fíorú i meánbhogearraí a idirghabhálann na bealaí ábhartha sula sroicheann siad do loighic gnó:

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)

Cad a láimhseálann Vibe duitse

I Vibe, tá OAuth ceangailte cheana féin le connectors feiceálacha—GitHub, Gmail, Linear: cliceálann an t-úsáideoir, tugann sé comhaontú, agus tá sé déanta. I gcás do chuid connectors saincheaptha, tairgeann an chumraíocht na trí rogha céanna a tuairiscíodh thuas: Gan fíordheimhniú d’URL poiblí, Comhartha má ghreamaíonn tú an eochair de láimh, agus OAuth 2.0 don sruth iomlán. Tá tábhacht phraiticiúil ag baint le mionsonra amháin: stóráiltear an comhartha in aghaidh an úsáideora, ní in aghaidh na heagraíochta. I bhfoireann Mistral, téann gach ball trína chomhaontú féin dá bhrí sin agus oibríonn sé lena chuid dintiúir féin—rud a choscann ar imeacht nó ar chúlghairm rochtain a bhriseadh do chách.

Príomhphointí

  • Cumasaíonn OAuth 2.0 comhaontú sainráite le cearta teoranta (scóip)
  • An sruth: údarú → cód → comharthaí (rochtain + athnuachan)
  • Cuir prionsabal na pribhléide is lú i bhfeidhm ar scóip
  • Caithfear comharthaí a stóráil go slán agus a athnuachan go huathoibríoch
  • I gcásanna simplí, leorann comhartha statach i gceanntásca HTTP
  • I Vibe, stóráiltear comharthaí in aghaidh an úsáideora