Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Klici vzporedno

Lekcija 6 od 14 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Več orodij v enem samem odgovoru
  2. Parameter parallel_tool_calls
  3. Obdelava vzporednih klicev
  4. Prava vzporedna izvedba na strani odjemalca
  5. Onemogočanje vzporednih klicev
  6. Vzporedni klici z različnimi orodji
  7. Obravnava napak pri vzporednem izvajanju
  8. Ključne ugotovitve

Več orodij v enem samem odgovoru

Ena najzmogljivejših funkcij klicanja funkcij v modelu Grok je zmožnost vrnitve več klicev orodij v enem samem odgovoru. Namesto da bi za vsako funkcijo opravil ločen krog komunikacije, model prepozna vse potrebne informacije in vse klice ustvari vzporedno.

Parameter parallel_tool_calls

Vzporedni klici so privzeto omogočeni. Parameter parallel_tool_calls nadzoruje to vedenje:

# Privzeto omogočeno (ni treba navajati)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # To je privzeta vrednost
)

Ko uporabnik vpraša: „Kakšno je vreme v Parizu in Lyonu?”, model vrne dva tool_calls v istem odgovoru:

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

Obdelava vzporednih klicev

Tvoja koda mora obdelati polje tool_calls, ne le enega samega:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Izvedi vse funkcije
    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šlji VSE rezultate nazaj modelu
    messages = [
        {"role": "user", "content": "What's the weather in Paris and Lyon?"},
        message,
        *tool_results  # Vsi rezultati
    ]

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

Ključna točka: vrniti moraš vse rezultate orodij, ne le prvega. Vsak rezultat je povezan s svojim ustreznim tool_call_id.

Prava vzporedna izvedba na strani odjemalca

Model vrne klice vzporedno, vendar mora tvoja koda te klice tudi izvesti vzporedno. V Pythonu uporabi asyncio ali 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

Vzporedna izvedba znatno zmanjša skupno zakasnitev. Če vsak klic API traja 200 ms, dva zaporedna klica pomenita 400 ms, medtem ko dva vzporedna klica trajata le ~200 ms.

Onemogočanje vzporednih klicev

V nekaterih primerih boš želel zaporedne klice:

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

Onemogoči vzporednost, kadar neodvisnost klicev ni zagotovljena. Najbolj očiten primer je odvisnost podatkov: če rezultat enega orodja služi kot vhodni argument za naslednje orodje – na primer iskanje ID-ja stranke pred pridobivanjem njenih naročil – bo vzporedno izvajanje v najboljšem primeru povzročilo napako, v najslabšem pa tiho napačen rezultat. Vrsten red poslovne logike nalaga enako omejitev: ustvarjanje uporabnika pred dodelitvijo vloge je nujno in to zagotavlja le zaporedni način. Sliki dopolnjujeta še dva praktična razloga: zunanji API, ki ima omejitve glede števila sočasnih zahtev, se ne bo dobro odzval na naval vzporednih klicev, med razvojem pa zaporedni način omogoča bistveno bolj pregledno sledenje klicem – en klic, en rezultat, en zapis v dnevniku, vse po vrsti.

Vzporedni klici z različnimi orodji

Model lahko vzporedno kliče tudi različna orodja:

# Zahteva: "Rezerviraj mizo in povej mi vreme za nocoj"
# Model vrne:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

To je še posebej uporabno za vsestranske pomočnike, ki morajo zbirati informacije iz različnih virov.

Obravnava napak pri vzporednem izvajanju

Ko en klic ne uspe, drugi pa so uspešni, vseeno vrni vse rezultate. Model samostojno obravnava posamezne napake:

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

Ključne ugotovitve

  • Vzporedni klici so privzeto omogočeni (parallel_tool_calls: true)
  • Model vrne več tool_calls v enem samem odgovoru
  • Vrniti moraš vse rezultate, pri čemer je vsak povezan s svojim tool_call_id
  • Za zmanjšanje zakasnitve implementiraj vzporedno izvedbo na strani odjemalca
  • Onemogoči vzporednost, kadar med klici obstajajo odvisnosti
  • Napake obravnavaj posamično – zaradi ene same napake ne blokiraj celotnega procesa