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

Klici vzporednih funkcij

Lekcija 8 od 14 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Ko model potrebuje več podatkov hkrati
  2. Branje odgovora z več klici
  3. Vrnitev vsakega rezultata prvotnemu klicu
  4. Prehod od navidezne vzporednosti k pravi vzporednosti
  5. Ponovni nadzor s parametrom parallel_tool_calls
  6. Kaj vzporednost dejansko spremeni
  7. Ključne ugotovitve

Ko model potrebuje več podatkov hkrati

Do zdaj je vsak korak v pogovoru rezultiral v enem samem klicu funkcije. Številna vprašanja iz resničnega sveta se ne ujemajo s tem vzorcem. Predstavljaj si uporabnika, ki vpraša: „Kakšen je status in datum plačila T1001?” Model potrebuje dva podatka, ki se nahajata v dveh ločenih funkcijah: retrieve_payment_status in retrieve_payment_date. Lahko bi ju zahteval eno za drugo in med čakanjem na tvoj odgovor. Vendar tukaj ugotovi, da nobena ni odvisna od druge, zato v enem samem odgovoru ustvari več tool_calls. Celotno delovno obremenitev prejmeš naenkrat, ti pa se odločiš, kako jo boš izvršil.

Branje odgovora z več klici

Praktična posledica je preprosta: message.tool_calls ni več seznam z enim elementom. Po njem moraš iterirati, namesto da bi zgrabil tool_calls[0], kar je pogost refleks pri učenju klicanja funkcij na primerih z eno samo funkcijo.

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

message = response.choices[0].message

# Več tool_calls v istem 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("---")

# Možni izpis:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Upoštevaj, da oba klica uporabljata isti argument, T1001, vendar imata različna ID-ja: call_abc123 in call_def456. Ti ID-ji so edini način, da model ve, kateri rezultat ustreza kateri zahtevi.

Vrnitev vsakega rezultata prvotnemu klicu

Pravilo je strogo: izvršiti moraš vsako funkcijo in vrniti vsak rezultat v ločenem sporočilu tool, ki nosi ustrezen tool_call_id. Če pozabiš ali zamenjaš ID, lahko model datum pripiše polju za status ali pa zavrne odgovor.

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

# Izvrši vse zahtevane funkcije
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

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

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

# Pošlji vse rezultate nazaj modelu
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026, and its status is: paid."

Model nato združi oba fragmenta v en stavek, kot da bi informacije prišle iz enega samega vira. To je točno učinek, ki ga želiš z vidika uporabnika.

Prehod od navidezne vzporednosti k pravi vzporednosti

Ena podrobnost pogosto uide bralcem ob prvem branju: v zgornji zanki for se funkcije izvršujejo ena za drugo. Model je svoje klice zahteval vzporedno, tvoja koda pa ostaja zaporedna. Dokler tvoje funkcije berejo podatkovni okvir (DataFrame) v pomnilniku, to ni pomembno. Ko pa začnejo poizvedovati v zunanjem API-ju ali bazi podatkov, se dva klica po 300 ms spremenita v 600 ms zaznane zakasnitve in korist vzporednosti izgine. Če so tvoje funkcije asinhrone, asyncio.gather jih zažene skupaj in počaka na celoten paket.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Executes tool_calls in parallel and returns the results."""

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

    # Execute all functions in parallel
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

Večina obstoječih kodnih zbirk uporablja sinhronizirane funkcije, ki jih ne boš želel prepisati v async samo zaradi tega. Skupina niti (thread pool) doseže enak učinek, ne da bi se dotaknil tvoje poslovne logike.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Executes tool_calls using a thread pool."""
    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

Ponovni nadzor s parametrom parallel_tool_calls

Vzporednost ni vedno zaželena. Parameter parallel_tool_calls ti omogoča, da jo dovoliš ali prepoveš. Ko je nastavljen na True (privzeto), se model sam odloči, ali bo svoje klice združil. Ko je nastavljen na False, lahko v vsakem odgovoru ustvari le en tool_call.

# Dovoli vzporedne klice (privzeto)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Model se odloči
)

# Vsili zaporedne klice
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Le en tool_call na odgovor
)

Trije scenariji upravičujejo nastavitev tega parametra na False. Prvi je, ko je vrstni red izvrševanja pomemben: zaračunavanje pred preverjanjem zaloge da drugačen rezultat kot obratno. Drugi vključuje odvisnosti podatkov, kjer je rezultat ene funkcije potreben za klic naslednje – na primer, iskanje stika za pridobitev njegovega ID-ja pred spremembo njegovega zapisa. Tretji se preprosto nanaša na potrebo po natančnejšem nadzoru nad tokom, običajno med razhroščevanjem, ko želiš opazovati vsak klic izolirano, preden odpreš vse pipe.

Kaj vzporednost dejansko spremeni

Dobiček ni le v nitih; primarno gre za število krožnih potovanj do API-ja, ki dominirajo nad celotno zakasnitvijo.

# Zaporedno (2 klica API-ja do modela)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Vzporedno (samo 1 dodatni klic API-ja)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

V zaporednem vzorcu mora model zaključiti dva polna razmisleka, preden poda končni odgovor. V vzporednem vzorcu ena sama zahteva pridobi vse tool_calls, za odgovor pa je potreben le en dodatni klic. Pri vprašanju, ki vključuje dve ali tri funkcije, to uporabniku običajno prihrani več sekund.

Ključne ugotovitve

  • Model lahko v enem samem odgovoru ustvari več tool_calls
  • Vsak rezultat mora biti vrnjen s pravilnim tool_call_id
  • Za omrežne funkcije uporabi asyncio ali ThreadPoolExecutor za pravo vzporedno izvrševanje
  • Parameter parallel_tool_calls nadzira to vedenje (privzeto True)
  • Vzporedni vzorec zmanjša število zahtev API-ja in izboljša zakasnitev