Parallelle kald
På denne side
Flere værktøjer i ét svar
En af de mest kraftfulde funktioner ved Grok-funktionskald er evnen til at returnere flere værktøjskald i ét enkelt svar. I stedet for at foretage en tur-retur for hver funktion, identificerer modellen al den information, den har brug for, og genererer hvert kald parallelt.
Parameteren parallel_tool_calls
Parallelle kald er aktiveret som standard. Parameteren parallel_tool_calls styrer denne adfærd:
# Aktiveret som standard (behøver ikke at blive specificeret)
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=True # Dette er standardværdien
)
Når en bruger spørger: „Hvad er vejret i Paris og Lyon?”, returnerer modellen to tool_calls i samme svar:
{
"tool_calls": [
{
"id": "call_001",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Paris\"}"
}
},
{
"id": "call_002",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Lyon\"}"
}
}
]
}
Håndtering af parallelle kald
Din kode skal håndtere et array af tool_calls, ikke bare ét:
import json
import asyncio
message = response.choices[0].message
if message.tool_calls:
# Udfør alle funktioner
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)
})
# Send ALLE resultater tilbage til modellen
messages = [
{"role": "user", "content": "What's the weather in Paris and Lyon?"},
message,
*tool_results # Alle resultater
]
final = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools
)
Vigtigt punkt: Du skal returnere alle værktøjsresultater, ikke kun det første. Hvert resultat er knyttet til dets tilsvarende tool_call_id.
Ægte parallel eksekvering på klienten
Modellen returnerer kald parallelt, men din kode skal eksekvere dem parallelt. I Python bruger du asyncio eller 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
Parallel eksekvering reducerer den samlede ventetid markant. Hvis hvert API-kald tager 200 ms, vil to sekventielle kald tage 400 ms, mens to parallelle kald tager ~200 ms.
Deaktivering af parallelle kald
I nogle tilfælde vil du have sekventielle kald:
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=False
)
Deaktiver parallelitet, når uafhængigheden mellem kald ikke er garanteret. Det mest åbenlyse tilfælde er dataafhængighed: Hvis resultatet fra ét værktøj indgår i argumenterne til det næste værktøj – f.eks. opslag af et kunde-ID før hentning af deres ordrer – vil kørsel i parallel i bedste fald forårsage en fejl og i værste fald producere et stille fejlagtigt resultat. Forretningslogisk rækkefølge pålægger den samme begrænsning: Oprettelse af en bruger før tildeling af en rolle er ikke-forhandlingsbar, og kun sekventiel tilstand garanterer dette. To mere praktiske årsager fuldender billedet: Et eksternt API underlagt grænser for samtidige anmodninger vil ikke håndtere en byge af parallelle kald godt, og under udvikling gør sekventiel tilstand sporing af kald uendeligt mere læsbar – ét kald, ét resultat, én log, i rækkefølge.
Parallelle kald med forskellige værktøjer
Modellen kan også kalde forskellige værktøjer parallelt:
# Anmodning: "Book et bord og fortæl mig vejret i aften"
# Modellen returnerer:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")
Dette er særligt nyttigt for alsidige assistenter, der har brug for at indsamle information fra forskellige kilder.
Fejlhåndtering i parallelle kald
Når ét kald fejler, men andre lykkes, skal du stadig returnere alle resultater. Modellen håndterer individuelle fejl:
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)})
})
Vigtige pointer
- Parallelle kald er aktiveret som standard (
parallel_tool_calls: true) - Modellen returnerer flere
tool_callsi ét enkelt svar - Du skal returnere alle resultater, hver knyttet til sin
tool_call_id - Implementer klient-side parallel eksekvering for at reducere ventetid
- Deaktiver parallelitet, når der er afhængigheder mellem kald
- Håndter fejl individuelt – bloker ikke alt for en enkelt fejl