Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Pozivi u paraleli

Lekcija 6 od 14 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Više alata u jednom odgovoru
  2. Parametar parallel_tool_calls
  3. Rukovanje paralelnim pozivima
  4. Pravo paralelno izvršavanje na klijentu
  5. Onemogućavanje paralelnih poziva
  6. Paralelni pozivi s različitim alatima
  7. Rukovanje pogreškama u paraleli
  8. Ključne točke

Više alata u jednom odgovoru

Jedna od najmoćnijih značajki pozivanja funkcija u Groku jest mogućnost vraćanja više poziva alata u jednom odgovoru. Umjesto da obavljaš krug razmjene za svaku funkciju zasebno, model identificira sve informacije koje su mu potrebne i generira svaki poziv paralelno.

Parametar parallel_tool_calls

Paralelni pozivi omogućeni su prema zadanim postavkama. Parametar parallel_tool_calls upravlja tim ponašanjem:

# Omogućeno prema zadanim postavkama (nema potrebe za navođenjem)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Ovo je zadana vrijednost
)

Kada korisnik pita: „Kakvo je vrijeme u Parizu i Lyonu?“, model vraća dva tool_calls u istom odgovoru:

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

Rukovanje paralelnim pozivima

Tvoj kod mora obrađivati polje tool_calls, a ne samo jedan element:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Izvrši sve 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šalji SVE rezultate natrag modelu
    messages = [
        {"role": "user", "content": "What's the weather in Paris and Lyon?"},
        message,
        *tool_results  # Svi rezultati
    ]

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

Kritična točka: moraš vratiti sve rezultate alata, a ne samo prvi. Svaki rezultat povezan je sa svojim odgovarajućim tool_call_id.

Pravo paralelno izvršavanje na klijentu

Model vraća pozive paralelno, ali tvoj kod mora izvršiti ih paralelno. U Pythonu koristi asyncio ili 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

Paralelno izvršavanje značajno smanjuje ukupnu latenciju. Ako svaki API poziv traje 200 ms, dva sekvencijalna poziva = 400 ms, dok dva paralelna poziva = ~200 ms.

Onemogućavanje paralelnih poziva

U nekim ćeš slučajevima htjeti sekvencijalne pozive:

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

Onemogući paralelizam kad god neovisnost poziva nije zajamčena. Najočitiji slučaj je ovisnost o podacima: ako rezultat jednog alata ulazi kao argument u sljedeći alat – primjerice, traženje ID-a kupca prije dohvaćanja njegovih narudžbi – njihovo paralelno pokretanje u najboljem će slučaju izazvati pogrešku, a u najgorem proizvesti tiho netočan rezultat. Redoslijed poslovne logike nameće isto ograničenje: stvaranje korisnika prije dodjele uloge nije pregovaračko, a to garantira samo sekvencijalni način rada. Još dva praktična razloga zaokružuju sliku: vanjski API podložan ograničenjima istodobnih zahtjeva neće dobro podnijeti nalet paralelnih poziva, a tijekom razvoja sekvencijalni način rada čini praćenje poziva beskonačno čitljivijim – jedan poziv, jedan rezultat, jedan zapis, redom.

Paralelni pozivi s različitim alatima

Model može paralelno pozivati i različite alate:

# Zahtjev: "Rezerviraj stol i reci mi kakvo će biti vrijeme večeras"
# Model vraća:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

To je posebno korisno za svestrane asistente koji moraju prikupljati informacije iz različitih izvora.

Rukovanje pogreškama u paraleli

Kada jedan poziv ne uspije, a drugi uspiju, ipak vrati sve rezultate. Model obrađuje pojedinačne pogreške:

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 točke

  • Paralelni pozivi omogućeni su prema zadanim postavkama (parallel_tool_calls: true)
  • Model vraća više tool_calls u jednom odgovoru
  • Moraš vratiti sve rezultate, od kojih je svaki povezan sa svojim tool_call_id
  • Implementiraj paralelno izvršavanje na strani klijenta kako bi smanjio latenciju
  • Onemogući paralelizam kada postoje ovisnosti između poziva
  • Pogreške obrađuj pojedinačno – nemoj blokirati sve zbog jedne neuspješne operacije