Wywołania równoległe
Na tej stronie
Wiele narzędzi w jednej odpowiedzi
Jedną z najpotężniejszych funkcji wywoływania funkcji przez Grok jest możliwość zwrócenia wielu wywołań narzędzi w jednej odpowiedzi. Zamiast odbywać osobną podróż tam i z powrotem dla każdej funkcji, model identyfikuje wszystkie potrzebne informacje i generuje każde wywołanie równolegle.
Parametr parallel_tool_calls
Wywołania równoległe są domyślnie włączone. Parametr parallel_tool_calls kontroluje to zachowanie:
# Włączone domyślnie (nie trzeba określać)
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=True # To jest wartość domyślna
)
Gdy użytkownik zapyta: „Jaka jest pogoda w Paryżu i Lyonie?“, model zwróci dwa elementy tool_calls w tej samej odpowiedzi:
{
"tool_calls": [
{
"id": "call_001",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Paris\"}"
}
},
{
"id": "call_002",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Lyon\"}"
}
}
]
}
Obsługa wywołań równoległych
Twój kod musi obsługiwać tablicę tool_calls, a nie tylko jeden element:
import json
import asyncio
message = response.choices[0].message
if message.tool_calls:
# Wykonaj wszystkie funkcje
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)
})
# Wyślij WSZYSTKIE wyniki z powrotem do modelu
messages = [
{"role": "user", "content": "Jaka jest pogoda w Paryżu i Lyonie?"},
message,
*tool_results # Wszystkie wyniki
]
final = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools
)
Kluczowa uwaga: musisz zwrócić wszystkie wyniki narzędzi, a nie tylko pierwszy. Każdy wynik jest powiązany z odpowiadającym mu tool_call_id.
Prawdziwe wykonanie równoległe po stronie klienta
Model zwraca wywołania równolegle, ale Twój kod musi je wykonać równolegle. W Pythonie użyj asyncio lub 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
Wykonanie równoległe znacząco skraca całkowite opóźnienie. Jeśli każde wywołanie API trwa 200 ms, dwa wywołania sekwencyjne zajmą 400 ms, podczas gdy dwa wywołania równoległe to około 200 ms.
Wyłączanie wywołań równoległych
W niektórych przypadkach będziesz chciał użyć wywołań sekwencyjnych:
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=False
)
Wyłącz równoległość, gdy niezależność wywołań nie jest gwarantowana. Najbardziej oczywistym przypadkiem jest zależność danych: jeśli wynik jednego narzędzia zasila argumenty następnego narzędzia – na przykład wyszukanie ID klienta przed pobraniem jego zamówień – uruchomienie ich równolegle spowoduje w najlepszym razie błąd, a w najgorszym cicho wygeneruje niepoprawny wynik. Kolejność logiki biznesowej narzuca to samo ograniczenie: utworzenie użytkownika przed przypisaniem mu roli jest nienegocjowalne i tylko tryb sekwencyjny to gwarantuje. Dwa kolejne praktyczne powody dopełniają obrazu: zewnętrzne API podlegające limitom równoczesnych żądań nie poradzi sobie dobrze z falą wywołań równoległych, a podczas rozwoju tryb sekwencyjny sprawia, że śledzenie wywołań jest nieskończenie bardziej czytelne – jedno wywołanie, jeden wynik, jeden wpis w logu, po kolei.
Wywołania równoległe z różnymi narzędziami
Model może również wywoływać różne narzędzia równolegle:
# Żądanie: "Zarezerwuj stolik i powiedz mi, jaka będzie tonight pogoda"
# Model zwraca:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")
Jest to szczególnie przydatne dla wszechstronnych asystentów, które muszą gromadzić informacje z różnych źródeł.
Obsługa błędów w trybie równoległym
Gdy jedno wywołanie nie powiedzie się, a inne zakończą sukcesem, nadal zwróć wszystkie wyniki. Model obsługuje błędy indywidualnie:
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)})
})
Kluczowe wnioski
- Wywołania równoległe są domyślnie włączone (
parallel_tool_calls: true) - Model zwraca wiele elementów
tool_callsw jednej odpowiedzi - Musisz zwrócić wszystkie wyniki, każdy powiązany z jego
tool_call_id - Zaimplementuj wykonanie równoległe po stronie klienta, aby zmniejszyć opóźnienie
- Wyłącz równoległość, gdy między wywołaniami występują zależności
- Obsługuj błędy indywidualnie – nie blokuj wszystkiego z powodu jednej awarii