Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Paralleelsed väljakutsed

Õppetund 6 / 14 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Mitu tööriista ühes vastuses
  2. Parameeter parallel_tool_calls
  3. Paralleelsete väljakutsete töötlemine
  4. Tõeline paralleeltöötlus kliendipoolses koodis
  5. Paralleelsuse keelamine
  6. Erinevate tööriistadega paralleelsed väljakutsed
  7. Veakäsitlus paralleelses režiimis
  8. Peamised punktid

Mitu tööriista ühes vastuses

Üks Groki funktsioonide kutsumise võimsamaid omadusi on võimalus tagastada mitu tööriista väljakutset ühes vastuses. Mudel ei tee iga funktsiooni jaoks eraldi päringut, vaid tuvastab kogu vajaliku teabe ja genereerib kõik väljakutsed paralleelselt.

Parameeter parallel_tool_calls

Paralleelsed väljakutsed on vaikimisi lubatud. Käitumist juhib parameeter parallel_tool_calls:

# Vaikimisi lubatud (määramine pole vajalik)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # See on vaikimisi säte
)

Kui kasutaja küsib: „Milline on ilm Pariisis ja Lyonis?“, tagastab mudel samas vastuses kaks tool_calls elementi:

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

Paralleelsete väljakutsete töötlemine

Sinu kood peab töötlema tool_calls massiivi, mitte ainult ühte elementi:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Käivita kõik funktsioonid
    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)
        })

    # Saada KÕIK tulemused mudelile tagasi
    messages = [
        {"role": "user", "content": "What's the weather in Paris and Lyon?"},
        message,
        *tool_results  # Kõik tulemused
    ]

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

Kriitiline punkt: sa pead tagastama kõik tööriista tulemused, mitte ainult esimese. Iga tulemus on seotud oma vastava tool_call_id-ga.

Tõeline paralleeltöötlus kliendipoolses koodis

Mudel tagastab väljakutsed paralleelselt, kuid sinu kood peab need ka täitma paralleelselt. Kasuta Pythonis asyncio või concurrent.futures moodulit:

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

Paralleeltäitmine vähendab oluliselt kogulatentsust. Kui iga API väljakutse võtab 200 ms, siis kaks järjestikust väljakutset = 400 ms, kuid kaks paralleelset väljakutset = ~200 ms.

Paralleelsuse keelamine

Mõnel juhul soovid kasutada järjestikuseid väljakutseid:

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

Keela paralleelsus alati, kui väljakutsete sõltumatus pole garanteeritud. Ilmselgeim juhtum on andmesõltuvus: kui ühe tööriista tulemus sisestatakse järgmise tööriista argumentidesse (näiteks kliendi ID otsimine enne tellimuste pärimist), põhjustab paralleelne käivitamine parimal juhul vea ja halvimal juhul vaikselt vale tulemuse. Ärilogika järjestus seab sama piirangu: kasutaja loomine enne talle rolli määramist on kohustuslik ja seda garanteerib ainult järjestikune režiim. Pilti täiendavad veel kaks praktilist põhjust: väline API, millel on samaaegsete päringute piirangud, ei tule paralleelsete väljakutsete purskega hästi toime ning arenduse ajal muudab järjestikune režiim väljakutsete jälgimise lõpmatult loetavamaks – üks väljakutse, üks tulemus, üks logi, järjekorras.

Erinevate tööriistadega paralleelsed väljakutsed

Mudel saab paralleelselt kutsuda ka erinevaid tööriistu:

# Päring: "Broneeri laud ja ütle mulle, milline on ilm täna õhtul"
# Mudel tagastab:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

See on eriti kasulik mitmekülgsete assistentide puhul, mis peavad koguma teavet erinevatest allikatest.

Veakäsitlus paralleelses režiimis

Kui üks väljakutse ebaõnnestub, kuid teised õnnestuvad, tagasta siiski kõik tulemused. Mudel haldab individuaalseid vigu:

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

Peamised punktid

  • Paralleelsed väljakutsed on vaikimisi lubatud (parallel_tool_calls: true)
  • Mudel tagastab mitu tool_calls elementi ühes vastuses
  • Sa pead tagastama kõik tulemused, igaüks seotud oma tool_call_id-ga
  • Latentsuse vähendamiseks rakenda kliendipoolne paralleeltäitmine
  • Keela paralleelsus, kui väljakutsete vahel on sõltuvusi
  • Käitle vigu individuaalselt – ära blokeeri kõike üheainsa ebaõnnestumise tõttu