Parallelle aanroepen
Op deze pagina
Meerdere tools in één antwoord
Een van de krachtigste functies van Grok function calling is de mogelijkheid om meerdere tool-aanroepen in één enkel antwoord terug te geven. In plaats van voor elke functie een volledige round-trip te maken, identificeert het model alle benodigde informatie en genereert het elke aanroep parallel.
De parameter parallel_tool_calls
Parallelle aanroepen zijn standaard ingeschakeld. De parameter parallel_tool_calls stuurt dit gedrag:
# Standaard ingeschakeld (niet nodig om op te geven)
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=True # Dit is de standaardwaarde
)
Wanneer een gebruiker vraagt: “Wat is het weer in Parijs en Lyon?”, geeft het model twee tool_calls terug in hetzelfde antwoord:
{
"tool_calls": [
{
"id": "call_001",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Paris\"}"
}
},
{
"id": "call_002",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Lyon\"}"
}
}
]
}
Afhandeling van parallelle aanroepen
Uw code moet een array van tool_calls afhandelen, niet slechts één:
import json
import asyncio
message = response.choices[0].message
if message.tool_calls:
# Voer alle functies uit
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)
})
# Stuur ALLE resultaten terug naar het model
messages = [
{"role": "user", "content": "What's the weather in Paris and Lyon?"},
message,
*tool_results # Alle resultaten
]
final = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools
)
Cruciaal punt: u moet alle tool-resultaten teruggeven, niet alleen het eerste. Elk resultaat is gekoppeld aan de bijbehorende tool_call_id.
Echte parallelle uitvoering aan de clientzijde
Het model geeft aanroepen parallel terug, maar uw code moet ze ook daadwerkelijk parallel uitvoeren. Gebruik in Python asyncio of 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
Parallelle uitvoering vermindert de totale latentie aanzienlijk. Als elke API-aanroep 200 ms duurt, kosten twee sequentiële aanroepen 400 ms, terwijl twee parallelle aanroepen ongeveer 200 ms duren.
Parallelle aanroepen uitschakelen
In sommige gevallen wilt u sequentiële aanroepen:
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=False
)
Schakel parallelisme uit wanneer de onafhankelijkheid van aanroepen niet gegarandeerd is. Het meest voor de hand liggende geval is gegevensafhankelijkheid: als het resultaat van de ene tool dient als invoer voor de argumenten van de volgende tool—bijvoorbeeld het opzoeken van een klant-ID voordat diens bestellingen worden opgehaald—zal parallel uitvoeren op zijn best een fout veroorzaken en op zijn worst leiden tot een stilzwijgend onjuist resultaat. De volgorde van bedrijfslogica legt dezelfde beperking op: het aanmaken van een gebruiker voordat een rol wordt toegewezen is niet onderhandelbaar, en alleen de sequentiële modus garandeert dit. Twee meer praktische redenen maken het plaatje compleet: een externe API met limieten voor gelijktijdige verzoeken kan een burst van parallelle aanroepen slecht aan, en tijdens de ontwikkeling maakt de sequentiële modus het traceren van aanroepen oneindig leesbaarder—één aanroep, één resultaat, één logregel, op volgorde.
Parallelle aanroepen met verschillende tools
Het model kan ook verschillende tools parallel aanroepen:
# Verzoek: "Reserveer een tafel en vertel me het weer vanavond"
# Het model geeft terug:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")
Dit is bijzonder nuttig voor veelzijdige assistenten die informatie uit verschillende bronnen moeten verzamelen.
Foutafhandeling bij parallelle uitvoering
Wanneer één aanroep mislukt maar andere slagen, geeft u toch alle resultaten terug. Het model handelt individuele fouten af:
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)})
})
Belangrijkste punten
- Parallelle aanroepen zijn standaard ingeschakeld (
parallel_tool_calls: true) - Het model geeft meerdere
tool_callsterug in één enkel antwoord - U moet alle resultaten teruggeven, elk gekoppeld aan de bijbehorende
tool_call_id - Implementeer parallelle uitvoering aan de clientzijde om de latentie te verlagen
- Schakel parallelisme uit wanneer er afhankelijkheden bestaan tussen aanroepen
- Handel fouten individueel af—blokkeer niet alles vanwege één enkele mislukking