Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Eksempel i fuld længde: Lokal server med agent

Lektion 6 af 14 Opdateret 3. november 2026 Udvikler
På denne side
  1. Samling af brikkerne
  2. Serveren: weather_server.py
  3. Klienten: main.py
  4. Kørsel af projektet
  5. At se svaret bygges op
  6. Når et værktøj fejler
  7. Vigtige pointer

Opdateret 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 deklarere dette værtsnavn (transport_security). Dette er også den version, som Mistral SDK kræver: mistralai[agents]-ekstrapakken kræver mcp>=2.2.0,<3.0. Kilder: Hvad er nyt i v2 · Migrationsguide · Deploy & scale. Tillæg 3. november: læs resultatet af en run_async fra result.output_as_text (Mistralai SDK 3.7.0 har ingen output-attribut), og i streaming-tilstand er den sidste begivenhed en RunResult, identificeret med isinstance, som i det officielle SDK-eksempel.

Samling af brikkerne

Tidligere lektioner har lagt byggestenene frem separat: serveren og dens værktøjer, klienten og dens RunContext. Nu skal du samle dem til et fungerende projekt – en lokal MCP-server, der leverer vejrinformation, drevet af en Mistral-agent, der kan besvare spørgsmål på naturligt sprog. Læs koden, men vær særligt opmærksom på, hvad hver del beslutter: serveren beslutter, hvad der er muligt, og agenten beslutter, hvad der er relevant.

Serveren: weather_server.py

Denne server består af tre værktøjer. Det første returnerer vejret for en by, det andet sammenligner to byer, og det tredje lister, hvad databasen indeholder. Det sidste er ikke blot dekorativt: det giver modellen en måde at opdage det tilgængelige omfang på i stedet for at gætte bynavne.

# weather_server.py
"""Local MCP server providing weather tools."""

from mcp.server.mcpserver import MCPServer
import json

app = MCPServer("Weather Service")

# Simulated database
WEATHER_DATA = {
    "paris": {"temp": 18.5, "condition": "Cloudy", "humidity": 72},
    "lyon": {"temp": 22.0, "condition": "Sunny", "humidity": 45},
    "marseille": {"temp": 25.3, "condition": "Sunny", "humidity": 38},
    "lille": {"temp": 14.2, "condition": "Rainy", "humidity": 88},
    "bordeaux": {"temp": 20.1, "condition": "Partly cloudy", "humidity": 55},
}

@app.tool()
def get_weather(city: str) -> str:
    """Retrieves current weather for a French city.

    Args:
        city: City name in lowercase (paris, lyon, marseille, etc.)

    Returns:
        JSON with temperature, condition, and humidity.
        Returns an error if the city is unknown.
    """
    city_lower = city.lower().strip()
    if city_lower in WEATHER_DATA:
        data = WEATHER_DATA[city_lower]
        return json.dumps({
            "city": city.capitalize(),
            "temperature_celsius": data["temp"],
            "condition": data["condition"],
            "humidity_percent": data["humidity"],
        }, ensure_ascii=False)
    return json.dumps({"error": f"City {city} not found. Available cities: {', '.join(WEATHER_DATA.keys())}"})

@app.tool()
def compare_weather(city_a: str, city_b: str) -> str:
    """Compares weather between two French cities.

    Args:
        city_a: First city (lowercase)
        city_b: Second city (lowercase)

    Returns:
        Comparison of temperatures and conditions for both cities
    """
    a = WEATHER_DATA.get(city_a.lower().strip())
    b = WEATHER_DATA.get(city_b.lower().strip())
    if not a:
        return f"Unknown city: {city_a}"
    if not b:
        return f"Unknown city: {city_b}"

    diff = a["temp"] - b["temp"]
    warmer = city_a if diff > 0 else city_b
    return json.dumps({
        "city_a": {"name": city_a.capitalize(), **a},
        "city_b": {"name": city_b.capitalize(), **b},
        "temperature_difference": abs(diff),
        "warmer_city": warmer.capitalize(),
    }, ensure_ascii=False)

@app.tool()
def list_cities() -> str:
    """Lists all cities available in the weather database.

    Returns:
        List of cities with their current temperature
    """
    cities = [
        {"city": k.capitalize(), "temp": v["temp"], "condition": v["condition"]}
        for k, v in WEATHER_DATA.items()
    ]
    return json.dumps(cities, ensure_ascii=False)

To designdetaljer fortjener opmærksomhed. Værktøjerne normaliserer input med .lower().strip(), fordi modellen kan skrive „Paris” eller „paris” afhængigt af brugerens formulering. Og når en by mangler, kaster get_weather ikke en undtagelse: den returnerer en fejl i JSON-format, der oplister kendte byer, hvilket gør en fiasko til information, som modellen kan bruge.

Klienten: main.py

Klienten gør fire ting i rækkefølge: instantierer Mistral, opretter agenten, beskriver hvordan serveren startes, og åbner derefter RunContext for at kæde samtaler sammen.

# main.py
"""MCP client with Mistral agent for weather queries."""

import asyncio
import os
from pathlib import Path

from mistralai.client import Mistral
from mistralai.extra.run.context import RunContext
from mistralai.extra.mcp.stdio import MCPClientSTDIO
from mcp import StdioServerParameters
from pydantic import BaseModel

# Configuration
MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
SERVER_PATH = Path(__file__).parent / "weather_server.py"

# Structured output format (optional)
class WeatherResponse(BaseModel):
    summary: str
    details: dict | None = None

async def main():
    # 1. Initialize Mistral client
    client = Mistral(api_key=MISTRAL_API_KEY)

    # 2. Create the agent
    agent = client.beta.agents.create(
        model="mistral-medium-latest",
        name="weather-assistant",
        instructions=(
            "You are a weather assistant for France. "
            "Use available tools to answer questions. "
            "Always respond in French with metric units."
        ),
    )

    # 3. Configure local MCP server
    server_params = StdioServerParameters(
        command="python",
        args=[str(SERVER_PATH)],
        env=None,
    )
    mcp_client = MCPClientSTDIO(stdio_params=server_params)

    # 4. Open context and register MCP client
    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)

        # 5. Launch conversations
        questions = [
            "What's the weather like in Paris?",
            "Compare the weather between Marseille and Lille.",
            "Which city is the warmest right now?",
        ]

        for question in questions:
            print(f"\n{'='*60}")
            print(f"Question: {question}")
            print(f"{'='*60}")

            result = await client.beta.conversations.run_async(
                run_ctx=run_ctx,
                inputs=question,
            )

            print(f"Response: {result.output_as_text}")

    # 6. Automatic cleanup upon exiting context manager
    print("\nAgent and MCP server closed cleanly.")

if __name__ == "__main__":
    asyncio.run(main())

Bemærk stien til serveren: Path(__file__).parent / "weather_server.py" lokaliserer filen i forhold til scriptet snarere end den aktuelle mappe. Dette er den eneste måde at garantere, at opstarten virker, uanset hvor du kører python main.py fra.

Kørsel af projektet

# Set API key
export MISTRAL_API_KEY="your_mistral_api_key"

# Launch client (it will launch the server automatically)
python main.py

Du starter kun én proces. Klienten opretter Mistral-agenten, RunContext starter weather_server.py som en STDIO-proces, opdager de tre værktøjer – get_weather, compare_weather og list_cities – og lader derefter modellen vælge, hvilke den skal kalde, spørgsmål for spørgsmål, før den integrerer resultaterne i sit svar. Det tredje spørgsmål i eksemplet er det mest interessante at observere: for at vide, hvilken by der er varmest, har modellen intet andet valg end at gå via list_cities, selv om intet ord i spørgsmålet antyder det.

At se svaret bygges op

At vente på det komplette svar fungerer til et script; over for en bruger giver streaming-tilstand en langt bedre oplevelse.

from mistralai.extra.run.result import RunResult

async with RunContext(agent_id=agent.id) as run_ctx:
    await run_ctx.register_mcp_client(mcp_client=mcp_client)

    events = await client.beta.conversations.run_stream_async(
        run_ctx=run_ctx,
        inputs="What's the weather like in Lyon?",
    )

    async for event in events:
        if isinstance(event, RunResult):
            # Last event: complete run result
            print(event.output_as_text)
        else:
            # Intermediate events (tool calls, etc.)
            print(f"[Event] {event}")

Begivenhedsstrømmen er ikke kun til visning: det er også dit bedste fejlfindingsværktøj, da den afslører værktøjskald og argumenter, som modellen vælger i realtid.

Når et værktøj fejler

Takket være continue_on_fn_error=True bryder en anmodning uden for omfanget ikke noget. Hvis brugeren spørger om vejret i Tokyo, returnerer get_weather sin fejl i JSON-format, modellen læser den og svarer igen ved at foreslå de faktisk tilgængelige byer.

# If the user requests a non-existent city:
# → get_weather returns {"error": "City tokyo not found..."}
# → The model reads the error and reformulates its response
# → "I'm sorry, Tokyo is not in my database. Here are the available cities..."

I sidste ende passer projektet i fire filer, hvoraf kun to indeholder logik:

weather-mcp-project/
├── weather_server.py    # MCP server (3 tools)
├── main.py              # Client with Mistral agent
├── requirements.txt     # mcp>=2.2,<3, mistralai[agents], pydantic
└── .env                 # MISTRAL_API_KEY=...

Vigtige pointer

  • Et komplet MCP-projekt = server (værktøjer) + klient (agent + RunContext)
  • Serveren definerer værktøjer med MCPServer og @app.tool()-dekuratorer
  • Klienten opretter agenten, åbner RunContext og starter samtaler
  • Streaming-tilstand muliggør progressiv visning
  • continue_on_fn_error=True håndterer værktøjsfejl elegant
  • Al kode er asynkron – brug asyncio.run() som indgangspunkt