Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Kvietimų lygiagretus vykdymas

Paskaita 8 iš 14 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Kai modeliui vienu metu reikia kelių informacijos dalių
  2. Atsakymo su keliais kvietimais skaitymas
  3. Kiekvieno rezultato grąžinimas į originalų kvietimą
  4. Perėjimas nuo tariamo lygiagretumo prie tikro lygiagretumo
  5. Valdymo atgavimas naudojant parallel_tool_calls
  6. Ką iš tikrųjų keičia lygiagretumas
  7. Svarbiausi punktai

Kai modeliui vienu metu reikia kelių informacijos dalių

Iki šiol kiekvienas pokalbio posūkis rezultuodavo vienu funkcijos kvietimu. Daugelis realių klausimų į šį rėmą netelpa. Įsivaizduok naudotoją, kuris klausia: „Kokia yra mokėjimo T1001 būsena ir data?“ Modeliui reikia dviejų informacijos dalių, esančių dviejose skirtingose funkcijose: retrieve_payment_status ir retrieve_payment_date. Jis galėtų jų prašyti vieną po kitos, laukdamas tavo atsakymo tarp jų. Tačiau čia jis nustato, kad viena nuo kitos nepriklauso, todėl viename atsakyme sugeneruoja kelis tool_calls. Tu visą darbo krūvį gauni iškart ir pats sprendi, kaip jį vykdyti.

Atsakymo su keliais kvietimais skaitymas

Praktinė išvada paprasta: message.tool_calls nebėra vien elementą turintis sąrašas. Turi jį iteruoti, o ne griebti tool_calls[0], kas yra dažnas refleksas besimokant funkcijų kvietimo iš pavyzdžių su viena funkcija.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

message = response.choices[0].message

# Keli tool_calls tame pačiame atsakyme
for tc in message.tool_calls:
    print(f"Function: {tc.function.name}")
    print(f"Arguments: {tc.function.arguments}")
    print(f"ID: {tc.id}")
    print("---")

# Galima išvestis:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Atkreipk dėmesį, kad abu kvietimai naudoja tą patį argumentą T1001, bet turi skirtingus ID: call_abc123 ir call_def456. Šie ID yra vienintelis būdas, kuriuo modelis supranta, kuris rezultatas atitinka kurį prašymą.

Kiekvieno rezultato grąžinimas į originalų kvietimą

Taisyklė griežta: privalai įvykdyti kiekvieną funkciją ir grąžinti kiekvieną rezultatą atskirame tool pranešime, kuriame nurodytas atitinkamas tool_call_id. Jei pamirši arba sukeisi ID, modelis gali priskirti datą būsenos laukui arba visiškai atsisakyti atsakyti.

message = response.choices[0].message
messages.append(message)

# Įvykdyti visas prašytas funkcijas
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Įvykdyti funkciją
    result = available_functions[function_name](**function_params)

    # Pridėti rezultatą su teisingu tool_call_id
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Išsiųsti visus rezultatus atgal modeliui
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026, and its status is: paid."

Tuomet modelis šiuos du fragmentus sujungia į vieną sakinį, tarsi informacija būtų atėjusi iš vieno šaltinio. Būtent tokio efekto ir nori naudotojo požiūriu.

Perėjimas nuo tariamo lygiagretumo prie tikro lygiagretumo

Yra viena subtilybė, kurią pirmą kartą skaitantys dažnai praleidžia: aukščiau esančiame for cikle funkcijos vykdomos viena po kitos. Modelis savo kvietimus užsakė lygiagrečiai, tačiau tavo kodas lieka nuoseklus. Kol tavo funkcijos skaito atmintyje esantį „DataFrame“, tai nesvarbu. Tačiau kai jos kreipiasi į išorinę API arba duomenų bazę, du 300 ms trunkantys kvietimai virsta 600 ms suvokiama delsą, o lygiagretumo nauda išgaruoja. Jei tavo funkcijos yra asinchroninės, asyncio.gather jas paleidžia kartu ir laukia viso paketo pabaigos.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Executes tool_calls in parallel and returns the results."""

    async def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        # If your functions are async:
        result = await available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    # Execute all functions in parallel
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

Dauguma esamų kodų bazių naudoja sinchronines funkcijas, kurių nenorėsi perrašyti į async vien dėl šio tikslo. Gijų baseinas („thread pool“) suteikia tą patį efektą neliečiant tavo verslo logikos.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Executes tool_calls using a thread pool."""
    def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        result = available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    with ThreadPoolExecutor(max_workers=5) as executor:
        results = list(executor.map(execute_one, tool_calls))

    return results

Valdymo atgavimas naudojant parallel_tool_calls

Lygiagretumas ne visada pageidautinas. Parametras parallel_tool_calls leidžia tai leisti arba uždrausti. Nustačius True (numatytoji reikšmė), modelis pats sprendžia, ar grupuoti savo kvietimus. Nustačius False, jis viename atsakyme gali sugeneruoti tik vieną tool_call.

# Leisti lygiagrečius kvietimus (numatyta)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Sprendžia modelis
)

# Priversti nuoseklius kvietimus
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Tik vienas tool_call per atsakymą
)

Yra trys situacijos, pateisinančios šio parametro nustatymą į False. Pirmoji – kai svarbi vykdymo tvarka: sąskaitos išrašymas prieš tikrinant atsargas duoda kitokį rezultatą nei atvirkščiai. Antroji susijusi su duomenų priklausomybėmis, kai vienos funkcijos rezultatas reikalingas kitai iškviesti – pavyzdžiui, reikia rasti kontaktą, kad gautum jo ID prieš redaguojant jo įrašą. Trečioji tiesiog susijusi su poreikiu tiksliau valdyti eigą, dažniausiai derinimo metu, kai nori stebėti kiekvieną kvietimą atskirai prieš atverdamas visas galimybes.

Ką iš tikrųjų keičia lygiagretumas

Naudą lemia ne tik gijos; ji visų pirma susijusi su API užklausų ciklų skaičiumi, kuris ir lemia bendrą delsą.

# Nuoseklus (2 API užklausos modeliui)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Lygiagretus (tik 1 papildoma API užklausa)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

Nuoseklioje schemoje modelis turi atlikti du pilnus samprotavimo ciklus prieš pateikdamas galutinį atsakymą. Lygiagrečioje schemoje vienas prašymas gauna visus tool_calls, o atsakymui reikia tik vienos papildomos užklausos. Klausimui, apimančiam dvi ar tris funkcijas, tai naudotojui dažnai sutaupo kelias sekundes.

Svarbiausi punktai

  • Modelis viename atsakyme gali sugeneruoti kelis tool_calls
  • Kiekvienas rezultatas turi būti grąžintas su teisingu tool_call_id
  • Tinklo funkcijoms tikram lygiagrečiam vykdymui naudok asyncio arba ThreadPoolExecutor
  • Parametras parallel_tool_calls valdo šią elgseną (pagal nutylėjimą True)
  • Lygiagreti schema sumažina API užklausų skaičių ir gerina delsą