Przejdź do głównej treści
Polski— Wybierz język
Menu

Wywołania równoległe

Lekcja 6 z 14 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Wiele narzędzi w jednej odpowiedzi
  2. Parametr parallel_tool_calls
  3. Obsługa wywołań równoległych
  4. Prawdziwe wykonanie równoległe po stronie klienta
  5. Wyłączanie wywołań równoległych
  6. Wywołania równoległe z różnymi narzędziami
  7. Obsługa błędów w trybie równoległym
  8. Kluczowe wnioski

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_calls w 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