Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

RunContext: Upravljanje odjemalca MCP in agenta

Lekcija 5 od 14 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Dirigent tvojega agenta
  2. Ustvari agenta
  3. Odpri kontekst
  4. Registriraj odjemalca MCP
  5. Dodaj lokalne funkcije
  6. Začni pogovor
  7. Ključne ugotovitve

Dirigent tvojega agenta

RunContext je komponenta, ki drži vse skupaj. Povezuje tvojega agenta umetne inteligence s strežniki MCP in upravlja celoten življenjski cikel: povezavo s strežniki, registracijo orodij, izvajanje pogovorov, pridobivanje rezultatov in urejeno zaustavitev. V SDK-ju Mistral ima obliko asinhronega upravitelja konteksta, ki zajema vso to logiko. Odpreš blok, določiš, kaj sme agent uporabljati, opraviš pogovor in ob izhodu se vse samodejno zapre.

Ustvari agenta

RunContext ne ustvarja agenta; nanj se le priklopi. Tvoj prvi korak je torej vzpostavitev instanc agenta prek API-ja.

from mistralai.client import Mistral

# Inicializiraj odjemalca Mistral
client = Mistral(api_key="YOUR_API_KEY")

# Ustvari agenta
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}")

Ta agent je trajen entitet na strani Mistrala: ima model, ime in sistemska navodila ter preživi konec tvojega skripta. Orodja MCP pa niso pripeta agentu. Namesto tega jih RunContext zagotavlja dinamično ob vsakem izvajanju. Ta ločenost ti omogoča, da istega agenta poganjaš z različnimi orodji glede na kontekst.

Odpri kontekst

RunContext uporabljaš z async with, kar zagotavlja sprostitev virov, tudi če pride do izjeme.

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

# Izbirno: definiranje strukturirane oblike izhoda
class WeatherResult(BaseModel):
    location: str
    temperature: float
    description: str

async with RunContext(
    agent_id=agent.id,
    output_format=WeatherResult,      # Strukturirana oblika (izbirno)
    continue_on_fn_error=True,         # Nadaljuj, če orodje odpove
) as run_ctx:
    # Tu registriraj odjemalce MCP in začni pogovore
    pass

Trije parametri nadzorujejo to vedenje. agent_id določa agenta, ki si ga ustvaril prej. output_format sprejme model Pydantic in omeji končni odgovor na to strukturo – kar je dragoceno, ko izhod napaja drug program in ne človeka. Nazadnje, continue_on_fn_error odloča, kaj se zgodi s pogovorom, ko orodje sproži napako: če je nastavljeno na True, se kontekst nadaljuje in model prejme sporočilo o napaki enako kot rezultat.

Registriraj odjemalca MCP

Ko je kontekst odprt, v njem deklariraš svoje odjemalce MCP.

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

# Konfiguriraj lokalni strežnik
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:
    # Registriraj odjemalca MCP
    await run_ctx.register_mcp_client(mcp_client=mcp_client)

Ta en sam klic register_mcp_client sproži popolno zaporedje: zagon procesa strežnika v načinu STDIO, pogajanje o zmožnostih, pridobitev seznama orodij in omogočitev teh orodij modelu za prihajajoče pogovore. Tega ti ni treba pisati ročno.

Prav tako nisi omejen na en sam strežnik. En sam RunContext lahko združi več virov, model pa vidi unijo njihovih orodij kot en sam katalog:

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)

Dodaj lokalne funkcije

Ni vsaka zmožnost potrebna postati strežnik MCP. Za kratko funkcijo, specifično za ta skript, zadostuje okrasek register_func, da jo izpostaviš modelu kot standardno orodje.

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

Z vidika modela ni razlike: preprosto vidi še eno orodje. Razlika je zate – te funkcije se izvajajo v tvojem procesu Python, brez zunanjega strežnika, zato jih ni mogoče ponovno uporabiti zunaj tega skripta.

Začni pogovor

Ko je kontekst napolnjen, preostane le še pogovor.

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

    # Sinhrono izvajanje (čaka na celoten odgovor)
    run_result = await client.beta.conversations.run_async(
        run_ctx=run_ctx,
        inputs="What is the weather in Paris?",
    )

    print(run_result.output)

Za tem klicem model analizira vprašanje, se posvetuje z razpoložljivimi orodji – tako s strežnikov MCP kot lokalnih funkcij – pokliče tista, za katera meni, da so potrebna, in nato na podlagi pridobljenih rezultatov sestavi svoj odgovor.

Celoten cikel je videti takole:

1. Ustvari agenta (client.beta.agents.create)
       ↓
2. Odpri RunContext (async with RunContext)
       ↓
3. Registriraj odjemalce MCP (register_mcp_client)
       ↓
4. Registriraj lokalne funkcije (register_func)
       ↓
5. Začni pogovore (conversations.run_async)
       ↓
6. Samodejno čiščenje (konec upravitelja konteksta)

Ko zapustiš blok, kontekst zaustavi vse procese strežnika STDIO, ki jih je zagnal – po izjemi ne ostanejo nobeni osiroteli procesi Python.

Še beseda o continue_on_fn_error=True, katerega vrednost je najbolj očitna v proizvodnem okolju. Brez tega najmanjša napaka v orodju prekine celoten pogovor in uporabnik ostane gledati izjemo. S tem model jasno prejme napako in ima prostor za manevriranje: lahko preoblikuje svojo zahtevo z drugačnimi argumenti, se zateče k drugemu orodju ali preprosto uporabniku razloži, kaj je spodletelo. Agent, ki reče „storitev za vremensko napoved se ne odziva”, je neskončno boljši od agenta, ki se zruši.

Ključne ugotovitve

  • RunContext usklajuje komunikacijo med agentom in strežniki MCP
  • Uporabi ga kot upravitelja konteksta async with
  • register_mcp_client poveže strežnik MCP in odkrije njegova orodja
  • register_func registrira lokalne funkcije Python kot orodja
  • continue_on_fn_error=True zagotavlja odpornost tvojega agenta
  • Celoten delovni tok je asinhron (async/await)