Celoten primer: Oddaljeni strežnik z avtentikacijo
Na tej strani
Posodobitev 2. november 2026 — Le Chat je zdaj Vibe. Od 28. maja 2026 dalje je bil Le Chat preimenovan v Vibe (še vedno na chat.mistral.ai): en sam agent za delo in kodo, ki ohranja vaša pogovora, nastavitve in naročnine. Stara izkušnja Le Chat ostaja dostopna v načinu Chat; v načinu Work so agenti zdaj veščine (priklicane z
@), spomini služijo kot baza znanja, globoko iskanje pa je veščina Deep Research. Načrti se zdaj imenujejo Mistral Free, Pro, Team in Enterprise. Ta lekcija uporablja ime Vibe; nekateri meniji, opisani tukaj, so morda spremenili imena ali lokacije. Dodatek 3. november: rezultatirun_asyncse berejo izresult.output_as_text; SDKmistralairazličice 3.7.0 nima atributaoutput.
Posodobitev 2. november 2026 — MCP Python SDK v2. Ta tečaj zdaj sledi različici 2 paketa SDK
mcp(2.3.0 z dne 2. oktober 2026):MCPServernadomeščaFastMCP, nastavitve prenosa se premaknejo vrun()alistreamable_http_app(), aplikacija, izpostavljena pod realnim gostiteljskim imenom, pa mora to ime deklarirati (transport_security). To je tudi različica, ki jo zahteva Mistral SDK: dodatekmistralai[agents]zahtevamcp>=2.2.0,<3.0. Viri: Kaj je novega v v2 · Vodnik za selitev · Namestitev in skaliranje.
Scenarij: Strežnik MCP za upravljanje opravil
Prejšnje lekcije so pokrivale posamezne dele: HTTP prenos, vmesno programsko opremo (middleware) in avtentikacijo s žetoni. Zdaj jih boste združili v popolnoma funkcionalen projekt. Strežnik razkriva štiri orodja za upravljanje opravil – ustvari, naštej, zaključi, izbriši – odjemalec pa se poveže oddaljeno in pri vsaki zahtevi predloži nosilni žeton (bearer token). Ta isti strežnik bo nato zagnan iz Vibea brez niti ene dodatne vrstice kode: v tem je celotna prednost oddaljenega strežnika pred strežnikom STDIO.
Strežnik: task_server.py
V tej enojni datoteki sobivajo trije elementi. FastAPI obravnava HTTP prenos in vmesno programsko opremo za avtentikacijo, MCPServer obravnava protokol MCP in orodja, slovar Python pa služi kot baza podatkov. Vrstni red datoteke je pomemben: najprej deklarirajte strežnik MCP in njegova orodja, nato ustvarite aplikacijo FastAPI z lifespan, ki zažene upravitelja seje, in nazadnje namestite (mount) strežnik. Upoštevajte, da vmesna programska oprema ščiti pot /tasks, kamor je nameščen strežnik MCP: ti dve vrednosti se morata ujemati, sicer boste končali bodisi z odprtimi vrati bodisi z zazidano potjo.
# task_server.py
"""Oddaljeni strežnik MCP z avtentikacijo žetona."""
import json
import os
import uuid
from contextlib import asynccontextmanager
from datetime import datetime
from fastapi import FastAPI, Request, HTTPException
from mcp.server.mcpserver import MCPServer
from mcp.server.transport_security import TransportSecuritySettings
# --- Konfiguracija ---
API_TOKEN = "mcp-secret-token-2026"
# --- Baza podatkov v pomnilniku ---
tasks_db: dict[str, dict] = {}
# --- Strežnik MCP ---
mcp = MCPServer("Task Manager")
@mcp.tool()
def create_task(title: str, description: str = "", priority: str = "medium") -> str:
"""Ustvari novo opravilo v upravitelju.
Args:
title: Naslov opravila (obvezno, največ 200 znakov)
description: Podroben opis (izbirno)
priority: Raven prioritete: low, medium, high (privzeto: medium)
Returns:
JSON z ID-jem in podrobnostmi ustvarjenega opravila
"""
task_id = str(uuid.uuid4())[:8]
task = {
"id": task_id,
"title": title[:200],
"description": description,
"priority": priority if priority in ("low", "medium", "high") else "medium",
"status": "open",
"created_at": datetime.now().isoformat(),
}
tasks_db[task_id] = task
return json.dumps({"success": True, "task": task}, ensure_ascii=False)
@mcp.tool()
def list_tasks(status: str = "all", priority: str = "all") -> str:
"""Našteje opravila z izbirnimi filtri.
Args:
status: Filter po statusu: all, open, completed (privzeto: all)
priority: Filter po prioriteti: all, low, medium, high (privzeto: all)
Returns:
JSON s seznamom opravil in skupnim številom
"""
filtered = list(tasks_db.values())
if status != "all":
filtered = [t for t in filtered if t["status"] == status]
if priority != "all":
filtered = [t for t in filtered if t["priority"] == priority]
return json.dumps({
"total": len(filtered),
"tasks": filtered,
}, ensure_ascii=False)
@mcp.tool()
def complete_task(task_id: str) -> str:
"""Označi opravilo kot zaključeno.
Args:
task_id: Edinstveni identifikator opravila
Returns:
Potrdilo posodobitve ali sporočilo o napaki
"""
if task_id not in tasks_db:
return json.dumps({"error": f"Task {task_id} not found"})
tasks_db[task_id]["status"] = "completed"
tasks_db[task_id]["completed_at"] = datetime.now().isoformat()
return json.dumps({"success": True, "task": tasks_db[task_id]}, ensure_ascii=False)
@mcp.tool()
def delete_task(task_id: str) -> str:
"""Izbriše opravilo iz upravitelja.
Args:
task_id: Edinstveni identifikator opravila za izbris
Returns:
Potrdilo izbrisa ali sporočilo o napaki
"""
if task_id not in tasks_db:
return json.dumps({"error": f"Task {task_id} not found"})
deleted = tasks_db.pop(task_id)
return json.dumps({"success": True, "deleted_task": deleted["title"]}, ensure_ascii=False)
# --- Namestitev strežnika MCP v FastAPI ---
# streamable_http_app() ustvari aplikacijo ASGI za strežnik MCP.
# Njegov upravitelj seje mora biti zagnan prek lifespan FastAPI,
# sicer strežnik odgovarja, vendar vsak klic orodja ne uspe.
@asynccontextmanager
async def lifespan(app: FastAPI):
async with mcp.session_manager.run():
yield
api = FastAPI(title="Task Manager MCP", lifespan=lifespan)
# --- Vmesna programska oprema za avtentikacijo ---
@api.middleware("http")
async def auth_middleware(request: Request, call_next):
"""Preveri žeton za vse poti /tasks."""
if request.url.path.startswith("/tasks"):
auth = request.headers.get("Authorization", "")
if auth != f"Bearer {API_TOKEN}":
raise HTTPException(status_code=401, detail="Invalid token")
return await call_next(request)
# Javno gostiteljsko ime (ngrok, produkcijska domena), deklarirano strežniku MCP
PUBLIC_HOST = os.environ.get("MCP_PUBLIC_HOST", "localhost")
securite = TransportSecuritySettings(
allowed_hosts=[PUBLIC_HOST, f"{PUBLIC_HOST}:*", "localhost:*", "127.0.0.1:*"]
)
api.mount("/tasks", mcp.streamable_http_app(transport_security=securite))
if __name__ == "__main__":
import uvicorn
uvicorn.run(api, host="0.0.0.0", port=8000)
Dve podrobnosti pri implementaciji si zaslužita vašo pozornost. V create_task je naslov obrezan na 200 znakov, prioriteta pa privzeto nastavi na medium, če prejeta vrednost ni na seznamu dovoljenih: model včasih predlaga verjetne, a zunaj pogodbe določene vrednosti, orodje pa mora ostati robustno in se ne sme sesuti. V complete_task in delete_task neznani ID ne sproži izjeme, temveč vrne sporočilo o napaki v formatu JSON – model to lahko prebere, razume svojo napako in ponovno oblikuje zahtevo, medtem ko bi sesutje to preprečilo.
Zagon in izpostavitev strežnika
# V prvem terminalu odprite predor ngrok
ngrok http 8000
# Javni URL: https://xyz789.ngrok-free.app
# V drugem terminalu zaženite strežnik z deklaracijo tega gostiteljskega imena
MCP_PUBLIC_HOST=xyz789.ngrok-free.app python task_server.py
Končna točka MCP se nato nahaja na https://xyz789.ngrok-free.app/tasks/mcp. Upoštevajte sestavo tega naslova: javni URL, ki ga zagotavlja ngrok, ki mu sledi pot namestitve /tasks, nato pa pripona /mcp, ki jo doda SDK. Zmeda glede tega združevanja je glavni vzrok za neuspehe povezave.
Odjemalec: client_tasks.py
Na strani odjemalca se glede na lokalni strežnik ne spremeni nič, razen vrste odjemalca MCP in dodajanja glave za avtentikacijo. Agent pa prejme navodila, ki v naravnem jeziku opisujejo njegovo vlogo – to ga spodbuja, da potrdi vsako dejanje, namesto da bi tiho verižil klice.
# client_tasks.py
"""Odjemalec MCP za oddaljeni strežnik opravil z avtentikacijo."""
import asyncio
import os
from mistralai.client import Mistral
from mistralai.extra.run.context import RunContext
from mistralai.extra.mcp.streamable_http import (
MCPClientStreamableHTTP,
StreamableHTTPServerParams,
)
API_TOKEN = "mcp-secret-token-2026"
SERVER_URL = "https://xyz789.ngrok-free.app/tasks/mcp"
async def main():
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
# Ustvari agenta s prilagojenimi navodili
agent = client.beta.agents.create(
model="mistral-medium-latest",
name="task-manager",
instructions=(
"You are an intelligent task manager. "
"Use the available tools to create, list, and manage "
"the user's tasks. Respond in English. "
"Confirm every action performed."
),
)
# Konfiguriraj oddaljenega odjemalca MCP z avtentikacijo
mcp_client = MCPClientStreamableHTTP(
params=StreamableHTTPServerParams(
url=SERVER_URL,
headers={"Authorization": f"Bearer {API_TOKEN}"},
timeout=30,
)
)
async with RunContext(
agent_id=agent.id,
continue_on_fn_error=True,
) as run_ctx:
await run_ctx.register_mcp_client(mcp_client=mcp_client)
# Pogovor z upraviteljem
conversations = [
"Create a high priority task: Prepare the MCP presentation",
"Create a medium priority task: Review the documentation",
"List all ongoing tasks",
"Mark the first task as completed",
"Show me the remaining tasks",
]
for msg in conversations:
print(f"\n> {msg}")
result = await client.beta.conversations.run_async(
run_ctx=run_ctx,
inputs=msg,
)
print(f"Agent: {result.output_as_text}")
asyncio.run(main())
Zaporedje sporočil je namerno: veriži dve ustvarjanji, branje, posodobitev in ponovno branje. To je minimalni scenarij za preverjanje, ali stanje preživi od enega klica do naslednjega in ali lahko model pridobi ID opravila, ustvarjenega prej v pogovoru. Če četrto navodilo ne uspe, težava redko tiči v strežniku: običajno izvira iz tega, da odgovor list_tasks ne naredi ID-jev dovolj vidnih.
Testiranje v Mistral Vibe
Isto končno točko lahko dodate neposredno kot prilagojeni konektor, kar vam omogoča vmesnik za testiranje brez pisanja odjemalca. To je tudi najboljši način za validacijo vaših docstringov: Vibe jih pri odkrivanju prikaže takšne, kot so, tako da takoj vidite, kaj bo imel model pred seboj pri odločanju, katero orodje poklicati.
- Pojdite na zavihek Connectors v Vibeu
- Kliknite Add Custom Connector
- Vnesite Name kot
Task Manager, URL kothttps://xyz789.ngrok-free.app/tasks/mcp, nato izberite Auth: Token in prilepitemcp-secret-token-2026 - Kliknite Connect
Vibe nato samodejno odkrije štiri orodja in lahko v naravnem jeziku komunicirate s svojim lastnim strežnikom.
Organizacija projekta in naslednji koraki
task-mcp-project/
├── task_server.py # Strežnik MCP + FastAPI + avtentikacija
├── client_tasks.py # Odjemalec Python z agentom
├── requirements.txt # fastapi, uvicorn, mcp>=2.2,<3, mistralai[agents]
└── .env # MISTRAL_API_KEY, API_TOKEN
Ta ogrodje deluje za prototipiranje, vendar ga dve stvari diskvalificirata za produkcijsko uporabo. Žeton v navadni besedilni obliki v izvorni kodi se mora premakniti v .env, URL ngrok pa se ob vsakem ponovnem zagonu spremeni, kar prekine vse konfigurirane konektorje. ngrok ostaja idealno orodje za validacijo ideje v nekaj minutah; trajno gostovanje z možnostmi Docker, oblak in Hugging Face Spaces je tema lekcije 12.
Ključne ugotovitve
- Oddaljeni strežnik združuje FastAPI (HTTP) +
MCPServer(MCP) + vmesno programsko opremo (avtentikacija), pri čemer je javno gostiteljsko ime deklarirano vtransport_security - Avtentikacija z žetonom se obravnava prek glave
Authorization: Bearer ... - Odjemalec
MCPClientStreamableHTTPsprejema poljubne glave za avtentikacijo - Isti strežnik je uporaben tako iz Python SDK kot iz Mistral Vibe
- ngrok omogoča hitro prototipiranje pred produkcijsko namestitvijo