Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Paralelné volania funkcií

Lekcia 8 z 14 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Keď model potrebuje viacero informácií naraz
  2. Čítanie odpovede s viacerými volaniami
  3. Vrátanie každého výsledku k pôvodnému volaniu
  4. Prechod od zdanlivej paralelizmu k skutočnému paralelizmu
  5. Získanie kontroly pomocou parallel_tool_calls
  6. Čo paralelizmus skutočne mení
  7. Kľúčové poznatky

Keď model potrebuje viacero informácií naraz

Doteraz každý krok v konverzácii viedol k jedinému volaniu funkcie. Mnohé reálne otázky sa do tohto rámca nezmestia. Predstav si používateľa, ktorý sa opýta: „Aký je stav a dátum platby T1001?“ Model potrebuje dve informácie, ktoré sa nachádzajú v dvoch odlišných funkciách: retrieve_payment_status a retrieve_payment_date. Mohol by ich vyžiadať jednu po druhej a čakať na tvoju odpoveď medzi nimi. Tu však určí, že ani jedna nie je závislá od druhej, takže vygeneruje viacero tool_calls v jednej odpovedi. Celú záťaž dostaneš naraz a ty rozhodneš, ako ju vykonať.

Čítanie odpovede s viacerými volaniami

Praktický dôsledok je jednoduchý: message.tool_calls už nie je zoznam s jednou položkou. Musíš prejsť cyklom cez celý zoznam, namiesto toho, aby si automaticky siahol po tool_calls[0], čo je bežný reflex pri učení sa volania funkcií z príkladov s jednou funkciou.

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

message = response.choices[0].message

# Viacero tool_calls v tej istej odpovedi
for tc in message.tool_calls:
    print(f"Function: {tc.function.name}")
    print(f"Arguments: {tc.function.arguments}")
    print(f"ID: {tc.id}")
    print("---")

# Možný výstup:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Všimni si, že obe volania používajú rovnaký argument, T1001, ale majú rôzne ID: call_abc123 a call_def456. Tieto ID sú jediným spôsobom, ako model vie, ktorý výsledok patrí ku ktorej požiadavke.

Vrátanie každého výsledku k pôvodnému volaniu

Pravidlo je prísne: musíš vykonať každú funkciu a vrátiť každý výsledok v samostatnej správe typu tool, ktorá nesie zodpovedajúce tool_call_id. Ak ID zabudneš alebo vymeníš, model môže pripísať dátum k poľu stavu, alebo môže odmietnuť odpovedať.

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

# Vykonanie všetkých vyžiadaných funkcií
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Vykonanie funkcie
    result = available_functions[function_name](**function_params)

    # Pridanie výsledku so správnym tool_call_id
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Odoslanie všetkých výsledkov späť modelu
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."

Model následne pospája tieto dva fragmenty do jednej vety, akoby informácie pochádzali z jedného zdroja. Presne takýto efekt chceš z pohľadu používateľa dosiahnuť.

Prechod od zdanlivej paralelizmu k skutočnému paralelizmu

Jedna nuansa často uniká čitateľom pri prvom prečítaní: v cykle for vyššie sa funkcie vykonávajú jedna po druhej. Model síl požiadal o svoje volania paralelne, ale tvoj kód zostáva sekvenčný. Pokiaľ tvoje funkcie čítajú DataFrame v pamäti, na tom nezáleží. Akonáhle však queryujú externé API alebo databázu, dve volania po 300 ms sa zmenia na 600 ms vnímanej latencie a výhoda paralelizmu sa vyparí. Ak sú tvoje funkcie asynchrónne, asyncio.gather ich spustí naraz a počká na celú dávku.

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)

Väčšina existujúcich kódových báz vystavuje synchrónne funkcie, ktoré nebudeš chcieť prepisovať na async len kvôli tomu. Pool vlákien dosiahne rovnaký efekt bez zásahu do tvojej business logiky.

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

Získanie kontroly pomocou parallel_tool_calls

Paralelizmus nie je vždy žiaduci. Parameter parallel_tool_calls ti umožňuje povoliť alebo zakázať ho. Keď je nastavený na True (predvolená hodnota), model sa sám rozhodne, či svoje volania zgrupuje. Keď je nastavený na False, môže vygenerovať iba jedno tool_call na odpoveď.

# Povolenie paralelných volaní (predvolené)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Rozhodne model
)

# Vynútenie sekvenčných volaní
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Iba jedno tool_call na odpoveď
)

Existujú tri situácie, ktoré odôvodňujú nastavenie tejto hodnoty na False. Prvou je prípad, keď záleží na poradí vykonania: fakturácia pred kontrolou stavu zásob prináša iný výsledok ako opačné poradie. Druhá situácia zahŕňa dátové závislosti, kde je výsledok jednej funkcie potrebný na zavolanie ďalšej – napríklad nájdenie kontaktu za účelom získania jeho ID pred úpravou jeho záznamu. Tretia situácia sa jednoducho týka potreby jemnejšej kontroly toku, typicky počas ladenia, keď chceš pozorovať každé volanie izolovane predtým, než otvoríš stavidlá naplno.

Čo paralelizmus skutočne mení

Zisk nie je len vo vláknach; primárne sa týka počtu spätných ciest (round trips) k API, ktoré dominujú celkovej latencii.

# Sekvenčné (2 API volania k modelu)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Paralelné (iba 1 dodatočné API volanie)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

V sekvenčnom vzore musí model dokončiť dva úplné kroky uvažovania pred finálnou odpoveďou. V paralelnom vzore jedna požiadavka získa všetky tool_calls a na odpoveď je potrebná iba jedna dodatočná požiadavka. Pri otázke zahŕňajúcej dve alebo tri funkcie to používateľovi bežne ušetrí niekoľko sekúnd.

Kľúčové poznatky

  • Model môže vygenerovať viacero tool_calls v jednej odpovedi
  • Každý výsledok musí byť vrátený so správnym tool_call_id
  • Pre sieťové funkcie použij asyncio alebo ThreadPoolExecutor na skutočné paralelné vykonávanie
  • Parameter parallel_tool_calls riadi toto správanie (predvolené True)
  • Paralelný vzorec znižuje počet požiadaviek na API a zlepšuje latenciu