Párhuzamos függvényhívások
Ezen az oldalon
- Amikor a modellnek egyszerre több információra van szüksége
- Több hívást tartalmazó válasz olvasása
- Minden eredmény visszaküldése az eredeti híváshoz
- A látszólagos párhuzamosságtól a valódi párhuzamosságig
- Vezérlés visszavétele a parallel_tool_calls paraméterrel
- Amit a párhuzamosítás valójában megváltoztat
- 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_callselemet is generálhat egyetlen válaszon belül - Minden eredményt a helyes
tool_call_idsegítségével kell visszaküldeni - Hálózati függvények esetén használd az
asynciovagy aThreadPoolExecutoreszközt a valódi párhuzamos végrehajtáshoz - A
parallel_tool_callsparaméter vezérli ezt a viselkedést (alapértelmezettenTrue) - A párhuzamos mintázat csökkenti az API-kérések számát és javítja a késleltetést