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

Funktsioonide paralleelsed väljakutsed

Õppetund 8 / 14 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Kui mudel vajab korraga mitut teabekildu
  2. Mitme väljakutsega vastuse lugemine
  3. Iga tulemuse tagastamine oma algsele väljakutsele
  4. Liikumine näiliselt paralleelselt tegelikule paralleelsusele
  5. Kontrolli taastamine parameetriga parallel_tool_calls
  6. Mida paralleelsus tegelikult muudab
  7. Peamised punktid

Kui mudel vajab korraga mitut teabekildu

Seni on iga vestluskäik toonud kaasa vaid ühe funktsiooni väljakutse. Paljud reaalsed küsimused aga sellisesse raamistikku ei mahu. Kujuta ette kasutajat, kes küsib: „Mis on makse T1001 staatus ja kuupäev?“ Mudel vajab kahte teabekildu, mis asuvad kahes erinevas funktsioonis: retrieve_payment_status ja retrieve_payment_date. Ta võiks need üksteise järel pärida, oodates sinu vastust vahepeal. Kuid kuna mudel tuvastab, et üks ei sõltu teisest, genereerib ta ühes vastuses mitu tool_calls’i. Sina saad kogu töökoormuse korraga kätte ja otsustad, kuidas seda täita.

Mitme väljakutsega vastuse lugemine

Praktiline järeldus on lihtne: message.tool_calls ei ole enam ühe elemendiga loend. Sa pead sellest läbi iteratsiooniga käima, mitte haarama tool_calls[0], mis on tavaline refleks, kui õpid funktsioonide kutsumist üksikute näidete pealt.

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

message = response.choices[0].message

# Mitu tool_calls'i samas vastuses
for tc in message.tool_calls:
    print(f"Function: {tc.function.name}")
    print(f"Arguments: {tc.function.arguments}")
    print(f"ID: {tc.id}")
    print("---")

# Võimalik väljund:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Pane tähele, et mõlemad väljakutsed kasutavad sama argumenti, T1001, kuid neil on erinevad ID-d: call_abc123 ja call_def456. Need ID-d on ainus viis, kuidas mudel teab, milline tulemus millisele päringule vastab.

Iga tulemuse tagastamine oma algsele väljakutsele

Reegel on range: sa pead täitma iga funktsiooni ja tagastama iga tulemuse eraldi tool sõnumis, kandes vastava tool_call_id. Kui unustad ID või vahetad need omavahel, võib mudel omistada kuupäeva staatuse väljale või keelduda vastamast.

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

# Täida kõik soovitud funktsioonid
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Käivita funktsioon
    result = available_functions[function_name](**function_params)

    # Lisa tulemus õige tool_call_id-ga
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Saada kõik tulemused mudelile tagasi
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)
# → "Makse T1001 tehti 15. märtsil 2026 ja selle staatus on: tasutud."

Mudel põimib need kaks killu seejärel üheks lauseks, justkui oleks info tulnud ühest allikast. See on täpselt see efekt, mida soovid kasutaja seisukohalt.

Liikumine näiliselt paralleelselt tegelikule paralleelsusele

Üks nüanss jääb esmalugemisel sageli märkamata: ülaltoodud for tsüklis käivituvad funktsioonid üksteise järel. Mudel küsis oma väljakutseid paralleelselt, kuid sinu kood jääb järjestikuseks. Seni, kuni su funktsioonid loevad mälusisest DataFrame’ist, pole sellel tähtsust. Kui aga need päringuid välisele API-le või andmebaasile, muutuvad kaks 300 ms kestvat väljakutset 600 ms tajutavaks viivituseks ja paralleelsuse eelis aurustub. Kui su funktsioonid on asünkroonsed, käivitab asyncio.gather need koos ja ootab kogu partii lõppu.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Käivitab tool_calls'id paralleelselt ja tagastab tulemused."""

    async def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        # Kui su funktsioonid on asünkroonsed:
        result = await available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    # Käivita kõik funktsioonid paralleelselt
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

Enamik olemasolevaid koodibaase eksponeerib sünkroonseid funktsioone, mida sa ei soovi ainult selle pärast async-iks ümber kirjutada. Lõimipark (thread pool) annab sama efekti, puutumata sinu ärilogikat.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Käivitab tool_calls'id kasutades lõimiparki."""
    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

Kontrolli taastamine parameetriga parallel_tool_calls

Paralleelsus pole alati soovitav. Parameeter parallel_tool_calls võimaldab seda lubada või keelata. Kui see on seatud väärtusele True (vaikimisi), otsustab mudel, kas grupeerida oma väljakutsed. Kui see on False, saab ta genereerida ühes vastuses vaid ühe tool_call’i.

# Luba paralleelsed väljakutsed (vaikimisi)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Mudel otsustab
)

# Sunni järjestikused väljakutsed
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Ainult üks tool_call vastuse kohta
)

On kolm olukorda, mis õigustavad selle seadmist väärtusele False. Esimene on siis, kui täitmise järjekord loeb: arveldamine enne laoseisu kontrollimist annab teistsuguse tulemuse kui vastupidine järjekord. Teine hõlmab andmesõltuvusi, kus ühe funktsiooni tulemus on vajalik järgmise kutsumiseks – näiteks kontakti leidmine tema ID saamiseks enne kirje muutmist. Kolmas puudutab lihtsalt vajadust voogu peenemalt kontrollida, tavaliselt silumise ajal, kui soovid iga väljakutset eraldi jälgida enne kui lased kõik valla.

Mida paralleelsus tegelikult muudab

Kasu ei seisne mitte ainult lõimides; see puudutab peamiselt API-le tehtavate ringkäikude arvu, mis domineerib kogu viivituses.

# Järjestikune (2 API väljakutset mudelile)
kasutaja → assistent(fc.1) → tööriist(r.1) → assistent(fc.2) → tööriist(r.2) → assistent(vastus)

# Paralleelne (ainult 1 täiendav API väljakutse)
kasutaja → assistent(fc.1, fc.2) → tööriist(r.1), tööriist(r.2) → assistent(vastus)

Järjestikuses mustris peab mudel enne lõplikku vastust läbima kaks täielikku arutluskäiku. Paralleelses mustris toob üks päring kätte kõik tool_calls’id ja vastuse jaoks on vaja vaid üht täiendavat päringut. Kahe või kolme funktsiooni hõlmava küsimuse puhul säästab see kasutajale tavaliselt mitu sekundit.

Peamised punktid

  • Mudel saab genereerida mitu tool_calls’i ühes vastuses
  • Iga tulemus tuleb tagastada õige tool_call_id-ga
  • Võrgufunktsioonide puhul kasuta tegelikuks paralleelseks täitmiseks asyncio või ThreadPoolExecutor’it
  • Parameeter parallel_tool_calls kontrollib seda käitumist (vaikimisi True)
  • Paralleelne muster vähendab API päringute arvu ja parandab viivitust