Näide tervikuna: kaugserver autentimisega
Sellel lehel
Uuendus 2. novembril 2026 — Le Chat on nüüd Vibe. Alates 28. maist 2026 on Le Chat ümber bränditud nimele Vibe (aadressil chat.mistral.ai): üks agent tööks ja kodeerimiseks, säilitades sinu vestlused, seaded ja tellimused. Vana Le Chati kasutajaliides on endiselt kättesaadav režiimis Chat; režiimis Work on agendid nüüd oskused (käivitatakse sümboliga
@), mälud toimivad teadmiste baasina ja sügav otsing on oskus Deep Research. Plaanid kannavad nüüd nimesid Mistral Free, Pro, Team ja Enterprise. Selles õppetunnis kasutame nime Vibe; mõned siin kirjeldatud menüüd võivad olla muutnud nime või asukohta. Lisand 3. novembril:run_asynctulemused loetakse väljaltresult.output_as_text;mistralaiSDK versioonil 3.7.0 puudub atribuutoutput.
Uuendus 2. novembril 2026 — MCP Python SDK v2. See kursus järgib nüüd
mcpSDK versiooni 2 (2.3.0 seisuga 2. oktoober 2026):MCPServerasendabFastMCP-i, transpordi seaded liiguvad meetoditesserun()võistreamable_http_app()ja reaalse hostinime all avaldatud rakendus peab selle hostinime deklareerima (transport_security). See on ka versioon, mida nõuab Mistral SDK: lisapakettmistralai[agents]eeldabmcp>=2.2.0,<3.0. Allikad: Mis on uut v2-s · Rändejuhend · Kasutuselevõtt ja skaleerimine.
Stsenaarium: ülesannete halduse MCP server
Eelmistes tundides käsitlesime üksikuid osi: HTTP transporti, vahevara ja token-põhist autentimist. Nüüd paned sa need kokku täisfunktsionaalseks projektiks. Server avaldab neli ülesannete halduse tööriista – loomine, loetlemine, lõpetamine, kustutamine – ja klient ühendub kaugelt, esitades iga päringuga bearer-tokeni. Sama server jookseb seejärel Vibe’is ilma ühegi lisakoodireata: selles seisnebki kaugserveri eelis STDIO serveri ees.
Server: task_server.py
Selles ühes failis eksisteerivad koos kolm elementi. FastAPI haldab HTTP transporti ja autentimise vahevara, MCPServer haldab MCP protokolli ja tööriistu ning Pythoni sõnastik toimib andmebaasina. Faili järjestus on oluline: deklareeri esmalt MCP server ja selle tööriistad, seejärel loo FastAPI rakendus koos lifespan-iga, mis käivitab sessioonihalduri, ja haagi server lõpuks külge. Pane tähele, et vahevara kaitseb teed /tasks, kuhu MCP server on haagitud: need kaks väärtust peavad kattuma, muidu jääb kas uks valla või tee müüritakse kinni.
# task_server.py
"""Remote MCP server with token authentication."""
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
# --- Configuration ---
API_TOKEN = "mcp-secret-token-2026"
# --- In-memory database ---
tasks_db: dict[str, dict] = {}
# --- MCP Server ---
mcp = MCPServer("Task Manager")
@mcp.tool()
def create_task(title: str, description: str = "", priority: str = "medium") -> str:
"""Creates a new task in the manager.
Args:
title: Task title (required, max 200 characters)
description: Detailed description (optional)
priority: Priority level: low, medium, high (default: medium)
Returns:
JSON with the ID and details of the created task
"""
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:
"""Lists tasks with optional filters.
Args:
status: Filter by status: all, open, completed (default: all)
priority: Filter by priority: all, low, medium, high (default: all)
Returns:
JSON with the list of tasks and the total count
"""
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:
"""Marks a task as completed.
Args:
task_id: The unique identifier of the task
Returns:
Confirmation of the update or an error message
"""
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:
"""Deletes a task from the manager.
Args:
task_id: The unique identifier of the task to delete
Returns:
Confirmation of deletion or an error message
"""
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)
# --- Mount the MCP server in FastAPI ---
# streamable_http_app() produces the ASGI app for the MCP server.
# Its session manager must be started by the FastAPI lifespan,
# otherwise the server responds but every tool call fails.
@asynccontextmanager
async def lifespan(app: FastAPI):
async with mcp.session_manager.run():
yield
api = FastAPI(title="Task Manager MCP", lifespan=lifespan)
# --- Authentication Middleware ---
@api.middleware("http")
async def auth_middleware(request: Request, call_next):
"""Verifies the token for all /tasks routes."""
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)
# Public hostname (ngrok, production domain) declared to the MCP server
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)
Kaks rakenduse detaili väärivad tähelepanu. Funktsioonis create_task lühendatakse pealkiri 200 märgini ja prioriteediks määratakse vaikimisi medium, kui saadud väärtus pole lubatud nimekirjas: mudel pakub mõnikord usutavaid, kuid lepinguväliseid väärtusi ja tööriist peab jääma robustseks ilma tõrketa. Funktsioonides complete_task ja delete_task tundmatu ID korral viset erandit ei teki, vaid tagastatakse JSON-vormingus veateade – mudel suudab seda lugeda, oma veast aru saada ja sõnastust muuta, samas kui kokkujooksumine seda takistaks.
Serveri käivitamine ja avalikustamine
# Esimeses terminalis ava ngrok tunnel
ngrok http 8000
# Avalik URL: https://xyz789.ngrok-free.app
# Teises terminalis käivita server, deklareerides selle hostinime
MCP_PUBLIC_HOST=xyz789.ngrok-free.app python task_server.py
MCP lõpp-punkt asub seejärel aadressil https://xyz789.ngrok-free.app/tasks/mcp. Pane tähele selle aadressi ülesehitust: ngroki pakutav avalik URL, millele järgneb haakimise tee /tasks ja seejärel SDK lisatud sufiks /mcp. Segadus selle liitmise osas on ühendusvigade peamine põhjus.
Klient: client_tasks.py
Kliendi poolel ei muutu kohaliku serveriga võrreldes midagi, välja arvatud MCP kliendi tüüp ja autentimispäise lisamine. Agent saab aga juhised, mis kirjeldavad tema rolli loomulikus keeles – see julgustab teda kinnitama iga toimingut, mitte vaikimisi kutseid aheldama.
# client_tasks.py
"""MCP client for the remote task server with authentication."""
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"])
# Create the agent with adapted instructions
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."
),
)
# Configure the remote MCP client with authentication
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)
# Conversation with the manager
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())
Sõnumite jada on tahtlik: see aheldab kaks loomist, lugemise, uuendamise ja uuesti lugemise. See on minimaalne stsenaarium, et kontrollida, kas olek püsib ühelt väljakutselt teisele ja kas mudel suudab leida varem vestluses loodud ülesande ID-d. Kui neljas juhend ebaõnnestub, peitub probleem harva serveris: tavaliselt tuleneb see sellest, et list_tasks vastus ei tee ID-sid piisavalt nähtavaks.
Testimine Mistral Vibe’is
Sama lõpp-punkti saab lisada otse kohandatud ühendusena, mis annab sulle testiliidese ilma klienti kirjutamata. See on ka parim viis oma docstringide valideerimiseks: Vibe kuvab need avastamise käigus muutmatuna, nii et näed kohe, mis mudeli ette satub, kui ta otsustab, millist tööriista kutsuda.
- Mine Vibe’is vahekaardile Connectors
- Klõpsa Add Custom Connector
- Sisesta Name väärtuseks
Task Manager, URL väärtusekshttps://xyz789.ngrok-free.app/tasks/mcpja vali Auth: Token, kleepides sinnamcp-secret-token-2026 - Klõpsa Connect
Vibe avastab seejärel automaatselt neli tööriista ja saad vestelda loomulikus keeles omaenda serveriga.
Projekti struktuur ja järgmised sammud
task-mcp-project/
├── task_server.py # MCP server + FastAPI + auth
├── client_tasks.py # Python client with agent
├── requirements.txt # fastapi, uvicorn, mcp>=2.2,<3, mistralai[agents]
└── .env # MISTRAL_API_KEY, API_TOKEN
See luustik sobib prototüüpimiseks, kuid kaks asja diskvalifitseerivad selle tootmiskeskkonnas. Läbipaistev token lähtekoodis tuleb viia faili .env ja ngroki URL muutub iga taaskäivitusega, rikkudes kõik konfigureeritud ühendused. ngrok jääb ideaalseks tööriistaks idee valideerimiseks minutitega; püsiv majutus koos selle Dockeri, pilve ja Hugging Face Spacesi võimalustega on 12. õppetunni teema.
Peamised punktid
- Kaugserver ühendab FastAPI (HTTP) +
MCPServer(MCP) + vahevara (autentimine), kus avalik hostinimi on deklareeritudtransport_securitysees - Token-autentimist hallatakse päise
Authorization: Bearer ...kaudu - Klient
MCPClientStreamableHTTPaktsepteerib autentimiseks kohandatud päiseid - Sama serverit saab kasutada nii Python SDK kui ka Mistral Vibe kaudu
- ngrok võimaldab kiiret prototüüpimist enne tootmisse viimist