Párhuzamos hívások
Ezen az oldalon
Több eszköz egyetlen válaszban
A Grok függvényhívás egyik legerősebb tulajdonsága, hogy egyetlen válaszban több eszköz hívását is vissza tudja adni. Ahelyett, hogy minden függvényhez külön körmenetet végezne, a modell azonosítja az összes szükséges információt, és párhuzamosan generálja az összes hívást.
A parallel_tool_calls paraméter
A párhuzamos hívások alapértelmezés szerint engedélyezettek. A parallel_tool_calls paraméter vezérli ezt a viselkedést:
# Alapértelmezés szerint engedélyezve (nem kell megadni)
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=True # Ez az alapértelmezett érték
)
Amikor a felhasználó azt kérdezi: „Milyen az időjárás Párizsban és Lyonban?“, a modell két tool_calls elemet ad vissza ugyanabban a válaszban:
{
"tool_calls": [
{
"id": "call_001",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Paris\"}"
}
},
{
"id": "call_002",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Lyon\"}"
}
}
]
}
Párhuzamos hívások kezelése
A kódodnak egy tool_calls tömböt kell kezelnie, nem csak egy elemet:
import json
import asyncio
message = response.choices[0].message
if message.tool_calls:
# Összes függvény végrehajtása
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)
})
# MINDEN eredmény visszaküldése a modellnek
messages = [
{"role": "user", "content": "Milyen az időjárás Párizsban és Lyonban?"},
message,
*tool_results # Minden eredmény
]
final = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools
)
Kritikus pont: minden eszközeredményt vissza kell adnod, nem csak az elsőt. Minden eredmény a hozzá tartozó tool_call_id-hoz van kötve.
Valódi párhuzamos végrehajtás a kliens oldalon
A modell párhuzamosan adja vissza a hívásokat, de a kódodnak is párhuzamosan kell végrehajtania azokat. Pythonban használd az asyncio vagy a concurrent.futures modult:
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
A párhuzamos végrehajtás jelentősen csökkenti a teljes késleltetést. Ha minden API-hívás 200 ms-ot vesz igénybe, akkor két szekvenciális hívás = 400 ms, míg két párhuzamos hívás = ~200 ms.
Párhuzamos hívások letiltása
Bizonyos esetekben szekvenciális hívásokra lesz szükséged:
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=False
)
Akkor tiltsd le a párhuzamosságot, ha a hívások függetlensége nem garantált. A legkézenfekvőbb eset az adatfüggőség: ha az egyik eszköz eredménye a következő eszköz argumentumaiba kerül – például egy ügyfélazonosító lekérése, mielőtt lekérnéd a rendeléseit –, akkor a párhuzamos futtatás legjobb esetben hibát okoz, rosszabb esetben csendesen helytelen eredményt produkál. Az üzleti logika sorrendje ugyanilyen korlátot szab: felhasználó létrehozása, mielőtt szerepet rendelnél hozzá, nem tárgyalható, és ezt csak a szekvenciális mód garantálja. Két további gyakorlati ok egészíti ki a képet: egy olyan külső API, amelyre egyidejű kérelmek korlátai vonatkoznak, nem kezeli jól a párhuzamos hívások rohamát; fejlesztés közben pedig a szekvenciális mód végtelenül átláthatóbbá teszi a hívások nyomon követését – egy hívás, egy eredmény, egy naplóbejegyzés, sorrendben.
Párhuzamos hívások különböző eszközökkel
A modell különböző eszközöket is meghívhat párhuzamosan:
# Kérés: „Foglalj asztalt, és mondd meg, milyen az időjárás ma este“
# A modell visszaadja:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")
Ez különösen hasznos sokoldalú asszisztensek esetén, amelyeknek különböző forrásokból kell információt gyűjteniük.
Hibakezelés párhuzamos módban
Ha egy hívás meghiúsul, de mások sikerrel járnak, akkor is minden eredményt adj vissza. A modell kezeli az egyes hibákat:
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)})
})
Főbb megállapítások
- A párhuzamos hívások alapértelmezés szerint engedélyezettek (
parallel_tool_calls: true) - A modell több
tool_callselemet ad vissza egyetlen válaszban - Minden eredményt vissza kell adnod, mindegyiket a saját
tool_call_id-jához kötve - Implementálj kliens oldali párhuzamos végrehajtást a késleltetés csökkentése érdekében
- Tiltsd le a párhuzamosságot, ha függőség van a hívások között
- Kezeld a hibákat egyenként – ne blokkolj mindent egyetlen hiba miatt