Paralelné volania
Na tejto strane
Viacero nástrojov v jednej odpovedi
Jednou z najvýkonnejších funkcií volania funkcií v modeli Grok je schopnosť vrátiť viacero volaní nástrojov v jednej odpovedi. Namiesto toho, aby si pre každú funkciu robil samostatný cyklus požiadavka-odpoveď, model identifikuje všetky potrebné informácie a vygeneruje všetky volania paralelne.
Parameter parallel_tool_calls
Paralelné volania sú predvolene povolené. Správanie riadi parameter parallel_tool_calls:
# Predvolene povolené (nie je potrebné špecifikovať)
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=True # Toto je predvolená hodnota
)
Keď sa používateľ opýta: „Aké je počasie v Paríži a Lyone?“, model vráti dve položky tool_calls v tej istej odpovedi:
{
"tool_calls": [
{
"id": "call_001",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Paris\"}"
}
},
{
"id": "call_002",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Lyon\"}"
}
}
]
}
Spracovanie paralelných volaní
Tvoj kód musí spracovať pole tool_calls, nielen jednu položku:
import json
import asyncio
message = response.choices[0].message
if message.tool_calls:
# Vykonaj všetky funkcie
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ŠETKY výsledky späť modelu
messages = [
{"role": "user", "content": "What's the weather in Paris and Lyon?"},
message,
*tool_results # Všetky výsledky
]
final = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools
)
Kľúčový bod: musíš vrátiť všetky výsledky nástrojov, nie len prvý. Každý výsledok je prepojený so svojím zodpovedajúcim tool_call_id.
Skutočné paralelné vykonávanie na strane klienta
Model vracia volania paralelne, ale tvoj kód ich musí vykonať paralelne. V Pythone použij asyncio alebo 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é vykonávanie výrazne znižuje celkovú latenciu. Ak každé volanie API trvá 200 ms, dve sekvenčné volania = 400 ms, zatiaľ čo dve paralelné volania = ~200 ms.
Zakázanie paralelných volaní
V niektorých prípadoch budeš chcieť sekvenčné volania:
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=False
)
Paralelizmus vypni vždy, keď nie je zaručená nezávislosť volaní. Najzrejmejším prípadom je závislosť na dátach: ak výsledok jedného nástroja slúži ako vstup pre argumenty ďalšieho nástroja – napríklad vyhľadanie ID zákazníka pred získaním jeho objednávok – ich spustenie paralelne spôsobí v najlepšom prípade chybu a v najhoršom ticho nesprávny výsledok. Poradie obchodnej logiky ukladá rovnaké obmedzenie: vytvorenie používateľa pred priradením role je nevyhnutné a toto zaručuje len sekvenčný režim. Obraz dopĺňajú ešte dva praktické dôvody: externé API podliehajúce limitom súbežných požiadaviek nezvládne nával paralelných volaní dobre a počas vývoja robí sekvenčný režim sledovanie volaní nekonečne čitateľnejším – jedno volanie, jeden výsledok, jeden záznam, v poradí.
Paralelné volania s rôznymi nástrojmi
Model môže tiež volať rôzne nástroje paralelne:
# Požiadavka: "Rezervuj stôl a povedz mi, aké bude dnes večer počasie"
# Model vráti:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")
Toto je obzvlášť užitočné pre všestranných asistentov, ktorí potrebujú zbierať informácie z rôznych zdrojov.
Spracovanie chýb pri paralelnom vykonávaní
Keď jedno volanie zlyhá, ale ostatné uspejú, stále vráť všetky výsledky. Model sa postará o individuálne chyby:
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)})
})
Kľúčové poznatky
- Paralelné volania sú predvolene povolené (
parallel_tool_calls: true) - Model vracia viacero
tool_callsv jednej odpovedi - Musíš vrátiť všetky výsledky, každý prepojený so svojím
tool_call_id - Implementuj paralelné vykonávanie na strane klienta na zníženie latencie
- Vypni paralelizmus, keď existujú závislosti medzi volaniami
- Spracúvaj chyby individuálne – neblokuj všetko kvôli jednej chybe