Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Paralelní volání funkcí

Lekce 8 z 14 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Když model potřebuje najednou více informací
  2. Čtení odpovědi s více voláními
  3. Vrácení každého výsledku k původnímu volání
  4. Od zdánlivé paralelizace ke skutečné paralelizaci
  5. Získání kontroly pomocí parallel_tool_calls
  6. Co paralelismus skutečně mění
  7. Klíčové poznatky

Když model potřebuje najednou více informací

Zatím každé kolo konverzace vedlo k jedinému volání funkce. Mnoho reálných dotazů se do tohoto schématu nevejde. Představ si uživatele, který se zeptá: „Jaký je stav a datum platby T1001?“ Model potřebuje dvě informace, které žijí ve dvou odlišných funkcích: retrieve_payment_status a retrieve_payment_date. Mohl by je požadovat jednu po druhé a mezi tím čekat na tvou odpověď. Zde však určí, že žádná na druhé nezávisí, a proto vygeneruje více tool_calls v jedné odpovědi. Celou práci dostaneš najednou a ty rozhodneš, jak ji zpracovat.

Čtení odpovědi s více voláními

Praktický dopad je jednoduchý: message.tool_calls už není seznam s jednou položkou. Musíš jím iterovat, místo abys automaticky sahal po tool_calls[0], což je častý reflex při učení volání funkcí z příkladů s jednou funkcí.

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

message = response.choices[0].message

# Více tool_calls ve stejné odpovědi
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 obě volání používají stejný argument, T1001, ale mají různá ID: call_abc123 a call_def456. Tato ID jsou jediným způsobem, jak model pozná, který výsledek odpovídá kterému požadavku.

Vrácení každého výsledku k původnímu volání

Pravidlo je přísné: musíš spustit každou funkci a vrátit každý výsledek v samostatné zprávě typu tool, která nese odpovídající tool_call_id. Pokud ID zapomeneš nebo prohodíš, model může přiřadit datum ke stavu, nebo odmítne odpovědět.

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

# Spuštění všech požadovaných funkcí
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Spuštění funkce
    result = available_functions[function_name](**function_params)

    # Přidání výsledku se správným tool_call_id
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Odeslání všech výsledků zpět modelu
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)
# → "Platba T1001 byla provedena 15. března 2026 a její stav je: zaplaceno."

Model pak tyto dva útržky spojí do jedné věty, jako by informace přišly z jednoho zdroje. Přesně toho chceš z pohledu uživatele dosáhnout.

Od zdánlivé paralelizace ke skutečné paralelizaci

Jedna nuance často unikne čtenářům při prvním prostudování: v cyklu for výše se funkce spouští jedna po druhé. Model sice požádal o svá volání paralelně, ale tvůj kód zůstává sekvenční. Dokud tvé funkce čtou pouze DataFrame v paměti, na tom nezáleží. Jakmile však začnou dotazovat externí API nebo databázi, dvě volání po 300 ms se promění v 600 ms vnímané latence a přínos paralelismu zmizí. Pokud jsou tvé funkce asynchronní, asyncio.gather je spustí najednou a počká na celou dávku.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Spustí tool_calls paralelně a vrátí výsledky."""

    async def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        # Pokud jsou tvé funkce async:
        result = await available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    # Spuštění všech funkcí paralelně
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

Většina stávajících kódových základen vystavuje synchronní funkce, které nebudeš chtít přepisovat na async jen kvůli tomu. Pool vláken dosáhne stejného efektu, aniž bys musel sahat do své obchodní logiky.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Spustí tool_calls pomocí poolu vláken."""
    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ískání kontroly pomocí parallel_tool_calls

Paralelismus není vždy žádoucí. Parametr parallel_tool_calls ti umožňuje jej povolit nebo zakázat. Pokud je nastaven na True (výchozí hodnota), model se sám rozhodne, zda svá volání seskupí. Pokud je nastaven na False, může vyprodukovat pouze jedno tool_call na odpověď.

# Povolení paralelních volání (výchozí)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Rozhodne model
)

# Vynucení sekvenčních volání
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Pouze jedno tool_call na odpověď
)

Existují tři situace, které ospravedlňují nastavení této hodnoty na False. První nastává, když záleží na pořadí provedení: fakturace před kontrolou skladu přinese jiný výsledek než obrácený postup. Druhá zahrnuje datové závislosti, kde je výsledek jedné funkce nutný k zavolání další – například nalezení kontaktu pro získání jeho ID před úpravou jeho záznamu. Třetí se týká prosté potřeby jemnější kontroly toku, typicky při ladění, kdy chceš pozorovat každé volání izolovaně, než otevřeš stavidla naplno.

Co paralelismus skutečně mění

Zisk nespočívá jen ve vláknech; primárně jde o počet cest tam a zpět k API, které dominují celkové latenci.

# Sekvenčně (2 volání API k modelu)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Paralelně (pouze 1 další volání API)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

V sekvenčním vzoru musí model dokončit dvě celá kola uvažování, než dospěje ke konečné odpovědi. V paralelním vzoru jediný požadavek získá všechna tool_calls a k odpovědi je potřeba pouze jeden další požadavek. U dotazu zahrnujícího dvě nebo tři funkce to uživateli běžně ušetří několik sekund.

Klíčové poznatky

  • Model může vygenerovat více tool_calls v jedné odpovědi
  • Každý výsledek musí být vrácen se správným tool_call_id
  • Pro síťové funkce použij asyncio nebo ThreadPoolExecutor pro skutečné paralelní provádění
  • Parametr parallel_tool_calls řídí toto chování (výchozí hodnota je True)
  • Paralelní vzor snižuje počet požadavků na API a zlepšuje latenci