Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Vykdymas serveryje arba kliente

Paskaita 14 iš 18 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Du perdavimų valdymo būdai
  2. Serverio režimas – numatytasis variantas
  3. Kliento režimas, kai nori kontrolės
  4. Pasirinkimas tarp šių dviejų
  5. Svarbiausi punktai

Pamoka atnaujinta 2026 m. lapkričio 3 d. pagal mistralai SDK 3.7.0 versiją ir „Mistral“ Handoffs dokumentaciją: įrašas agent.handoff nurodo tikslinį agentą per next_agent_id (ne to_agent), o conversations.append nepriima parametro agent_id – senesnis kodas neveiktų. Tikslinio agento tęsimas čia vyksta naujo pokalbio metu, kuriam perduodate kontekstą. Šaltiniai: Handoffs · client-python.

Du perdavimų valdymo būdai

Kai agentas perduoda valdymą kitam agentui, „Mistral“ API siūlo du vykdymo režimus: serverio (automatinį) ir kliento (rankinį). Nustatymas yra vienas žodis, tačiau jis lemia, kas tiksliai valdo darbo eigą. Serverio režimu visą choreografiją deleguoji „Mistral“ ir gauni rezultatą. Kliento režimu atgauni kontrolę po kiekvieno žingsnio. Visa kita – agentai, jų įrankiai, jų perdavimo tikslai – lieka visiškai tokie patys.

Serverio režimas – numatytasis variantas

response = client.beta.conversations.start(
    agent_id=router_agent.id,
    inputs="Analyze and calculate market trends.",
    handoff_execution="server"  # Numatyta – galima praleisti
)

Eiga valdoma visiškai: maršrutizatorius gauna užklausą, nusprendžia perduoti tyrimų agentui, ir „Mistral“ įvykdo perdavimą; tyrimų agentas atlieka savo darbą, tada perduoda skaičiuotuvui, ir „Mistral“ tai taip pat įvykdo; skaičiuotuvas pateikia rezultatą. Tu gauni galutinį atsakymą, lydimą visų tarpinių išvesčių – tad matai, kas įvyko, bet jau post factum.

Šis režimas pasižymi trim savybėmis, kurios paaiškina, kodėl jis yra numatytasis. Jis paprastas, nes tavo pusėje nerašai jokios valdymo logikos. Jis greitas, nes visa grandinė vykdoma „Mistral“ be tinklo užklausų kiekviename perdavimo taške. Jis patikimas, nes klaidų apdorojimą ir laiko limitus tarp agentų „Mistral“ tvarko už tave.

Jo trūkumai yra tiksli šių privalumų priešybė. Neturi tarpinės kontrolės: neįmanoma patvirtinti ar pakeisti perdavimo jo vykimo metu. Kaina yra neaiški ta prasme, kad visi grandinės agentai vykdomi be galimybės nutraukti užklausos, judančios nereikalinga kryptimi, vykdymą viduryje eigos. Be to, negali įterpti jokios savo logikos tarp žingsnių – jokio detalizuoto žurnalavimo, jokio patvirtinimo, jokių verslo sprendimų.

Kliento režimas, kai nori kontrolės

response = client.beta.conversations.start(
    agent_id=router_agent.id,
    inputs="Analyze the cloud market.",
    handoff_execution="client"
)

Maršrutizatorius gauna užklausą ir nusprendžia ją perduoti – lygiai taip pat, kaip ir anksčiau. Tačiau vietoj to, kad perdavimas būtų įvykdytas, tu gauni agent.handoff įvykį, ir grandinė čia sustoja. Tai nuo tavęs priklauso, ar ją paleisti iš naujo iškviečiant tikslinį agentą – tai palieka tau laisvę patvirtinti, įrašyti į žurnalą, praturtinti kontekstą arba tiesiog atsisakyti.

response = client.beta.conversations.start(
    agent_id=router_agent.id,
    inputs="Search for the latest tech news.",
    handoff_execution="client"
)

for entry in response.outputs:
    if entry.type == "agent.handoff":
        target_agent_id = entry.next_agent_id
        print(f"Handoff requested to: {target_agent_id}")

        # Patvirtink, tada perduok tiksliniam agentui su reikiamu kontekstu
        next_response = client.beta.conversations.start(
            agent_id=target_agent_id,
            inputs="Search for the latest tech news.",
        )

        # Apdorok tikslinio agento atsakymą
        for next_entry in next_response.outputs:
            print(f"{next_entry.type}: {next_entry.content}")

Vienas punktas nusipelno dėmesio: „Mistral“ dokumentacija aprašo client režimą – kontrolė grąžinama tau perdavimo metu – tačiau nepateikia metodo, kaip priversti tikslinį agentą tęsti tą patį pokalbį, be to, conversations.append nepriima parametro agent_id. Todėl pavyzdyje pradedamas pokalbis su tiksliniu agentu, kuriam aiškiai perduodi tai, ko jam reikia: originalią užklausą ir, jei taikoma, jau atlikto darbo santrauką. Tai taip pat proga perduoti tik tai, ką jis turi matyti.

Pirmiau pateiktas fragmentas apdoroja tik vieną perdavimą. Tikra grandinė sujungia kelis, todėl reikia ciklo.

def execute_with_control(router_id, query):
    """Vykdo kelių agentų darbo eigą su kontrole kiekviename žingsnyje."""
    response = client.beta.conversations.start(
        agent_id=router_id,
        inputs=query,
        handoff_execution="client"
    )

    conversation_id = response.conversation_id
    results = []

    while True:
        handoff_found = False

        for entry in response.outputs:
            if entry.type == "agent.handoff":
                handoff_found = True
                target = entry.next_agent_id
                print(f"[LOG] Handoff to {target}")

                # Čia gali pridėti: patvirtinimą, žurnalavimą, metrikas
                response = client.beta.conversations.start(
                    agent_id=target,
                    inputs=query,  # originali užklausa, prireikus praturtinta
                    handoff_execution="client",
                )
                conversation_id = response.conversation_id
                break

            elif entry.type == "message.output":
                results.append(entry.content)

        if not handoff_found:
            break

    return results

Struktūra primena siurblį: kol išvestyje atsiranda perdavimas, jį apdoroji ir paleidi iš naujo; kai tik ciklo iteracija jų neranda, grandinė baigta ir išeini su sukauptais pranešimais. Komentaras viduryje žymi vietą, kuri pateisina visą šį režimą: būtent ten, ir tik ten, tavo kodas įsiterpia tarp dviejų agentų.

Pasirinkimas tarp šių dviejų

Serverio režimas padengia standartinę gamybą. Jei tavo darbo eiga nuspėjama, jei pasitiki savo parašytais agentais arba jei kuriate prototipą ir nori greitai pamatyti rezultatus, visiškas automatizavimas yra tinkamas pasirinkimas – o valdymo ciklo rašymas būtų laiko švaistymas.

Kliento režimas pateisinamas, kai į grandinę įtraukiamas išorinis reikalavimas. Žmogaus patvirtinimas, kai operatorius turi patvirtinti perdavimą agentui, kuris vykdo jautrius veiksmus. Žurnalavimo ir audito poreikis, kai atitikties reikalavimai diktuoja kiekvieno žingsnio sekimą su savo identifikatoriais ir laiko žymomis. Sąlyginis maršrutizavimas, kai sprendimas priklauso nuo verslo taisyklių, kurių modelis negali žinoti – kliento statuso, paros laiko, kvotos. Ribojimas arba dažnio limitavimas, kai nori apriboti vienai užklausai vykdomų agentų skaičių. Galiausiai, atsarginė strategija, kai vieno agento gedimas turi sukelti ką kita, o ne klaidą, rodomą naudotojui.

Štai kaip atrodo pirmoji iš šių situacijų, sumažinta iki savo skeleto.

def workflow_with_validation(router_id, query):
    response = client.beta.conversations.start(
        agent_id=router_id,
        inputs=query,
        handoff_execution="client"
    )

    for entry in response.outputs:
        if entry.type == "agent.handoff":
            target = entry.next_agent_id
            approval = input(f"Authorize transfer to {target}? (y/n) ")

            if approval.lower() == "y":
                response = client.beta.conversations.start(
                    agent_id=target,
                    inputs=query,
                )
            else:
                print("Transfer refused.")
                break

Konsolės input čia tarnauja kaip demonstracija; programoje ją pakeis pranešimas operatoriui ir darbo eigos tęsimas gavus atsakymą. Principas lieka tas pats: perdavimas įvyksta tik tada, kai jį suaktyvina tavo kodas.

Tinkamas požiūris – pradėti serverio režimu ir pereiti tik tada, kai konkretus apribojimas to pareikalaus. Perėjimas į kliento režimą „tik tuo atveju“ iškart apmokestina tave ciklo sudėtingumu ir tinklo užklausomis už kontrolę, kurios dar nenaudoji.

Svarbiausi punktai

  • Serverio režimas = visiškai automatinis, paprastas ir greitas, be tarpinės kontrolės
  • Kliento režimas = gauni perdavimo įvykius ir pats sprendži, ką daryti
  • Kliento režimas leidžia atlikti patvirtinimą, žurnalavimą, sąlyginį maršrutizavimą ir klaidų apdorojimą
  • Daugeliu atvejų pakanka serverio režimo – pereik prie kliento režimo, kai tau reikia kontrolės
  • Abu režimai palaiko tas pačias agentų grandines; skiriasi tik valdymas