Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Volání paralelních funkcí

Lekce 6 z 14 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Vícenásobná volání nástrojů v jedné odpovědi
  2. Parametr parallel_tool_calls
  3. Zpracování paralelních volání
  4. Skutečné paralelní provádění na straně klienta
  5. Zakázání paralelních volání
  6. Paralelní volání různých nástrojů
  7. Zpracování chyb při paralelním provádění
  8. Klíčové poznatky

Vícenásobná volání nástrojů v jedné odpovědi

Jednou z nejmocnějších funkcí volání funkcí v modelu Grok je schopnost vrátit více volání nástrojů v jediné odpovědi. Místo toho, abys pro každou funkci dělal samostatný požadavek a čekal na odpověď, model identifikuje všechny potřebné informace a vygeneruje všechna volání najednou, paralelně.

Parametr parallel_tool_calls

Paralelní volání jsou ve výchozím nastavení povolena. Chování řídí parametr parallel_tool_calls:

# Povoleno ve výchozím nastavení (není třeba specifikovat)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Toto je výchozí hodnota
)

Když se uživatel zeptá: „Jaké je počasí v Paříži a Lyonu?“, model vrátí dvě položky tool_calls ve stejné odpovědi:

{
  "tool_calls": [
    {
      "id": "call_001",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\": \"Paris\"}"
      }
    },
    {
      "id": "call_002",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\": \"Lyon\"}"
      }
    }
  ]
}

Zpracování paralelních volání

Tvůj kód musí umět pracovat s polem tool_calls, nejen s jedním prvkem:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Spusti všechny funkce
    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)
        })

    # Pošli VŠECHNY výsledky zpět modelu
    messages = [
        {"role": "user", "content": "What's the weather in Paris and Lyon?"},
        message,
        *tool_results  # Všechny výsledky
    ]

    final = client.chat.completions.create(
        model="grok-4.5",
        messages=messages,
        tools=tools
    )

Klíčové pravidlo: musíš vrátit všechny výsledky nástrojů, nejen ten první. Každý výsledek je svázán se svým odpovídajícím tool_call_id.

Skutečné paralelní provádění na straně klienta

Model sice vrátí volání paralelně, ale tvůj kód je musí vykonat také paralelně. V Pythonu k tomu použij asyncio nebo 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

Paralelní provádění výrazně snižuje celkovou latenci. Pokud každé volání API trvá 200 ms, dvě sekvenční volání zabere 400 ms, zatímco dvě paralelní volání pouze ~200 ms.

Zakázání paralelních volání

V některých případech budeš potřebovat sekvenční volání:

response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False
)

Paralelismus vypni vždy, když není zaručena nezávislost jednotlivých volání. Nejzřetelnějším případem je datová závislost: pokud výsledek jednoho nástroje slouží jako vstupní argument pro další nástroj – například vyhledání ID zákazníka před získáním jeho objednávek – spuštění paralelně povede přinejlepším k chybě a přinejhorším k tichému vzniku nesprávného výsledku. Stejné omezení ukládá i pořadí obchodní logiky: vytvoření uživatele před přiřazením role je nezbytné a pouze sekvenční režim to garantuje. Obraz doplňují další dva praktické důvody: externí API s omezením na počet souběžných požadavků nezvládne nápor paralelních volání dobře a během vývoje činí sekvenční režim sledování volání nekonečně čitelnějším – jedno volání, jeden výsledek, jeden záznam v logu, vše v pořadí.

Paralelní volání různých nástrojů

Model může také paralelně volat různé nástroje:

# Požadavek: "Rezervuj stůl a řekni mi, jaké bude dnes večer počasí"
# Model vrátí:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

To je obzvláště užitečné pro univerzální asistenty, kteří potřebují shromažďovat informace z různých zdrojů.

Zpracování chyb při paralelním provádění

Pokud jedno volání selže, ale ostatní uspějí, stále vrať všechny výsledky. Model si poradí s jednotlivými chybami:

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)})
        })

Klíčové poznatky

  • Paralelní volání jsou ve výchozím nastavení povolena (parallel_tool_calls: true)
  • Model vrací více položek tool_calls v jediné odpovědi
  • Musíš vrátit všechny výsledky, každý svázaný se svým tool_call_id
  • Implementuj paralelní provádění na straně klienta pro snížení latence
  • Vypni paralelismus, pokud mezi voláními existují závislosti
  • Chyby zpracovávej individuálně – kvůli jedné chybě nezablokuj vše ostatní