Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Voorbeeld: Lokale server met agent

Les 6 van 14 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. De onderdelen samenvoegen
  2. De server: weather_server.py
  3. De client: main.py
  4. Het project uitvoeren
  5. Zien hoe het antwoord tot stand komt
  6. Wanneer een tool faalt
  7. Belangrijkste punten

Bijgewerkt op 2 november 2026 — MCP Python SDK v2. Deze cursus volgt nu versie 2 van de mcp SDK (2.3.0 per 2 oktober 2026): MCPServer vervangt FastMCP, transportinstellingen verhuizen naar run() of streamable_http_app(), en een app die onder een echte hostnaam wordt blootgesteld, moet die hostnaam declareren (transport_security). Dit is ook de versie die vereist is door de Mistral SDK: de mistralai[agents] extra vereist mcp>=2.2.0,<3.0. Bronnen: Wat is nieuw in v2 · Migratiegids · Implementeren & schalen. Addendum 3 november: lees het resultaat van een run_async via result.output_as_text (de mistralai SDK 3.7.0 heeft geen output-attribuut), en in streaming-modus is het laatste evenement een RunResult, geïdentificeerd met isinstance, zoals in het officiële SDK-voorbeeld.

De onderdelen samenvoegen

Eerdere lessen hebben de bouwstenen afzonderlijk uiteengezet: de server en zijn tools, de client en zijn RunContext. Nu voegt u ze samen tot een werkend project: een lokale MCP-server die weersinformatie biedt, aangestuurd door een Mistral-agent die vragen in natuurlijke taal kan beantwoorden. Lees de code, maar let vooral op wat elk onderdeel beslist: de server bepaalt wat mogelijk is, de agent bepaalt wat relevant is.

De server: weather_server.py

Deze server bestaat uit drie tools. De eerste geeft het weer voor een stad terug, de tweede vergelijkt twee steden en de derde somt op wat de database bevat. Die laatste is niet louter decoratief: hij geeft het model een manier om de beschikbare reikwijdte te ontdekken in plaats van stadsnamen te raden.

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

Twee ontwerpdetails verdienen aandacht. De tools normaliseren invoer met .lower().strip() omdat het model “Paris” of “paris” kan schrijven, afhankelijk van de formulering van de gebruiker. En wanneer een stad ontbreekt, gooit get_weather geen uitzondering: het retourneert een JSON-fout die bekende steden opsomt, waardoor een mislukking wordt omgezet in informatie die het model kan gebruiken.

De client: main.py

De client doet vier dingen op volgorde: Mistral initialiseren, de agent aanmaken, beschrijven hoe de server moet worden gestart en vervolgens de RunContext openen om gesprekken te ketenen.

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

Let op het serverpad: Path(__file__).parent / "weather_server.py" lokaliseert het bestand relatief ten opzichte van het script in plaats van de huidige map. Dit is de enige manier om te garanderen dat de start werkt, ongeacht vanaf welke locatie u python main.py uitvoert.

Het project uitvoeren

# Set API key
export MISTRAL_API_KEY="your_mistral_api_key"

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

U start slechts één proces. De client maakt de Mistral-agent aan, de RunContext start weather_server.py als een STDIO-proces, ontdekt de drie tools—get_weather, compare_weather en list_cities—en laat vervolgens, vraag voor vraag, het model kiezen welke het moet aanroepen voordat het de resultaten in zijn antwoord integreert. De derde vraag in het voorbeeld is het meest interessant om te observeren: om te weten welke stad het warmst is, heeft het model geen andere keuze dan list_cities te gebruiken, ook al suggereert geen enkel woord in de vraag dit.

Zien hoe het antwoord tot stand komt

Wachten op het volledige antwoord werkt voor een script; wanneer u een gebruiker tegenover zich heeft, biedt de streaming-modus een veel betere ervaring.

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

De evenementenstroom dient niet alleen voor weergave: het is ook uw beste debugtool, omdat het tool-aanroepen en argumenten die door het model zijn gekozen, in realtime zichtbaar maakt.

Wanneer een tool faalt

Dankzij continue_on_fn_error=True breekt een verzoek buiten de reikwijdte niets. Als de gebruiker om het weer in Tokio vraagt, retourneert get_weather zijn JSON-fout, leest het model deze en kaatst terug door de daadwerkelijk beschikbare steden voor te stellen.

# 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..."

Uiteindelijk past het project in vier bestanden, waarvan er slechts twee logica bevatten:

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=...

Belangrijkste punten

  • Een compleet MCP-project = server (tools) + client (agent + RunContext)
  • De server definieert tools met MCPServer en @app.tool()-decorators
  • De client maakt de agent aan, opent de RunContext en start gesprekken
  • De streaming-modus maakt progressieve weergave mogelijk
  • continue_on_fn_error=True behandelt tool-fouten op een gracieuze manier
  • Alle code is asynchroon—gebruik asyncio.run() als instappunt