Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

RunContext: Beheer van de MCP-client en de agent

Les 5 van 14 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. De dirigent van uw agent
  2. De agent aanmaken
  3. De context openen
  4. Een MCP-client registreren
  5. Lokale functies toevoegen
  6. De conversatie starten
  7. Belangrijkste punten

De dirigent van uw agent

De RunContext is het onderdeel dat alles bij elkaar houdt. Het verbindt uw AI-agent met MCP-servers en beheert hun volledige levenscyclus: verbinding maken met servers, tools registreren, conversaties uitvoeren, resultaten ophalen en netjes afsluiten. In de Mistral SDK neemt dit de vorm aan van een asynchrone contextmanager die al deze logica kapselt. U opent een blok, declareert wat de agent mag gebruiken, voert uw conversatie en alles sluit automatisch wanneer u het blok verlaat.

De agent aanmaken

De RunContext maakt de agent niet aan; hij koppelt zich eraan. Uw eerste stap is daarom het instantiëren van een agent via de API.

from mistralai.client import Mistral

# Initialiseer de Mistral-client
client = Mistral(api_key="YOUR_API_KEY")

# Maak een agent aan
agent = client.beta.agents.create(
    model="mistral-medium-latest",
    name="assistant-mcp",
    instructions="You are an assistant capable of using MCP tools.",
)

print(f"Agent created: {agent.id}")

Deze agent is een persistente entiteit aan de kant van Mistral: hij heeft een model, een naam en systeeminstructies, en hij blijft bestaan buiten uw script om. MCP-tools zijn echter niet aan de agent gekoppeld. In plaats daarvan levert de RunContext deze dynamisch bij elke uitvoering. Deze ontkoppeling stelt u in staat dezelfde agent met verschillende tools te gebruiken, afhankelijk van de context.

De context openen

U gebruikt RunContext met async with, wat garandeert dat resources worden vrijgegeven, zelfs als er een uitzondering optreedt.

from mistralai.extra.run.context import RunContext
from pydantic import BaseModel

# Optioneel: definieer een gestructureerde uitvoerindeling
class WeatherResult(BaseModel):
    location: str
    temperature: float
    description: str

async with RunContext(
    agent_id=agent.id,
    output_format=WeatherResult,      # Gestructureerde indeling (optioneel)
    continue_on_fn_error=True,         # Doorgaan als een tool faalt
) as run_ctx:
    # Registreer hier MCP-clients en start conversaties
    pass

Drie parameters sturen dit gedrag. agent_id specificeert de agent die u eerder hebt aangemaakt. output_format accepteert een Pydantic-model en beperkt het eindantwoord tot die structuur; dit is waardevol wanneer de uitvoer door een ander programma wordt verwerkt in plaats van door een mens. Tot slot bepaalt continue_on_fn_error wat er met de conversatie gebeurt wanneer een tool een fout veroorzaakt: als deze op True staat, gaat de context door en ontvangt het model het foutbericht net zoals een resultaat.

Een MCP-client registreren

Zodra de context geopend is, declareert u uw MCP-clients binnen deze context.

from mcp import StdioServerParameters
from mistralai.extra.mcp.stdio import MCPClientSTDIO

# Configureer de lokale server
server_params = StdioServerParameters(
    command="python",
    args=["weather_server.py"],
)
mcp_client = MCPClientSTDIO(stdio_params=server_params)

async with RunContext(
    agent_id=agent.id,
    continue_on_fn_error=True,
) as run_ctx:
    # Registreer de MCP-client
    await run_ctx.register_mcp_client(mcp_client=mcp_client)

Deze ene aanroep van register_mcp_client activeert een volledige reeks acties: het starten van het serverproces in STDIO-modus, het onderhandelen over mogelijkheden, het ophalen van de lijst met tools en het beschikbaar stellen van die tools aan het model voor aankomende conversaties. U hoeft dit niet handmatig te schrijven.

U bent ook niet beperkt tot één server. Een enkele RunContext kan meerdere bronnen aggregeren, en het model ziet de vereniging van hun tools als één enkele catalogus:

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

Lokale functies toevoegen

Niet elke mogelijkheid hoeft een MCP-server te worden. Voor een korte functie die specifiek is voor dit script, volstaat de register_func-decorator om deze als standaardtool aan het model bloot te stellen.

import random

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

    @run_ctx.register_func
    def get_user_location(username: str) -> str:
        """Retrieves a user's location.

        Args:
            username: The username

        Returns:
            The user's city
        """
        locations = {"alice": "Paris", "bob": "Lyon", "charlie": "Marseille"}
        return locations.get(username, "Unknown")

Vanuit het perspectief van het model is er geen verschil: het ziet simpelweg één tool extra. Het verschil ligt bij u: deze functies draaien in uw Python-proces, zonder externe server, waardoor ze buiten dit script niet herbruikbaar zijn.

De conversatie starten

Zodra de context is gevuld, hoeft u alleen nog maar te praten.

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

    # Synchrone uitvoering (wacht op het volledige antwoord)
    run_result = await client.beta.conversations.run_async(
        run_ctx=run_ctx,
        inputs="What is the weather in Paris?",
    )

    print(run_result.output)

Achter deze aanroep analyseert het model de vraag, raadpleegt het de beschikbare tools (zowel van MCP-servers als lokale functies), roept het de tools aan die het noodzakelijk acht en stelt het vervolgens zijn antwoord op basis van de verkregen resultaten.

De volledige cyclus ziet er als volgt uit:

1. Maak de agent aan (client.beta.agents.create)
       ↓
2. Open de RunContext (async with RunContext)
       ↓
3. Registreer MCP-clients (register_mcp_client)
       ↓
4. Registreer lokale functies (register_func)
       ↓
5. Start conversaties (conversations.run_async)
       ↓
6. Automatische opruiming (einde van contextmanager)

Wanneer u het blok verlaat, stopt de context alle STDIO-serverprocessen die hij heeft gestart; er blijven geen verweesde Python-processen achter na een uitzondering.

Tot slot nog een woord over continue_on_fn_error=True, waarvan de waarde in productie het duidelijkst naar voren komt. Zonder dit onderbreekt de kleinste fout in een tool de hele conversatie, waardoor de gebruiker naar een uitzondering staart. Met deze instelling ontvangt het model de fout duidelijk en heeft het ruimte om te manoeuvreren: het kan zijn verzoek herformuleren met andere argumenten, terugvallen op een andere tool, of de gebruiker eenvoudig uitleggen wat er misging. Een agent die zegt “de weerdienst reageert niet” is oneindig veel beter dan een agent die crasht.

Belangrijkste punten

  • De RunContext orchestreert de communicatie tussen de agent en MCP-servers
  • Gebruik het als een async with-contextmanager
  • register_mcp_client verbindt een MCP-server en ontdekt de tools ervan
  • register_func registreert lokale Python-functies als tools
  • continue_on_fn_error=True zorgt voor de veerkracht van uw agent
  • De volledige workflow is asynchroon (async/await)