Eżempju Sħiħ: Server Remot b'Awtentikazzjoni
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 issa huma ħiliet (invokati b’
@), il-memorji jservu bħala bażi tal-għarfien, u t-tfittxija fil-fond 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: ir-riżultati ta’run_asyncjinqraw minnresult.output_as_text; l-SDKmistralai3.7.0 m’għandux attributoutput.
Aġġornament 2 ta’ Novembru, 2026 — MCP Python SDK v2. Din il-kors issa ssegwi l-verżjoni 2 tal-SDK
mcp(2.3.0 sal-2 ta’ Ottubru, 2026):MCPServerjieħu postFastMCP, l-issettjar tat-trasport jimxi għalrun()jewstreamable_http_app(), u app esposta taħt isem ta’ host reali trid tiddikjara dak l-isem ta’ host (transport_security). Din hija wkoll il-verżjoni meħtieġa mill-Mistral SDK: l-extramistralai[agents]jeħtieġmcp>=2.2.0,<3.0. Sorsi: X’inhu ġdid f’v2 · Gwida għall-Migrazzjoni · Iddispjega u skala.
Xenarju: Server MCP għall-Ġestjoni tal-Kompiti
Il-lezzjonijiet preċedenti koprew il-biċċiet individwali: it-trasport HTTP, il-middleware, u l-awtentikazzjoni bit-token. Issa se tgħaqqadhom f’proġett li jaħdem bis-sħiħ. Is-server jesponi erba’ għodod għall-ġestjoni tal-kompiti—oħloq, elenka, ikkompleta, ħassar—u l-klijent jikkonnetta remotament, u jippreżenta token bearer ma’ kull talba. Dan l-istess server imbagħad se jkun jista’ jitħaddem minn Vibe mingħajr linja waħda extra ta’ kodiċi: dan huwa l-vantaġġ kollu ta’ server remot fuq server STDIO.
Is-Server: task_server.py
Tliet elementi jikkoegżistu f’dan il-fajl wieħed. FastAPI jittratta t-trasport HTTP u l-middleware tal-awtentikazzjoni, MCPServer jittratta l-protokoll MCP u l-għodod, u dizzjunarju Python iservi bħala l-bażi tad-data. L-ordni tal-fajls hija importanti: iddikjara l-server MCP u l-għodod tiegħu l-ewwel, imbagħad oħloq l-app FastAPI bil-lifespan li tibda l-maniġer tas-sessjoni, u mmonta s-server fl-aħħar. Innota li l-middleware jipproteġi l-mogħdija /tasks, li hija eżattament fejn huwa mmuntat is-server MCP: dawn iż-żewġ valuri jridu jaqblu, inkella tispiċċa b’bieb miftuħ jew mogħdija mblukkata.
# 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)
Żewġ dettalji ta’ implimentazzjoni jistħoqqilhom attenzjoni. F’create_task, it-titlu jiġi maqtugħ għal 200 karattru u l-prijorità tiddefawltja għal medium jekk il-valur riċevut mhux fil-lista permessa: il-mudell xi kultant jipproponi valuri plawżibbli iżda barra mill-kuntratt, u l-għodda trid tibqa’ robusta mingħajr ma tfalli. F’complete_task u delete_task, ID mhux magħruf ma jqajjimx eċċezzjoni iżda jirritorna messaġġ ta’ żball JSON—il-mudell jista’ jaqra dan, jifhem l-iżball tiegħu, u jifformula mill-ġdid, filwaqt li ħsara (crash) tkun tipprevjeni dan.
Ixgħel u Esponi s-Server
# F'terminal ewlieni, iftaħ il-mina ngrok
ngrok http 8000
# URL Pubbliku: https://xyz789.ngrok-free.app
# F'tieni terminal, ixgħel is-server billi tiddikjara dan l-isem ta' host
MCP_PUBLIC_HOST=xyz789.ngrok-free.app python task_server.py
L-endpoint MCP imbagħad jinsab f’https://xyz789.ngrok-free.app/tasks/mcp. Innota l-kompożizzjoni ta’ dan l-indirizz: l-URL pubbliku pprovdut minn ngrok, segwit mill-mogħdija tal-immuntar /tasks, imbagħad is-suffiss /mcp miżjud mill-SDK. Il-konfużjoni dwar din il-konkatenazzjoni hija l-kawża ewlenija ta’ fallimenti fil-konnessjoni.
Il-Klijent: client_tasks.py
Fuq in-naħa tal-klijent, xejn ma jinbidel meta mqabbel ma’ server lokali ħlief it-tip ta’ klijent MCP u ż-żieda tal-header tal-awtentikazzjoni. L-aġent, madankollu, jirċievi struzzjonijiet li jiddeskrivu r-rwol tiegħu b’lingwa naturali—dan jinkoraġġih jikkonferma kull azzjoni minflok ma jgħaqqad sejħiet b’mod silenzjuż.
# 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())
Is-sekwenza tal-messaġġi hija deliberata: tgħaqqad żewġ ħolqien, qari, aġġornament, u qari mill-ġdid. Dan huwa l-iżgħar xenarju biex tivverifika li l-istat jibqa’ ħaj minn sejħa għall-oħra u li l-mudell jista’ jirkupra l-ID ta’ kompitu maħluq qabel fil-konversazzjoni. Jekk ir-raba’ istruzzjoni tfalli, il-problema tiegħek rari tkun fis-server: ġeneralment toriġina mir-rispons ta’ list_tasks li ma jagħmilx l-IDs viżibbli biżżejjed.
Ittestja f’Mistral Vibe
L-istess endpoint jista’ jiġi miżjud direttament bħala konnettur custom, u jagħtik interfaċċa tat-test mingħajr ma tikteb klijent. Din hija wkoll l-aħjar mod biex tivvalida d-docstrings tiegħek: Vibe jurihom hekk kif inhum waqt l-iskoperta, allura tara immedjatament x’se jkollu quddiemu l-mudell biex jiddeċiedi liema għodda jsejjaħ.
- Mur fit-tab Connectors f’Vibe
- Ikklikkja Add Custom Connector
- Daħħal Name bħala
Task Manager, URL bħalahttps://xyz789.ngrok-free.app/tasks/mcp, imbagħad agħżel Auth: Token u pejnjamcp-secret-token-2026 - Ikklikkja Connect
Vibe imbagħad jiskopri awtomatikament l-erba’ għodod, u tista’ tikkonversa b’lingwa naturali mas-server tiegħek stess.
Organizzazzjoni tal-Proġett u Passi Li Jmiss
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
Dan l-iskellet jaħdem għall-prototipar, iżda żewġ affarijiet jiskwalifikawh għall-produzzjoni. It-token f’test ċar fil-kodiċi sors irid jiċċaqlaq għal .env, u l-URL ta’ ngrok jinbidel f’kull riavvju, u jkisser il-konnetturi kollu kkonfigurati. ngrok jibqa’ l-għodda ideali biex tivvalida idea f’ftit minuti; l-hosting permanenti, bl-għażliet tiegħu ta’ Docker, cloud, u Hugging Face Spaces, huwa s-suġġett tal-lezzjoni 12.
Punti Ewlenin
- Server remot jgħaqqad FastAPI (HTTP) +
MCPServer(MCP) + middleware (awt), bl-isem ta’ host pubbliku ddikjarat f’transport_security - L-awtentikazzjoni bit-token tiġi ttrattata permezz tal-header
Authorization: Bearer ... - Il-klijent
MCPClientStreamableHTTPjaċċetta headers custom għall-awtentikazzjoni - L-istess server huwa użabbli kemm mill-Python SDK kif ukoll minn Mistral Vibe
- ngrok jippermetti prototipar rapidu qabel id-dispjega fil-produzzjoni