Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Példa teljes körűen: Távoli szerver hitelesítéssel

9. lecke 14 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Forgatókönyv: Feladatkezelő MCP Szerver
  2. A Szerver: task_server.py
  3. A Szerver Indítása és Közzététele
  4. A Kliens: client_tasks.py
  5. Tesztelés a Mistral Vibe-ban
  6. Projekt Szervezése és Következő Lépések
  7. Főbb megállapítások

Frissítés 2026. november 2. — A Le Chat mostantól Vibe. 2026. május 28-tól a Le Chat új neve Vibe (továbbra is a chat.mistral.ai címen érhető el): egyetlen ügynök munkához és kódoláshoz, amely megőrzi beszélgetéseidet, beállításaidat és előfizetéseidet. A régi Le Chat élmény továbbra is elérhető a Chat módban; a Work módban az ügynökök készségekké (skills) váltak (az @ jellel hívhatók meg), az emlékek (memories) a tudásbázisként szolgálnak, a mély keresés pedig a Deep Research készség. A csomagok neve mostantól: Mistral Free, Pro, Team és Enterprise. Ez a lecke a Vibe nevet használja; néhány itt leírt menü neve vagy helye megváltozhatott. Kiegészítés november 3.: A run_async eredményeit a result.output_as_textből olvassuk; a mistralai SDK 3.7.0-as verziójában nincs output attribútum.

Frissítés 2026. november 2. — MCP Python SDK v2. Ez a tanfolyam most az mcp SDK 2-es verzióját követi (2026. október 2-i állapot szerint 2.3.0): az MCPServer leváltja a FastMCP-et, a transzport beállítások a run() vagy streamable_http_app() függvényekbe kerültek, és egy valódi hosztnév alatt elérhető alkalmazásnak deklarálnia kell ezt a hosztnevet (transport_security). Ez az a verzió, amelyet a Mistral SDK is megkövetel: a mistralai[agents] extra függőségéhez mcp>=2.2.0,<3.0 szükséges. Források: Újdonságok a v2-ben · Migrációs útmutató · Telepítés és skálázás.

Forgatókönyv: Feladatkezelő MCP Szerver

Az előző leckék külön-külön tárgyalták az elemeket: HTTP transzport, middleware és tokenes hitelesítés. Most ezeket egy teljesen működőképes projektbe állítod össze. A szerver négy feladatkezelő eszközt tesz elérhetővé – létrehozás, listázás, befejezés, törlés –, a kliens pedig távolról csatlakozik, minden kérésnél bemutatva egy bearer tokent. Ugyanez a szerver ezután egyetlen extra sor kód nélkül futtatható a Vibeből is: ez a távoli szerver teljes előnye a STDIO szerverekkel szemben.

A Szerver: task_server.py

Három elem共存ál ebben az egyetlen fájlban. A FastAPI kezeli a HTTP transzportot és a hitelesítési middleware-t, az MCPServer az MCP protokollt és az eszközöket, egy Python szótár pedig az adatbázisként szolgál. A fájlok sorrendje számít: először deklaráld az MCP szervert és eszközeit, majd hozd létre a FastAPI alkalmazást azzal a lifespan kontextussal, amely elindítja a munkamenet-kezelőt, és végül csatlakoztasd (mount) a szervert. Figyeld meg, hogy a middleware a /tasks útvonalat védi, ami pontosan ott van, ahol az MCP szerver csatlakoztatva van: e két értéknek egyeznie kell, különben vagy nyitott kaput, vagy elzárt utat kapsz.

# task_server.py
"""Távoli MCP szerver tokenes hitelesítéssel."""

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

# --- Konfiguráció ---
API_TOKEN = "mcp-secret-token-2026"

# --- Memóriában tárolt adatbázis ---
tasks_db: dict[str, dict] = {}

# --- MCP Szerver ---
mcp = MCPServer("Task Manager")

@mcp.tool()
def create_task(title: str, description: str = "", priority: str = "medium") -> str:
    """Létrehoz egy új feladatot a kezelőben.

    Args:
        title: Feladat címe (kötelező, max 200 karakter)
        description: Részletes leírás (opcionális)
        priority: Prioritási szint: low, medium, high (alapértelmezett: medium)

    Returns:
        JSON a létrehozott feladat ID-jével és részleteivel
    """
    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:
    """Listázza a feladatokat opcionális szűrőkkel.

    Args:
        status: Szűrés állapot szerint: all, open, completed (alapértelmezett: all)
        priority: Szűrés prioritás szerint: all, low, medium, high (alapértelmezett: all)

    Returns:
        JSON a feladatok listájával és a teljes számmal
    """
    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:
    """Befejezettként jelöl meg egy feladatot.

    Args:
        task_id: A feladat egyedi azonosítója

    Returns:
        Megerősítés a frissítésről vagy hibaüzenet
    """
    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:
    """Töröl egy feladatot a kezelőből.

    Args:
        task_id: A törlendő feladat egyedi azonosítója

    Returns:
        Megerősítés a törlésről vagy hibaüzenet
    """
    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)

# --- Az MCP szerver csatlakoztatása a FastAPI-hoz ---
# A streamable_http_app() előállítja az ASGI alkalmazást az MCP szerverhez.
# A munkamenet-kezelőjét a FastAPI lifespan-nek kell elindítania,
# különben a szerver válaszol, de minden eszközhívás sikertelen.
@asynccontextmanager
async def lifespan(app: FastAPI):
    async with mcp.session_manager.run():
        yield

api = FastAPI(title="Task Manager MCP", lifespan=lifespan)

# --- Hitelesítési Middleware ---
@api.middleware("http")
async def auth_middleware(request: Request, call_next):
    """Ellenőrzi a tokent minden /tasks útvonalon."""
    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)

# Nyilvános hosztnév (ngrok, éles domain) deklaráálva az MCP szerver számára
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)

Két implementációs részletre érdemes figyelned. A create_task függvényben a címet 200 karakterre vágjuk, a prioritás pedig medium lesz alapértelmezettként, ha a kapott érték nincs a megengedett listában: a modell néha hihető, de szerződésen kívüli értékeket javasol, és az eszköznek robusztusnak kell maradnia hiba nélkül. A complete_task és delete_task függvényekben egy ismeretlen ID nem dob kivételt, hanem egy JSON hibaüzenetet ad vissza – a modell ezt elolvashatja, megértheti a hibáját, és újra fogalmazhat, míg egy összeomlás ezt megakadályozná.

A Szerver Indítása és Közzététele

# Az első terminálban nyisd meg az ngrok alagutat
ngrok http 8000
# Nyilvános URL: https://xyz789.ngrok-free.app

# A második terminálban indítsd el a szervert ezzel a hosztnévvel deklarálva
MCP_PUBLIC_HOST=xyz789.ngrok-free.app python task_server.py

Az MCP végpont ezután a https://xyz789.ngrok-free.app/tasks/mcp címen található. Figyeld meg ennek a címnek az összetételét: az ngrok által biztosított nyilvános URL, majd a /tasks csatlakoztatási útvonal, végül az SDK által hozzáadott /mcp utótag. Ennek az összefűzésnek a félreértése a kapcsolódási hibák legfőbb oka.

A Kliens: client_tasks.py

A kliens oldalon semmi sem változik a helyi szerverhez képest, kivéve az MCP kliens típusát és a hitelesítési fejléc hozzáadását. Az ügynök viszont olyan utasításokat kap, amelyek természetes nyelven írják le a szerepét – ez arra ösztönzi, hogy minden műveletet megerősítsen, ahelyett, hogy csendben láncolná a hívásokat.

# client_tasks.py
"""MCP kliens a távoli feladat szerverhez hitelesítéssel."""

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"])

    # Az ügynök létrehozása testreszabott utasításokkal
    agent = client.beta.agents.create(
        model="mistral-medium-latest",
        name="task-manager",
        instructions=(
            "Egy intelligens feladatkezelő vagy. "
            "Használd a rendelkezésre álló eszközöket a felhasználó "
            "feladatainak létrehozására, listázására és kezelésére. "
            "Válaszolj angolul. "
            "Minden végrehajtott műveletet erősíts meg."
        ),
    )

    # A távoli MCP kliens konfigurálása hitelesítéssel
    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)

        # Beszélgetés a kezelővel
        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())

Az üzenetek sorrendje szándékos: két létrehozást, egy olvasást, egy frissítést és egy újraolvasást láncol össze. Ez a minimális forgatókönyv annak ellenőrzésére, hogy az állapot megmarad-e egyik hívásról a másikra, és hogy a modell képes-e visszakeresni egy korábban a beszélgetés során létrehozott feladat ID-jét. Ha a negyedik utasítás sikertelen, a probléma ritkán a szerverben van: általában abból adódik, hogy a list_tasks válasza nem teszi elég láthatóvá az ID-kat.

Tesztelés a Mistral Vibe-ban

Ugyanez a végpont közvetlenül egyéni csatlakozóként (custom connector) is hozzáadható, így tesztelő felületet kapsz kliens írása nélkül. Ez egyben a legjobb módja a docstringjeid validálásának is: a Vibe változatlanul jeleníti meg őket felfedezés közben, így azonnal látod, mi lesz a modell előtt, amikor eldönti, melyik eszközt hívja meg.

  1. Navigálj a Connectors fülre a Vibeban
  2. Kattints az Add Custom Connector gombra
  3. Add meg a Name mezőt Task Managerként, az URL-t pedig https://xyz789.ngrok-free.app/tasks/mcp-ként, majd válaszd az Auth: Token lehetőséget, és illeszd be ezt: mcp-secret-token-2026
  4. Kattints a Connect gombra

A Vibe ezután automatikusan felfedezi a négy eszközt, és természetes nyelven beszélgethetsz a saját szervereddel.

Projekt Szervezése és Következő Lépések

task-mcp-project/
├── task_server.py       # MCP szerver + FastAPI + hitelesítés
├── client_tasks.py      # Python kliens ügynökkel
├── requirements.txt     # fastapi, uvicorn, mcp>=2.2,<3, mistralai[agents]
└── .env                 # MISTRAL_API_KEY, API_TOKEN

Ez a váz prototípuskészítésre működik, de két dolog alkalmatlanná teszi éles környezetre. A forráskódban szereplő nyílt szöveges tokent át kell helyezni a .env fájlba, és az ngrok URL minden újraindításkor megváltozik, ami megszakítja az összes konfigurált csatlakozót. Az ngrok továbbra is az ideális eszköz egy ötlet percek alatti validálására; az állandó hoszting, a Docker, felhő és Hugging Face Spaces lehetőségeivel együtt a 12. lecke témája.

Főbb megállapítások

  • Egy távoli szerver egyesíti a FastAPI-t (HTTP) + az MCPServer-t (MCP) + a middleware-t (hitelesítés), ahol a nyilvános hosztnevet a transport_security deklarálja
  • A tokenes hitelesítés az Authorization: Bearer ... fejlécen keresztül történik
  • Az MCPClientStreamableHTTP kliens elfogad egyedi fejléceket a hitelesítéshez
  • Ugyanaz a szerver használható mind a Python SDK-ból, mind a Mistral Vibe-ból
  • Az ngrok lehetővé teszi a gyors prototípuskészítést az éles telepítés előtt