Kompletní příklad: Vzdálený server s autentizací
Na této stránce
Aktualizace 2. listopadu 2026 — Le Chat je nyní Vibe. Od 28. května 2026 byl Le Chat přejmenován na Vibe (stále na chat.mistral.ai): jediný agent pro práci i kód, který si ponechává vaše konverzace, nastavení a předplatná. Původní prostředí Le Chat zůstává dostupné v režimu Chat; v režimu Work jsou agenti nyní dovednosti (vyvolávané pomocí
@), paměti slouží jako znalostní báze a hluboké vyhledávání je dovednost Deep Research. Plány se nyní nazývají Mistral Free, Pro, Team a Enterprise. Tato lekce používá název Vibe; některá zde popsaná menu mohla změnit názvy nebo umístění. Dodatek 3. listopadu: výsledkyrun_asyncse čtou zresult.output_as_text; SDKmistralaiverze 3.7.0 nemá atributoutput.
Aktualizace 2. listopadu 2026 — MCP Python SDK v2. Tento kurz nyní sleduje verzi 2 SDK
mcp(2.3.0 k 2. říjnu 2026):MCPServernahrazujeFastMCP, nastavení transportu se přesouvá dorun()nebostreamable_http_app()a aplikace vystavená pod skutečným hostname musí tento hostname deklarovat (transport_security). Toto je také verze požadovaná Mistral SDK: extra balíčekmistralai[agents]vyžadujemcp>=2.2.0,<3.0. Zdroje: Co je nového ve v2 · Průvodce migrací · Nasazení a škálování.
Scénář: MCP Server pro správu úkolů
Předchozí lekce pokryly jednotlivé části: HTTP transport, middleware a tokenovou autentizaci. Nyní je poskládáš do plně funkčního projektu. Server vystavuje čtyři nástroje pro správu úkolů – vytvoření, výpis, dokončení, smazání – a klient se připojuje vzdáleně, přičemž s každým požadavkem předkládá bearer token. Tento stejný server pak poběží z Vibe bez jediného řádku kódu navíc: v tom spočívá celá výhoda vzdáleného serveru oproti serveru STDIO.
Server: task_server.py
V tomto jediném souboru koexistují tři prvky. FastAPI zpracovává HTTP transport a autentizační middleware, MCPServer řeší protokol MCP a nástroje a Python slovník slouží jako databáze. Pořadí souboru je důležité: nejprve deklaruj MCP server a jeho nástroje, poté vytvoř aplikaci FastAPI s lifespan, která spustí správce relace, a nakonec připoj server. Všimni si, že middleware chrání cestu /tasks, kam je přesně MCP server připojen: tyto dvě hodnoty se musí shodovat, jinak skončíš buď s otevřenými dveřmi, nebo zablokovanou cestou.
# 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)
Dva implementační detaily si zaslouží tvou pozornost. V create_task je nadpis zkrácen na 200 znaků a priorita默认ně nastavena na medium, pokud přijatá hodnota není v povoleném seznamu: model někdy navrhuje věrohodné, ale mimo rámec specifikace hodnoty a nástroj musí zůstat robustní bez selhání. V complete_task a delete_task neznámé ID nezvedá výjimku, ale vrací chybovou zprávu ve formátu JSON – model si ji může přečíst, pochopit svou chybu a přeformulovat požadavek, zatímco pád by tomu zabránil.
Spuštění a vystavení serveru
# V prvním terminálu otevři tunel ngrok
ngrok http 8000
# Veřejná URL: https://xyz789.ngrok-free.app
# Ve druhém terminálu spusť server s deklarací tohoto hostname
MCP_PUBLIC_HOST=xyz789.ngrok-free.app python task_server.py
Koncový bod MCP se pak nachází na adrese https://xyz789.ngrok-free.app/tasks/mcp. Všimni si skladby této adresy: veřejná URL poskytnutá službou ngrok, následovaná cestou připojení /tasks a poté příponou /mcp přidanou SDK. Zmatky ohledně tohoto zřetězení jsou hlavní příčinou selhání připojení.
Klient: client_tasks.py
Na straně klienta se oproti lokálnímu serveru nic nemění kromě typu MCP klienta a přidání autentizační hlavičky. Agent však dostává instrukce, které popisují jeho roli přirozeným jazykem – to ho povzbuzuje, aby každou akci potvrdil, místo aby tiše řetězil volání.
# 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())
Posloupnost zpráv je záměrná: řetězí dvě vytvoření, čtení, aktualizaci a opětovné čtení. Toto je minimální scénář pro ověření, že stav přežívá z jednoho volání do druhého a že model dokáže získat ID úkolu vytvořeného dříve v konverzaci. Pokud čtvrtý instrukce selže, tvůj problém málokdy leží na serveru: obvykle pramení z toho, že odpověď list_tasks nečiní ID dostatečně viditelnými.
Testování v Mistral Vibe
Stejný koncový bod lze přidat přímo jako vlastní konektor, což ti poskytne testovací rozhraní bez psaní klienta. Je to také nejlepší způsob, jak ověřit své docstringy: Vibe je zobrazuje tak, jak jsou, během objevování, takže okamžitě vidíš, co bude mít model před sebou při rozhodování, který nástroj zavolat.
- Přejdi na kartu Connectors ve Vibe
- Klikni na Add Custom Connector
- Zadej Name jako
Task Manager, URL jakohttps://xyz789.ngrok-free.app/tasks/mcp, poté vyber Auth: Token a vložmcp-secret-token-2026 - Klikni na Connect
Vibe poté automaticky objeví čtyři nástroje a můžeš konverzovat přirozeným jazykem se svým vlastním serverem.
Organizace projektu a další kroky
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
Tato kostra funguje pro prototypování, ale dvě věci ji diskvalifikují pro produkci. Token v čistém textu ve zdrojovém kódu se musí přesunout do .env a URL ngrok se mění při každém restartu, což rozbíjí všechny nakonfigurované konektory. ngrok zůstává ideálním nástrojem pro ověření nápadu během minut; trvalé hostování s možnostmi Docker, cloud a Hugging Face Spaces je tématem lekce 12.
Klíčové poznatky
- Vzdálený server kombinuje FastAPI (HTTP) +
MCPServer(MCP) + middleware (auth), přičemž veřejný hostname je deklarován vtransport_security - Tokenová autentizace je zpracována prostřednictvím hlavičky
Authorization: Bearer ... - Klient
MCPClientStreamableHTTPpřijímá pro autentizaci vlastní hlavičky - Stejný server je použitelný jak z Python SDK, tak z Mistral Vibe
- ngrok umožňuje rychlé prototypování před nasazením do produkce