Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Eksempel i fuld længde: Fjernserver med godkendelse

Lektion 9 af 14 Opdateret 3. november 2026 Udvikler
På denne side
  1. Scenarie: En MCP-server til opgavehåndtering
  2. Serveren: task_server.py
  3. Start og eksponér serveren
  4. Klienten: client_tasks.py
  5. Test i Mistral Vibe
  6. Projektorganisation og næste skridt
  7. Vigtige pointer

Opdatering 2. november 2026 — Le Chat er nu Vibe. Fra den 28. maj 2026 er Le Chat blevet omdøbt til Vibe (stadig på chat.mistral.ai): en enkelt agent til arbejde og kode, der viderefører dine samtaler, indstillinger og abonnementer. Den ældre Le Chat-oplevelse forbliver tilgængelig i Chat-tilstand; i Work-tilstand er agenter nu færdigheder (kaldes med @), hukommelser fungerer som vidensbase, og dyb søgning er færdigheden Deep Research. Abonnementer hedder nu Mistral Free, Pro, Team og Enterprise. Denne lektion bruger navnet Vibe; nogle menuer beskrevet her kan have ændret navn eller placering. Tillæg 3. november: Resultater fra run_async læses fra result.output_as_text; mistralai SDK 3.7.0 har ikke attributten output.

Opdatering 2. november 2026 — MCP Python SDK v2. Dette kursus følger nu version 2 af mcp-SDK’et (2.3.0 pr. 2. oktober 2026): MCPServer erstatter FastMCP, transportindstillinger flyttes til run() eller streamable_http_app(), og en app, der eksponeres under et rigtigt værtsnavn, skal erklære dette værtsnavn (transport_security). Dette er også den version, der kræves af Mistral SDK: mistralai[agents]-ekstraktionen kræver mcp>=2.2.0,<3.0. Kilder: Hvad er nyt i v2 · Migrationsguide · Deploy & scale.

Scenarie: En MCP-server til opgavehåndtering

Tidligere lektioner har dækket de enkelte dele: HTTP-transport, middleware og token-godkendelse. Nu skal du samle dem til et fuldt funktionelt projekt. Serveren eksponerer fire værktøjer til opgavehåndtering – opret, list, fuldfør, slet – og klienten forbinder eksternt og præsenterer et bearer-token med hver anmodning. Denne samme server kører derefter fra Vibe uden en eneste ekstra linje kode: det er hele fordelen ved en fjernserver frem for en STDIO-server.

Serveren: task_server.py

Tre elementer sameksisterer i denne ene fil. FastAPI håndterer HTTP-transport og godkendelses-middleware, MCPServer håndterer MCP-protokollen og værktøjerne, og en Python-ordbog fungerer som database. Rækkefølgen i filen betyder noget: erklær først MCP-serveren og dens værktøjer, opret derefter FastAPI-appen med den lifespan, der starter sessionshåndteringen, og mount serveren til sidst. Bemærk, at middlewaren beskytter stien /tasks, hvilket er præcis dér, hvor MCP-serveren er monteret: disse to værdier skal matche, ellers ender du enten med en åben dør eller en afspærret sti.

# 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)

To implementeringsdetaljer fortjener din opmærksomhed. I create_task bliver titlen trunkeret til 200 tegn, og prioriteten sættes som standard til medium, hvis den modtagne værdi ikke findes på listen over tilladte værdier: modellen foreslår nogle gange plausible værdier, der ligger uden for kontrakten, og værktøjet skal forblive robust uden at fejle. I complete_task og delete_task udløser et ukendt ID ikke en undtagelse, men returnerer en JSON-fejlmeddelelse – modellen kan læse dette, forstå sin fejl og formulere sig om, hvorimod et nedbrud ville forhindre dette.

Start og eksponér serveren

# I en første terminal åbnes ngrok-tunnelen
ngrok http 8000
# Offentlig URL: https://xyz789.ngrok-free.app

# I en anden terminal startes serveren med erklæring af dette værtsnavn
MCP_PUBLIC_HOST=xyz789.ngrok-free.app python task_server.py

MCP-endepunktet befinder sig derefter på https://xyz789.ngrok-free.app/tasks/mcp. Bemærk sammensætningen af denne adresse: den offentlige URL leveret af ngrok, efterfulgt af mount-stien /tasks, og derefter suffikset /mcp tilføjet af SDK’et. Forvirring omkring denne sammenkædning er den hyppigste årsag til forbindelsesfejl.

Klienten: client_tasks.py

På klientsiden ændres intet i forhold til en lokal server bortset fra MCP-klienttypen og tilføjelsen af godkendelsesheadere. Agenten modtager dog instrukser, der beskriver dens rolle på naturligt sprog – dette opfordrer den til at bekræfte hver handling i stedet for stille at kæde kald sammen.

# 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())

Beskedsekvensen er bevidst: den kæder to oprettelser, en læsning, en opdatering og en genlæsning sammen. Dette er det minimale scenarie for at verificere, at tilstanden overlever fra det ene kald til det næste, og at modellen kan hente ID’et på en opgave, der blev oprettet tidligere i samtalen. Hvis den fjerde instruktion fejler, ligger dit problem sjældent hos serveren: det skyldes oftest, at svaret fra list_tasks ikke gør ID’erne synlige nok.

Test i Mistral Vibe

Det samme endepunkt kan tilføjes direkte som et brugerdefineret stik, hvilket giver dig et testgrænseflade uden at skulle skrive en klient. Dette er også den bedste måde at validere dine docstrings på: Vibe viser dem, som de er, under opdagelse, så du med det samme ser, hvad modellen har foran sig for at beslutte, hvilket værktøj der skal kaldes.

  1. Gå til fanen Connectors i Vibe
  2. Klik på Add Custom Connector
  3. Indtast Name som Task Manager, URL som https://xyz789.ngrok-free.app/tasks/mcp, og vælg derefter Auth: Token og indsæt mcp-secret-token-2026
  4. Klik på Connect

Vibe opdager derefter automatisk de fire værktøjer, og du kan conversere på naturligt sprog med din egen server.

Projektorganisation og næste skridt

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

Dette skelet fungerer til prototyping, men to ting diskvalificerer det til produktion. Tokenet i klartekst i kildekoden skal flyttes til .env, og ngrok-URL’en ændres ved hver genstart, hvilket bryder alle konfigurerede stik. ngrok forbliver det ideelle værktøj til at validere en idé på få minutter; permanent hosting med sine muligheder for Docker, cloud og Hugging Face Spaces er emnet for lektion 12.

Vigtige pointer

  • En fjernserver kombinerer FastAPI (HTTP) + MCPServer (MCP) + middleware (godkendelse), hvor det offentlige værtsnavn erklæres i transport_security
  • Token-godkendelse håndteres via headere Authorization: Bearer ...
  • Klienten MCPClientStreamableHTTP accepterer brugerdefinerede headers til godkendelse
  • Den samme server kan bruges fra både Python SDK og Mistral Vibe
  • ngrok muliggør hurtig prototyping før produktionsudrulning