Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Paralelné volania

Lekcia 6 z 14 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Viacero nástrojov v jednej odpovedi
  2. Parameter parallel_tool_calls
  3. Spracovanie paralelných volaní
  4. Skutočné paralelné vykonávanie na strane klienta
  5. Zakázanie paralelných volaní
  6. Paralelné volania s rôznymi nástrojmi
  7. Spracovanie chýb pri paralelnom vykonávaní
  8. Kľúčové poznatky

Viacero nástrojov v jednej odpovedi

Jednou z najvýkonnejších funkcií volania funkcií v modeli Grok je schopnosť vrátiť viacero volaní nástrojov v jednej odpovedi. Namiesto toho, aby si pre každú funkciu robil samostatný cyklus požiadavka-odpoveď, model identifikuje všetky potrebné informácie a vygeneruje všetky volania paralelne.

Parameter parallel_tool_calls

Paralelné volania sú predvolene povolené. Správanie riadi parameter parallel_tool_calls:

# Predvolene povolené (nie je potrebné špecifikovať)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Toto je predvolená hodnota
)

Keď sa používateľ opýta: „Aké je počasie v Paríži a Lyone?“, model vráti dve položky tool_calls v tej istej odpovedi:

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

Spracovanie paralelných volaní

Tvoj kód musí spracovať pole tool_calls, nielen jednu položku:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Vykonaj všetky funkcie
    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ŠETKY výsledky späť modelu
    messages = [
        {"role": "user", "content": "What's the weather in Paris and Lyon?"},
        message,
        *tool_results  # Všetky výsledky
    ]

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

Kľúčový bod: musíš vrátiť všetky výsledky nástrojov, nie len prvý. Každý výsledok je prepojený so svojím zodpovedajúcim tool_call_id.

Skutočné paralelné vykonávanie na strane klienta

Model vracia volania paralelne, ale tvoj kód ich musí vykonať paralelne. V Pythone použij asyncio alebo 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é vykonávanie výrazne znižuje celkovú latenciu. Ak každé volanie API trvá 200 ms, dve sekvenčné volania = 400 ms, zatiaľ čo dve paralelné volania = ~200 ms.

Zakázanie paralelných volaní

V niektorých prípadoch budeš chcieť sekvenčné volania:

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

Paralelizmus vypni vždy, keď nie je zaručená nezávislosť volaní. Najzrejmejším prípadom je závislosť na dátach: ak výsledok jedného nástroja slúži ako vstup pre argumenty ďalšieho nástroja – napríklad vyhľadanie ID zákazníka pred získaním jeho objednávok – ich spustenie paralelne spôsobí v najlepšom prípade chybu a v najhoršom ticho nesprávny výsledok. Poradie obchodnej logiky ukladá rovnaké obmedzenie: vytvorenie používateľa pred priradením role je nevyhnutné a toto zaručuje len sekvenčný režim. Obraz dopĺňajú ešte dva praktické dôvody: externé API podliehajúce limitom súbežných požiadaviek nezvládne nával paralelných volaní dobre a počas vývoja robí sekvenčný režim sledovanie volaní nekonečne čitateľnejším – jedno volanie, jeden výsledok, jeden záznam, v poradí.

Paralelné volania s rôznymi nástrojmi

Model môže tiež volať rôzne nástroje paralelne:

# Požiadavka: "Rezervuj stôl a povedz mi, aké bude dnes večer počasie"
# Model vráti:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

Toto je obzvlášť užitočné pre všestranných asistentov, ktorí potrebujú zbierať informácie z rôznych zdrojov.

Spracovanie chýb pri paralelnom vykonávaní

Keď jedno volanie zlyhá, ale ostatné uspejú, stále vráť všetky výsledky. Model sa postará o individuálne chyby:

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

Kľúčové poznatky

  • Paralelné volania sú predvolene povolené (parallel_tool_calls: true)
  • Model vracia viacero tool_calls v jednej odpovedi
  • Musíš vrátiť všetky výsledky, každý prepojený so svojím tool_call_id
  • Implementuj paralelné vykonávanie na strane klienta na zníženie latencie
  • Vypni paralelizmus, keď existujú závislosti medzi volaniami
  • Spracúvaj chyby individuálne – neblokuj všetko kvôli jednej chybe