Paralelní volání funkcí
Na této stránce
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_callsv 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
asyncioneboThreadPoolExecutorpro skutečné paralelní provádění - Parametr
parallel_tool_callsřídí toto chování (výchozí hodnota jeTrue) - Paralelní vzor snižuje počet požadavků na API a zlepšuje latenci