Volání paralelních funkcí
Na této stránce
Vícenásobná volání nástrojů v jedné odpovědi
Jednou z nejmocnějších funkcí volání funkcí v modelu Grok je schopnost vrátit více volání nástrojů v jediné odpovědi. Místo toho, abys pro každou funkci dělal samostatný požadavek a čekal na odpověď, model identifikuje všechny potřebné informace a vygeneruje všechna volání najednou, paralelně.
Parametr parallel_tool_calls
Paralelní volání jsou ve výchozím nastavení povolena. Chování řídí parametr parallel_tool_calls:
# Povoleno ve výchozím nastavení (není třeba specifikovat)
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=True # Toto je výchozí hodnota
)
Když se uživatel zeptá: „Jaké je počasí v Paříži a Lyonu?“, model vrátí dvě položky tool_calls ve stejné odpovědi:
{
"tool_calls": [
{
"id": "call_001",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Paris\"}"
}
},
{
"id": "call_002",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Lyon\"}"
}
}
]
}
Zpracování paralelních volání
Tvůj kód musí umět pracovat s polem tool_calls, nejen s jedním prvkem:
import json
import asyncio
message = response.choices[0].message
if message.tool_calls:
# Spusti všechny funkce
tool_results = []
for tool_call in message.tool_calls:
args = json.loads(tool_call.function.arguments)
result = execute_function(tool_call.function.name, args)
tool_results.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": json.dumps(result)
})
# Pošli VŠECHNY výsledky zpět modelu
messages = [
{"role": "user", "content": "What's the weather in Paris and Lyon?"},
message,
*tool_results # Všechny výsledky
]
final = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools
)
Klíčové pravidlo: musíš vrátit všechny výsledky nástrojů, nejen ten první. Každý výsledek je svázán se svým odpovídajícím tool_call_id.
Skutečné paralelní provádění na straně klienta
Model sice vrátí volání paralelně, ale tvůj kód je musí vykonat také paralelně. V Pythonu k tomu použij asyncio nebo concurrent.futures:
import concurrent.futures
def execute_parallel(tool_calls):
results = []
with concurrent.futures.ThreadPoolExecutor() as executor:
futures = {}
for tc in tool_calls:
args = json.loads(tc.function.arguments)
future = executor.submit(execute_function, tc.function.name, args)
futures[future] = tc.id
for future in concurrent.futures.as_completed(futures):
call_id = futures[future]
result = future.result()
results.append({
"role": "tool",
"tool_call_id": call_id,
"content": json.dumps(result)
})
return results
Paralelní provádění výrazně snižuje celkovou latenci. Pokud každé volání API trvá 200 ms, dvě sekvenční volání zabere 400 ms, zatímco dvě paralelní volání pouze ~200 ms.
Zakázání paralelních volání
V některých případech budeš potřebovat sekvenční volání:
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=False
)
Paralelismus vypni vždy, když není zaručena nezávislost jednotlivých volání. Nejzřetelnějším případem je datová závislost: pokud výsledek jednoho nástroje slouží jako vstupní argument pro další nástroj – například vyhledání ID zákazníka před získáním jeho objednávek – spuštění paralelně povede přinejlepším k chybě a přinejhorším k tichému vzniku nesprávného výsledku. Stejné omezení ukládá i pořadí obchodní logiky: vytvoření uživatele před přiřazením role je nezbytné a pouze sekvenční režim to garantuje. Obraz doplňují další dva praktické důvody: externí API s omezením na počet souběžných požadavků nezvládne nápor paralelních volání dobře a během vývoje činí sekvenční režim sledování volání nekonečně čitelnějším – jedno volání, jeden výsledek, jeden záznam v logu, vše v pořadí.
Paralelní volání různých nástrojů
Model může také paralelně volat různé nástroje:
# Požadavek: "Rezervuj stůl a řekni mi, jaké bude dnes večer počasí"
# Model vrátí:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")
To je obzvláště užitečné pro univerzální asistenty, kteří potřebují shromažďovat informace z různých zdrojů.
Zpracování chyb při paralelním provádění
Pokud jedno volání selže, ale ostatní uspějí, stále vrať všechny výsledky. Model si poradí s jednotlivými chybami:
results = []
for tc in message.tool_calls:
try:
result = execute_function(tc.function.name, args)
results.append({
"role": "tool",
"tool_call_id": tc.id,
"content": json.dumps(result)
})
except Exception as e:
results.append({
"role": "tool",
"tool_call_id": tc.id,
"content": json.dumps({"error": str(e)})
})
Klíčové poznatky
- Paralelní volání jsou ve výchozím nastavení povolena (
parallel_tool_calls: true) - Model vrací více položek
tool_callsv jediné odpovědi - Musíš vrátit všechny výsledky, každý svázaný se svým
tool_call_id - Implementuj paralelní provádění na straně klienta pro snížení latence
- Vypni paralelismus, pokud mezi voláními existují závislosti
- Chyby zpracovávej individuálně – kvůli jedné chybě nezablokuj vše ostatní