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

Pozivi funkcija u paraleli

Lekcija 8 od 14 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Kada modelu treba više informacija odjednom
  2. Čitanje odgovora s više poziva
  3. Vraćanje svakog rezultata izvornom pozivu
  4. Od prividne paralelizma do stvarne paralelizma
  5. Povratak kontrole s parallel_tool_calls
  6. Što paralelizam zapravo mijenja
  7. Ključne točke

Kada modelu treba više informacija odjednom

Do sada je svaki korak u razgovoru rezultirao jednim pozivom funkcije. Mnoga pitanja iz stvarnog svijeta ne uklapaju se u taj kalup. Zamisli korisnika koji pita: „Koji su status i datum uplate T1001?“ Modelu trebaju dva podatka koja se nalaze u dvjema različitim funkcijama: retrieve_payment_status i retrieve_payment_date. Mogao bi ih zatražiti jednu po jednu, čekajući tvoj odgovor između. Međutim, ovdje utvrđuje da jedna ne ovisi o drugoj, pa generira više tool_calls u jednom odgovoru. Ti primaš cijeli teret odjednom i ti odlučuješ kako ga izvršiti.

Čitanje odgovora s više poziva

Praktična posljedica je jednostavna: message.tool_calls više nije lista s jednim elementom. Moraš iterirati kroz nju umjesto da grabiš tool_calls[0], što je čest refleks kada učiš pozivanje funkcija iz primjera s jednom funkcijom.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

message = response.choices[0].message

# Više tool_calls u istom odgovoru
for tc in message.tool_calls:
    print(f"Function: {tc.function.name}")
    print(f"Arguments: {tc.function.arguments}")
    print(f"ID: {tc.id}")
    print("---")

# Mogući ispis:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Imaj na umu da oba poziva koriste isti argument, T1001, ali imaju različite ID-ove: call_abc123 i call_def456. Ti su ID-ovi jedini način na koji model zna koji rezultat odgovara kojem zahtjevu.

Vraćanje svakog rezultata izvornom pozivu

Pravilo je strogo: moraš izvršiti svaku funkciju i vratiti svaki rezultat u zasebnoj poruci tipa tool koja nosi odgovarajući tool_call_id. Ako zaboraviš ili zamijeniš ID, model može pripisati datum polju statusa ili odbiti odgovoriti.

message = response.choices[0].message
messages.append(message)

# Izvrši sve zatražene funkcije
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Izvrši funkciju
    result = available_functions[function_name](**function_params)

    # Dodaj rezultat s ispravnim tool_call_id
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Pošalji sve rezultate natrag modelu
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)
# → "Uplata T1001 izvršena je 15. ožujka 2026., a njezin status je: plaćeno."

Model zatim spaja ta dva fragmenta u jednu rečenicu, kao da su informacije došle iz jednog izvora. To je točno učinak koji želiš s korisničke perspektive.

Od prividne paralelizma do stvarne paralelizma

Jedna nijansa često promakne čitateljima pri prvom prolasku: u gornjoj petlji for funkcije se izvršavaju jedna za drugom. Model je zatražio svoje pozive paralelno, ali tvoj kod ostaje sekvencijalan. Dokle god tvoje funkcije čitaju DataFrame u memoriji, to nije bitno. Međutim, čim upite šalju vanjskom API-ju ili bazi podataka, dva poziva od po 300 ms postaju 600 ms percipiranog kašnjenja, a korist od paralelizma ispari. Ako su tvoje funkcije asinkrone, asyncio.gather pokreće ih zajedno i čeka cijelu seriju.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Izvršava tool_calls paralelno i vraća rezultate."""

    async def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        # Ako su tvoje funkcije async:
        result = await available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    # Izvrši sve funkcije paralelno
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

Većina postojećih baza koda izlaže sinkrone funkcije koje nećeš htjeti prepisivati kao async samo zbog ovoga. Pool niti (thread pool) proizvodi isti učinak bez diranja tvoje poslovne logike.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Izvršava tool_calls koristeći pool niti."""
    def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        result = available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    with ThreadPoolExecutor(max_workers=5) as executor:
        results = list(executor.map(execute_one, tool_calls))

    return results

Povratak kontrole s parallel_tool_calls

Paralelizam nije uvijek poželjan. Parametar parallel_tool_calls omogućuje ti da ga dopustiš ili zabraniš. Kada je postavljen na True (zadana vrijednost), model odlučuje hoće li grupirati svoje pozive. Kada je postavljen na False, može proizvesti samo jedan tool_call po odgovoru.

# Dopusti paralelne pozive (zadano)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Model odlučuje
)

# Prisili sekvencijalne pozive
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Samo jedan tool_call po odgovoru
)

Tri situacije opravdavaju postavljanje ovoga na False. Prva je kada je redoslijed izvršavanja bitan: naplata prije provjere zaliha daje drugačiji rezultat od obrnutog redoslijeda. Druga uključuje ovisnosti o podacima, gdje je rezultat jedne funkcije potreban za poziv sljedeće – na primjer, pronalaženje kontakta kako bi se dobio njegov ID prije modificiranja njegova zapisa. Treća se jednostavno odnosi na potrebu za finijom kontrolom tijeka, obično tijekom debugiranja, kada želiš promatrati svaki poziv izolirano prije nego što otvoriš brave.

Što paralelizam zapravo mijenja

Dobitak nije samo u nitima; primarno se tiče broja povratnih putovanja (round trips) do API-ja, koja dominiraju ukupnim kašnjenjem.

# Sekvencijalno (2 API poziva modelu)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Paralelno (samo 1 dodatni API poziv)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

U sekvencijalnom uzorku model mora dovršiti dva puna kruga rezoniranja prije konačnog odgovora. U paralelnom uzorku, jedan zahtjev dohvaća sve tool_calls, a potreban je samo jedan dodatni zahtjev za odgovor. Za pitanje koje uključuje dvije ili tri funkcije, ovo korisniku često štedi nekoliko sekundi.

Ključne točke

  • Model može generirati više tool_calls u jednom odgovoru
  • Svaki rezultat mora biti vraćen s ispravnim tool_call_id
  • Za mrežne funkcije koristi asyncio ili ThreadPoolExecutor za stvarno paralelno izvršavanje
  • Parametar parallel_tool_calls kontrolira ovo ponašanje (zadano True)
  • Paralelni uzorak smanjuje broj API zahtjeva i poboljšava kašnjenje