Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Párhuzamos függvényhívások

8. lecke 14 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Amikor a modellnek egyszerre több információra van szüksége
  2. Több hívást tartalmazó válasz olvasása
  3. Minden eredmény visszaküldése az eredeti híváshoz
  4. A látszólagos párhuzamosságtól a valódi párhuzamosságig
  5. Vezérlés visszavétele a parallel_tool_calls paraméterrel
  6. Amit a párhuzamosítás valójában megváltoztat
  7. Főbb megállapítások

Amikor a modellnek egyszerre több információra van szüksége

Eddig a beszélgetés minden fordulójában egyetlen függvényhívás történt. Sok valós kérdés azonban nem illik ebbe a keretbe. Képzeld el, hogy egy felhasználó azt kérdezi: „Mi a T1001-es fizetés státusza és dátuma?“ A modellnek két információra van szüksége, amelyek két különböző függvényben találhatók: retrieve_payment_status és retrieve_payment_date. Kérhetné őket egymás után is, várva a válaszodra a kettő között. Itt azonban úgy dönt, hogy egyik sem függ a másiktól, ezért több tool_calls elemet generál egyetlen válaszon belül. Te egyszerre kapod meg az egész munkaterhelést, és te döntöd el, hogyan hajtod végre.

Több hívást tartalmazó válasz olvasása

A gyakorlati következmény egyszerű: a message.tool_calls már nem egyelemű lista. Iterálnod kell rajta, ahelyett, hogy csak a tool_calls[0]-t ragadnád meg, ami gyakori reflex, amikor valaki egyetlen függvényes példákból tanulja a függvényhívást.

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

message = response.choices[0].message

# Több tool_calls ugyanabban a válaszban
for tc in message.tool_calls:
    print(f"Function: {tc.function.name}")
    print(f"Arguments: {tc.function.arguments}")
    print(f"ID: {tc.id}")
    print("---")

# Lehetséges kimenet:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Vedd észre, hogy mindkét hívás ugyanazt az argumentumot használja (T1001), de eltérő azonosítóval rendelkezik: call_abc123 és call_def456. Ezek az azonosítók az egyetlen módjai annak, hogy a modell tudja, melyik eredmény melyik kéréshez tartozik.

Minden eredmény visszaküldése az eredeti híváshoz

A szabály szigorú: minden függvényt végre kell hajtanod, és minden eredményt vissza kell küldenöd egy különálló tool üzenetben, amely tartalmazza a megfelelő tool_call_id-t. Ha elfelejted vagy felcseréled az azonosítót, a modell hozzárendelheti a dátumot a státusz mezőhöz, vagy akár meg is tagadhatja a választ.

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

# Az összes kért függvény végrehajtása
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # A függvény végrehajtása
    result = available_functions[function_name](**function_params)

    # Az eredmény hozzáadása a helyes tool_call_id-val
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Az összes eredmény visszaküldése a modellnek
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)
# → "A T1001-es fizetés 2026. március 15-én történt, státusza: fizetve."

A modell ezután egyetlen mondattá fűzi össze a két információdarabkát, mintha azok egyetlen forrásból származnának. Pontosan ezt a hatást szeretnéd elérni a felhasználó szemszögéből.

A látszólagos párhuzamosságtól a valódi párhuzamosságig

Egy részlet gyakran elkerüli az olvasók figyelmét első olvasásra: a fenti for ciklusban a függvények egymás után hajtódnak végre. A modell párhuzamosan kérte a hívásokat, de a kódod sorrendi marad. Addig, amíg a függvényeid egy memóriában lévő DataFrame-et olvasnak, ennek nincs jelentősége. Amint azonban külső API-t vagy adatbázist kérdeznek le, két 300 ms-os hívás 600 ms érzékelt késleltetést eredményez, és a párhuzamosítás előnye elpárolog. Ha a függvényeid aszinkronok, az asyncio.gather egyszerre indítja el őket, és megvárja a teljes köteg befejezését.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Végrehajtja a tool_calls elemeket párhuzamosan, és visszaadja az eredményeket."""

    async def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        # Ha a függvényeid aszinkronok:
        result = await available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    # Az összes függvény párhuzamos végrehajtása
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

A legtöbb meglévő kódbázis szinkron függvényeket tesz elérhetővé, amelyeket nem akarsz átírni async módra csak emiatt. Egy szálkezelő pool (thread pool) ugyanazt a hatást éri el anélkül, hogy hozzá kellene nyúlnod az üzleti logikádhoz.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Végrehajtja a tool_calls elemeket egy szálkezelő pool segítségével."""
    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

Vezérlés visszavétele a parallel_tool_calls paraméterrel

A párhuzamosítás nem mindig kívánatos. A parallel_tool_calls paraméterrel engedélyezheted vagy letilthatod ezt a funkciót. Ha True értékre van állítva (ez az alapértelmezett), a modell dönti el, hogy csoportosítja-e a hívásait. Ha False, akkor válaszonként csak egyetlen tool_call-t generálhat.

# Párhuzamos hívások engedélyezése (alapértelmezett)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # A modell dönt
)

# Sorrendi hívások kényszerítése
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Csak egy tool_call válaszonként
)

Három helyzet indokolja ennek False-ra állítását. Az első, amikor a végrehajtási sorrend számít: a számlázás előtt ellenőrizni a készletet más eredményt ad, mint fordítva. A második adatfüggőségeket érint, ahol az egyik függvény eredménye szükséges a következő hívásához – például egy kontakt megtalálása az ID-jének megszerzéséhez, mielőtt módosítanánk az adatlapját. A harmadik egyszerűen a folyamat feletti finomabb kontroll szükségességével függ össze, jellemzően hibakeresés során, amikor minden hívást izoláltan szeretnél megfigyelni, mielőtt teljesen megnyitnád a kapukat.

Amit a párhuzamosítás valójában megváltoztat

A nyereség nem csupán a szálakban rejlik; elsősorban az API felé irányuló körök (round trips) számáról szól, amelyek dominálják a teljes késleltetést.

# Sorrendi (2 API-hívás a modellhez)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Párhuzamos (csak 1 további API-hívás)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

A sorrendi mintázatban a modellnek két teljes gondolkodási kört kell teljesítenie a végső válasz előtt. A párhuzamos mintázatban egyetlen kérés lekéri az összes tool_calls elemet, és csak egy további kérés szükséges a válaszhoz. Két-három függvényt érintő kérdések esetén ez gyakran több másodpercet spórol meg a felhasználónak.

Főbb megállapítások

  • A modell több tool_calls elemet is generálhat egyetlen válaszon belül
  • Minden eredményt a helyes tool_call_id segítségével kell visszaküldeni
  • Hálózati függvények esetén használd az asyncio vagy a ThreadPoolExecutor eszközt a valódi párhuzamos végrehajtáshoz
  • A parallel_tool_calls paraméter vezérli ezt a viselkedést (alapértelmezetten True)
  • A párhuzamos mintázat csökkenti az API-kérések számát és javítja a késleltetést