Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

RunContext: pārvaldi MCP klientu un aģentu

Nodarbība 5 no 14 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Tava aģenta diriģents
  2. Izveido aģentu
  3. Atver kontekstu
  4. Reģistrē MCP klientu
  5. Pievieno lokālās funkcijas
  6. Sāc sarunu
  7. Galvenās atziņas

Tava aģenta diriģents

RunContext ir komponents, kas satur visu kopā. Tas savieno tavu AI aģentu ar MCP serveriem un pārvalda to visu dzīves ciklu: savienojuma izveidi ar serveriem, rīku reģistrēšanu, sarunu izpildi, rezultātu iegūšanu un korektu izslēgšanu. Mistral SDK tas ir asinhrons konteksta menedžeris, kas ietver visu šo loģiku. Tu atver bloku, deklarē, ko aģentam atļauts izmantot, veic sarunu, un viss automātiski aizveras, kad no tā izieci.

Izveido aģentu

RunContext neizveido aģentu; tas tam pievienojas. Tavs pirmais solis ir instantizēt aģentu, izmantojot API.

from mistralai.client import Mistral

# Inicilizē Mistral klientu
client = Mistral(api_key="YOUR_API_KEY")

# Izveido aģentu
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}")

Šis aģents ir pastāvīga entīte Mistral pusē: tam ir modelis, nosaukums un sistēmas instrukcijas, un tas pastāv arī pēc tava skripta beigām. MCP rīki tomēr nav pievienoti aģentam. Tā vietā RunContext nodrošina tos dinamiski katras izpildes reizē. Šī atdalīšana ļauj palaist vienu un to pašu aģentu ar dažādiem rīkiem atkarībā no konteksta.

Atver kontekstu

Tu izmanto RunContext ar async with, kas garantē resursu atbrīvošanu pat tad, ja rodas izņēmums.

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

# Neobligāti: definē strukturētu izvades formātu
class WeatherResult(BaseModel):
    location: str
    temperature: float
    description: str

async with RunContext(
    agent_id=agent.id,
    output_format=WeatherResult,      # Strukturēts formāts (neobligāti)
    continue_on_fn_error=True,         # Turpini, ja rīks neizdodas
) as run_ctx:
    # Šeit reģistrē MCP klientus un sāc sarunas
    pass

Trīs parametri kontrolē šo uzvedību. agent_id norāda iepriekš izveidoto aģentu. output_format pieņem Pydantic modeli un ierobežo gala atbildi līdz šai struktūrai – tas ir vērtīgi, ja izvade tiek nodota citai programmai, nevis cilvēkam. Visbeidzot, continue_on_fn_error nosaka, kas notiek ar sarunu, kad rīks izraisa kļūdu: ja iestatīts uz True, konteksts turpinās, un modelis saņem kļūdas ziņojumu tāpat, kā tas saņemtu rezultātu.

Reģistrē MCP klientu

Kad konteksts ir atvērts, tu tajā deklarē savus MCP klientus.

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

# Konfigurē lokālo serveri
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:
    # Reģistrē MCP klientu
    await run_ctx.register_mcp_client(mcp_client=mcp_client)

Šis vienīgais izsaukums register_mcp_client iedarbina pilnu secību: servera procesa palaišanu STDIO režīmā, iespēju apspriešanu, rīku saraksta iegūšanu un šo rīku darīšanu pieejamu modelim turpmākajām sarunām. Tev nav nekas no tā jāraksta ar roku.

Tu arī neesi ierobežots ar vienu serveri. Viens RunContext var apkopot vairākus avotus, un modelis redz to rīku apvienojumu kā vienu katalogu:

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)

Pievieno lokālās funkcijas

Ne katrai iespējai ir jākļūst par MCP serveri. Īsai funkcijai, kas specifiska tikai šim skriptam, dekorators register_func ir pietiekams, lai padarītu to pieejamu modelim kā standarta rīku.

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

Modeļa skatījumā nav nekādas atšķirības: tas vienkārši redz vēl vienu rīku. Atšķirība ir tev – šīs funkcijas darbojas tavā Python procesā bez ārēja servera, tāpēc tās nav atkārtoti izmantojamas ārpus šī skripta.

Sāc sarunu

Kad konteksts ir aizpildīts, atliek tikai runāt.

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

    # Sinhrona izpilde (gaida pilnu atbildi)
    run_result = await client.beta.conversations.run_async(
        run_ctx=run_ctx,
        inputs="What is the weather in Paris?",
    )

    print(run_result.output)

Aiz šī izsaukuma modelis analizē jautājumu, konsultējas ar pieejamajiem rīkiem – gan no MCP serveriem, gan lokālajām funkcijām, izsauc tos, kurus uzskata par nepieciešamiem, un pēc tam sastāda savu atbildi, balstoties uz iegūtajiem rezultātiem.

Viss cikls izskatās šādi:

1. Izveido aģentu (client.beta.agents.create)
       ↓
2. Atver RunContext (async with RunContext)
       ↓
3. Reģistrē MCP klientus (register_mcp_client)
       ↓
4. Reģistrē lokālās funkcijas (register_func)
       ↓
5. Sāk sarunas (conversations.run_async)
       ↓
6. Automātiska tīrīšana (konteksta menedžera beigas)

Kad izieci no bloka, konteksts aptur visus STDIO servera procesus, ko tas palaida – pēc izņēmuma nepaliek neviens pamests Python process.

Nobeigumā par continue_on_fn_error=True, kura vērtība vislabāk redzama produkcijā. Bez tā mazākā kļūda rīkā pārtrauc visu sarunu, atstājot lietotāju skatāmies uz izņēmumu. Ar to modelis skaidri saņem kļūdu un iegūst rīcības brīvību: tas var pārformulēt savu pieprasījumu ar citiem argumentiem, pāriet uz citu rīku vai vienkārši paskaidrot lietotājam, kas neizdevās. Aģents, kas saka „laikapstākļu serviss neatbild”, ir bezgalīgi labāks par aģentu, kas sabrūk.

Galvenās atziņas

  • RunContext organizē komunikāciju starp aģentu un MCP serveriem
  • Izmanto to kā async with konteksta menedžeri
  • register_mcp_client savieno MCP serveri un atklāj tā rīkus
  • register_func reģistrē lokālās Python funkcijas kā rīkus
  • continue_on_fn_error=True nodrošina tava aģenta noturību
  • Viss darbplūsmas process ir asinhrons (async/await)