Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Piemērs no A līdz Z: attālināts serveris ar autentifikāciju

Nodarbība 9 no 14 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Scenārijs: uzdevumu pārvaldības MCP serveris
  2. Serveris: task_server.py
  3. Servera palaišana un eksponēšana
  4. Klients: client_tasks.py
  5. Testēšana Mistral Vibe
  6. Projekta organizācija un nākamie soļi
  7. Galvenās atziņas

Atjauninājums, 2026. gada 2. novembris — Le Chat tagad ir Vibe. Kopš 2026. gada 28. maija Le Chat ir pārdēvēts par Vibe (joprojām chat.mistral.ai): vienots aģents darbam un kodam, kas saglabā jūsu sarunas, iestatījumus un abonementus. Vecais Le Chat interfeiss joprojām ir pieejams režīmā Chat; režīmā Work aģenti tagad ir prasmes (izsaucamas ar @), atmiņas kalpo kā zināšanu bāze, bet dziļā meklēšana ir prasme Deep Research. Plāni tagad saucas Mistral Free, Pro, Team un Enterprise. Šajā nodarbībā lietots nosaukums Vibe; dažu šeit aprakstīto izvēlņu nosaukumi vai atrašanās vietas var būt mainījušies. Pielikums, 3. novembris: run_async rezultāti tiek nolasīti no result.output_as_text; mistralai SDK 3.7.0 versijā nav atribūta output.

Atjauninājums, 2026. gada 2. novembris — MCP Python SDK v2. Šis kurss tagad seko mcp SDK 2. versijai (2.3.0 pēc 2026. gada 2. oktobra datiem): MCPServer aizstāj FastMCP, transporta iestatījumi pārvietoti uz run() vai streamable_http_app(), un lietotnei, kas eksponēta zem reāla resursdatora nosaukuma, tas ir jādeklarē (transport_security). Tā ir arī versija, ko pieprasa Mistral SDK: papildinājums mistralai[agents] prasa mcp>=2.2.0,<3.0. Avoti: Kas jauns v2 · Migrācijas ceļvedis · Izvietošana un mērogošana.

Scenārijs: uzdevumu pārvaldības MCP serveris

Iepriekšējās nodarbībās apskatījām atsevišķos komponentus: HTTP transportu, starpprogrammatūru un pilnvaru autentifikāciju. Tagad tu tos apvienosi pilnībā funkcionējošā projektā. Serveris eksponē četrus uzdevumu pārvaldības rīkus — izveide, saraksta iegūšana, pabeigšana, dzēšana —, bet klients pieslēdzas attālināti, katrā pieprasījumā nosūtot bearer marķieri. Tas pats serveris pēc tam darbosies no Vibe bez nevienas papildu koda rindiņas: tieši šī ir attālināta servera priekšrocība salīdzinājumā ar STDIO serveri.

Serveris: task_server.py

Šajā vienīgajā failā līdzās pastāv trīs elementi. FastAPI nodrošina HTTP transportu un autentifikācijas starpprogrammatūru, MCPServer rūpējas par MCP protokolu un rīkiem, bet Python vārdnīca kalpo kā datubāze. Failu secībai ir nozīme: vispirms deklarē MCP serveri un tā rīkus, tad izveido FastAPI lietotni ar lifespan, kas palaiž sesiju pārvaldnieku, un visbeidzot pievieno serveri. Ņem vērā, ka starpprogrammatūra aizsargā ceļu /tasks, kurā tieši ir pievienots MCP serveris: šīm divām vērtībām ir jāsakrīt, pretējā gadījumā tev būs vai nu atvērtas durvis, vai norobežots ceļš.

# task_server.py
"""Attālināts MCP serveris ar marķiera autentifikāciju."""

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ācija ---
API_TOKEN = "mcp-secret-token-2026"

# --- Datubāze atmiņā ---
tasks_db: dict[str, dict] = {}

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

@mcp.tool()
def create_task(title: str, description: str = "", priority: str = "medium") -> str:
    """Izveido jaunu uzdevumu pārvaldniekā.

    Args:
        title: Uzdevuma nosaukums (obligāts, maks. 200 rakstzīmes)
        description: Detalizēts apraksts (neobligāts)
        priority: Prioritātes līmenis: low, medium, high (pēc noklusējuma: medium)

    Returns:
        JSON ar izveidotā uzdevuma ID un detaļām
    """
    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:
    """Iegūst uzdevumu sarakstu ar opcionaliem filtriem.

    Args:
        status: Filtrs pēc statusa: all, open, completed (pēc noklusējuma: all)
        priority: Filtrs pēc prioritātes: all, low, medium, high (pēc noklusējuma: all)

    Returns:
        JSON ar uzdevumu sarakstu un kopējo skaitu
    """
    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:
    """Atzīmē uzdevumu kā pabeigtu.

    Args:
        task_id: Uzdevuma unikālais identifikators

    Returns:
        Apstiprinājums par atjauninājumu vai kļūdas ziņojums
    """
    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:
    """Dzēš uzdevumu no pārvaldnieka.

    Args:
        task_id: Dzēšamā uzdevuma unikālais identifikators

    Returns:
        Apstiprinājums par dzēšanu vai kļūdas ziņojums
    """
    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)

# --- MCP servera pievienošana FastAPI ---
# streamable_http_app() ģenerē ASGI lietotni MCP serverim.
# Tās sesiju pārvaldniekam ir jābūt palaistam caur FastAPI lifespan,
# pretējā gadījumā serveris atbildēs, bet katrs rīka izsaukums neizdosies.
@asynccontextmanager
async def lifespan(app: FastAPI):
    async with mcp.session_manager.run():
        yield

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

# --- Autentifikācijas starpprogrammatūra ---
@api.middleware("http")
async def auth_middleware(request: Request, call_next):
    """Pārbauda marķieri visiem /tasks ceļiem."""
    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)

# Publiskais resursdatora nosaukums (ngrok, ražošanas domēns), deklarēts MCP serverim
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)

Divas implementācijas detaļas ir pelnījušas tavu uzmanību. Funkcijā create_task nosaukums tiek saīsināts līdz 200 rakstzīmēm, un prioritāte pēc noklusējuma tiek iestatīta uz medium, ja saņemtā vērtība nav atļauto sarakstā: modelis dažkārt piedāvā ticamas, bet ārpus līguma esošas vērtības, un rīkam ir jāpaliek stabilam, nekļūstot. Funkcijās complete_task un delete_task nezināms ID neizraisa izņēmumu, bet atgriež JSON kļūdas ziņojumu — modelis to var nolasīt, saprast savu kļūdu un formulēt atkārtoti, savukārt sabrukums to nepieļautu.

Servera palaišana un eksponēšana

# Pirmajā terminālī atver ngrok tuneli
ngrok http 8000
# Publiskais URL: https://xyz789.ngrok-free.app

# Otrajā terminālī palaid serveri, deklarējot šo resursdatora nosaukumu
MCP_PUBLIC_HOST=xyz789.ngrok-free.app python task_server.py

MCP galapunkts tad atrodas adresē https://xyz789.ngrok-free.app/tasks/mcp. Ņem vērā šīs adreses uzbūvi: ngrok nodrošinātais publiskais URL, kam seko pievienošanas ceļš /tasks, un tad SDK pievienotais sufikss /mcp. Neskaidrības par šo savienojumu ir galvenais savienojuma kļūmju cēlonis.

Klients: client_tasks.py

Klienta pusē nekas nemainās salīdzinājumā ar lokālu serveri, izņemot MCP klienta tipu un autentifikācijas galvenes pievienošanu. Tomēr aģents saņem instrukcijas, kas dabiskā valodā apraksta tā lomu — tas mudina to apstiprināt katru darbību, nevis klusi ķēdēt izsaukumus.

# client_tasks.py
"""MCP klients attālinātam uzdevumu serverim ar autentifikāciju."""

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

    # Izveido aģentu ar pielāgotām instrukcijām
    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."
        ),
    )

    # Konfigurē attālināto MCP klientu ar autentifikāciju
    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)

        # Saruna ar pārvaldnieku
        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())

Ziņojumu secība ir apzināta: tā savieno divas izveides, lasīšanu, atjaunināšanu un atkārtotu lasīšanu. Tas ir minimālais scenārijs, lai pārbaudītu, ka stāvoklis saglabājas no viena izsaukuma uz nākamo un ka modelis spēj iegūt iepriekš sarunas laikā izveidota uzdevuma ID. Ja ceturtā instrukcija neizdodas, problēma reti slēpjas serverī: tā parasti rodas tāpēc, ka list_tasks atbilde nepadarīja ID pietiekami redzamus.

Testēšana Mistral Vibe

To pašu galapunktu var pievienot tieši kā pielāgotu konektoru, nodrošinot testa saskarni, nerakstot klientu. Tas ir arī labākais veids, kā validēt savus docstringus: Vibe tos atklāšanas laikā parāda tādos, kādi tie ir, tāpēc tu uzreiz redzi, kas būs modeļa priekšā, lemjot, kuru rīku izsaukt.

  1. Dodies uz cilni Connectors vietnē Vibe
  2. Noklikšķini uz Add Custom Connector
  3. Ievadi Name kā Task Manager, URL kā https://xyz789.ngrok-free.app/tasks/mcp, tad izvēlies Auth: Token un ielīmē mcp-secret-token-2026
  4. Noklikšķini uz Connect

Vibe tad automātiski atklāj četrus rīkus, un tu vari sarunāties dabiskā valodā ar savu serveri.

Projekta organizācija un nākamie soļi

task-mcp-project/
├── task_server.py       # MCP serveris + FastAPI + auth
├── client_tasks.py      # Python klients ar aģentu
├── requirements.txt     # fastapi, uvicorn, mcp>=2.2,<3, mistralai[agents]
└── .env                 # MISTRAL_API_KEY, API_TOKEN

Šis skelets der prototipēšanai, taču divas lietas to diskvalificē ražošanas videi. Skaidrteksta marķieris pirmkodā ir jāpārvieto uz .env, un ngrok URL mainās katrā restartēšanas reizē, laužot visus konfigurētos konektorus. ngrok joprojām ir ideāls rīks idejas validēšanai minūšu laikā; pastāvīga izvietošana ar tās Docker, mākoņa un Hugging Face Spaces opcijām ir 12. nodarbības tēma.

Galvenās atziņas

  • Attālināts serveris apvieno FastAPI (HTTP) + MCPServer (MCP) + starpprogrammatūru (auth), publisko resursdatora nosaukumu deklarējot transport_security
  • Marķiera autentifikācija tiek apstrādāta, izmantojot galveni Authorization: Bearer ...
  • Klients MCPClientStreamableHTTP pieņem pielāgotas galvenes autentifikācijai
  • Tas pats serveris ir lietojams gan no Python SDK, gan no Mistral Vibe
  • ngrok ļauj ātri veidot prototipus pirms izvietošanas ražošanā