Lähe põhisisu juurde
Eesti— Vali keel
Menüü

RunContext: haldab MCP klienti ja agenti

Õppetund 5 / 14 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Sinu agendi dirigent
  2. Agendi loomine
  3. Konteksti avamine
  4. MCP kliendi registreerimine
  5. Lokaalsete funktsioonide lisamine
  6. Vestluse alustamine
  7. Peamised punktid

Sinu agendi dirigent

RunContext on komponent, mis hoiab kõike koos. See ühendab sinu tehisintellekti agendi MCP serveritega ja haldab kogu nende elutsüklit: serveritega ühenduse loomine, tööriistade registreerimine, vestluste käivitamine, tulemuste hankimine ja korrektne sulgemine. Mistrali SDK-s on see asünkroonne kontekstihaldur, mis kapseldab kogu selle loogika. Sa avad ploki, määratled, mida agent tohib kasutada, pead vestlust ja väljumisel sulgeb süsteem kõik automaatselt.

Agendi loomine

RunContext ei loo agenti; see seostub olemasolevaga. Sinu esimene samm on seega agendi loomine API kaudu.

from mistralai.client import Mistral

# Lähtesta Mistrali klient
client = Mistral(api_key="YOUR_API_KEY")

# Loo agent
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}")

See agent on Mistrali poolt püsiv üksus: sellel on mudel, nimi ja süsteemi juhised ning see jääb alles ka pärast skripti lõppu. MCP tööriistad aga ei ole agendiga seotud. RunContext pakub need dünaamiliselt iga käivituse jaoks. See lahtisidumine võimaldab sul käivitada sama agenti erinevate tööriistadega sõltuvalt kontekstist.

Konteksti avamine

Kasuta RunContext-i koos async with-ga, mis tagab ressursside vabastamise isegi erindi tekkimisel.

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

# Valikuline: defineeri struktureeritud väljundformaad
class WeatherResult(BaseModel):
    location: str
    temperature: float
    description: str

async with RunContext(
    agent_id=agent.id,
    output_format=WeatherResult,      # Struktureeritud formaat (valikuline)
    continue_on_fn_error=True,         # Jätka, kui tööriist tõrgub
) as run_ctx:
    # Siin registreeri MCP kliendid ja alusta vestlusi
    pass

Seda käitumist juhib kolm parameetrit. agent_id määrab varem loodud agendi. output_format aktsepteerib Pydantic’i mudelit ja piirab lõppvastuse sellele struktuurile – see on väärtuslik, kui väljund suunatakse teisele programmile, mitte inimesele. Lõpuks määrab continue_on_fn_error, mis juhtub vestlusega, kui tööriist viskab vea: kui väärtus on True, jätkub kontekst ja mudel saab veateate samamoodi nagu tulemuse.

MCP kliendi registreerimine

Kui kontekst on avatud, deklareerid selles oma MCP kliendid.

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

# Konfigureeri lokaalne 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:
    # Registreeri MCP klient
    await run_ctx.register_mcp_client(mcp_client=mcp_client)

See üksainus väljakutse register_mcp_client käivitab täieliku jada: serveriprotsessi käivitamine STDIO režiimis, võimete läbirääkimine, tööriistade loendi hankimine ja nende tööriistade kättesaadavaks tegemine mudelile eelseisvateks vestlusteks. Seda ei pea sa käsitsi kirjutama.

Sa ei ole piiratud ka ühe serveriga. Üks RunContext võib koondada mitmeid allikaid ja mudel näeb nende tööriistade ühendit ühtse kataloogina:

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)

Lokaalsete funktsioonide lisamine

Iga võimekus ei pea saama MCP serveriks. Lühikese, ainult sellele skriptile omase funktsiooni mudelile standardse tööriistana eksponiseerimiseks piisab dekoraatorist register_func.

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

Mudeli seisukohalt vahet pole: ta näeb lihtsalt üht tööriista juurde. Erinevus on sinu jaoks – need funktsioonid jooksevad sinu Pythoni protsessis ilma välise serverita, mistõttu ei saa neid väljaspool seda skripti uuesti kasutada.

Vestluse alustamine

Kui kontekst on täidetud, tuleb vaid rääkima hakata.

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

    # Sünkroonne täitmine (ootab täielikku vastust)
    run_result = await client.beta.conversations.run_async(
        run_ctx=run_ctx,
        inputs="What is the weather in Paris?",
    )

    print(run_result.output)

Selle väljakutse taga analüüsib mudel küsimust, konsulteerib olemasolevate tööriistadega – nii MCP serveritest kui ka lokaalsetest funktsioonidest –, kutsub need, mida ta peab vajalikuks, ja koostab seejärel oma vastuse saadud tulemuste põhjal.

Kogu tsükkel näeb välja selline:

1. Loo agent (client.beta.agents.create)
       ↓
2. Ava RunContext (async with RunContext)
       ↓
3. Registreeri MCP kliendid (register_mcp_client)
       ↓
4. Registreeri lokaalsed funktsioonid (register_func)
       ↓
5. Alusta vestlusi (conversations.run_async)
       ↓
6. Automaatne puhastus (kontekstihalduri lõpp)

Kui plokist väljud, peatab kontekst kõik käivitatud STDIO serveriprotsessid – pärast erindit ei jää rippuma ühtegi üksikut Pythoni protsessi.

Lõpetuseks mõned sõnad continue_on_fn_error=True kohta, mille väärtus avaldub kõige selgemini tootmiskeskkonnas. Ilma selleta katkestab vähimgi viga tööriistas kogu vestluse, jättes kasutaja silmitsema erindit. Sellega saab mudel veast selge ülevaate ja tal on manööverdamisruumi: ta saab oma päringu ümber sõnastada teiste argumentidega, lülituda teisele tööriistale või lihtsalt selgitada kasutajale, mis nurjus. Agent, mis ütleb „ilmateenistus ei vasta“, on lõpmatult parem kui agent, mis kokku jookseb.

Peamised punktid

  • RunContext orkestreerib suhtlust agendi ja MCP serverite vahel
  • Kasuta seda kui async with kontekstihaldurit
  • register_mcp_client ühendab MCP serveri ja avastab selle tööriistad
  • register_func registreerib lokaalsed Pythoni funktsioonid tööriistadena
  • continue_on_fn_error=True tagab sinu agendi vastupidavuse
  • Kogu töövoog on asünkroonne (async/await)