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

Párhuzamos hívások

6. lecke 14 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Több eszköz egyetlen válaszban
  2. A parallel_tool_calls paraméter
  3. Párhuzamos hívások kezelése
  4. Valódi párhuzamos végrehajtás a kliens oldalon
  5. Párhuzamos hívások letiltása
  6. Párhuzamos hívások különböző eszközökkel
  7. Hibakezelés párhuzamos módban
  8. Főbb megállapítások

Több eszköz egyetlen válaszban

A Grok függvényhívás egyik legerősebb tulajdonsága, hogy egyetlen válaszban több eszköz hívását is vissza tudja adni. Ahelyett, hogy minden függvényhez külön körmenetet végezne, a modell azonosítja az összes szükséges információt, és párhuzamosan generálja az összes hívást.

A parallel_tool_calls paraméter

A párhuzamos hívások alapértelmezés szerint engedélyezettek. A parallel_tool_calls paraméter vezérli ezt a viselkedést:

# Alapértelmezés szerint engedélyezve (nem kell megadni)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Ez az alapértelmezett érték
)

Amikor a felhasználó azt kérdezi: „Milyen az időjárás Párizsban és Lyonban?“, a modell két tool_calls elemet ad vissza ugyanabban a válaszban:

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

Párhuzamos hívások kezelése

A kódodnak egy tool_calls tömböt kell kezelnie, nem csak egy elemet:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Összes függvény végrehajtása
    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)
        })

    # MINDEN eredmény visszaküldése a modellnek
    messages = [
        {"role": "user", "content": "Milyen az időjárás Párizsban és Lyonban?"},
        message,
        *tool_results  # Minden eredmény
    ]

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

Kritikus pont: minden eszközeredményt vissza kell adnod, nem csak az elsőt. Minden eredmény a hozzá tartozó tool_call_id-hoz van kötve.

Valódi párhuzamos végrehajtás a kliens oldalon

A modell párhuzamosan adja vissza a hívásokat, de a kódodnak is párhuzamosan kell végrehajtania azokat. Pythonban használd az asyncio vagy a concurrent.futures modult:

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

A párhuzamos végrehajtás jelentősen csökkenti a teljes késleltetést. Ha minden API-hívás 200 ms-ot vesz igénybe, akkor két szekvenciális hívás = 400 ms, míg két párhuzamos hívás = ~200 ms.

Párhuzamos hívások letiltása

Bizonyos esetekben szekvenciális hívásokra lesz szükséged:

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

Akkor tiltsd le a párhuzamosságot, ha a hívások függetlensége nem garantált. A legkézenfekvőbb eset az adatfüggőség: ha az egyik eszköz eredménye a következő eszköz argumentumaiba kerül – például egy ügyfélazonosító lekérése, mielőtt lekérnéd a rendeléseit –, akkor a párhuzamos futtatás legjobb esetben hibát okoz, rosszabb esetben csendesen helytelen eredményt produkál. Az üzleti logika sorrendje ugyanilyen korlátot szab: felhasználó létrehozása, mielőtt szerepet rendelnél hozzá, nem tárgyalható, és ezt csak a szekvenciális mód garantálja. Két további gyakorlati ok egészíti ki a képet: egy olyan külső API, amelyre egyidejű kérelmek korlátai vonatkoznak, nem kezeli jól a párhuzamos hívások rohamát; fejlesztés közben pedig a szekvenciális mód végtelenül átláthatóbbá teszi a hívások nyomon követését – egy hívás, egy eredmény, egy naplóbejegyzés, sorrendben.

Párhuzamos hívások különböző eszközökkel

A modell különböző eszközöket is meghívhat párhuzamosan:

# Kérés: „Foglalj asztalt, és mondd meg, milyen az időjárás ma este“
# A modell visszaadja:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

Ez különösen hasznos sokoldalú asszisztensek esetén, amelyeknek különböző forrásokból kell információt gyűjteniük.

Hibakezelés párhuzamos módban

Ha egy hívás meghiúsul, de mások sikerrel járnak, akkor is minden eredményt adj vissza. A modell kezeli az egyes hibákat:

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)})
        })

Főbb megállapítások

  • A párhuzamos hívások alapértelmezés szerint engedélyezettek (parallel_tool_calls: true)
  • A modell több tool_calls elemet ad vissza egyetlen válaszban
  • Minden eredményt vissza kell adnod, mindegyiket a saját tool_call_id-jához kötve
  • Implementálj kliens oldali párhuzamos végrehajtást a késleltetés csökkentése érdekében
  • Tiltsd le a párhuzamosságot, ha függőség van a hívások között
  • Kezeld a hibákat egyenként – ne blokkolj mindent egyetlen hiba miatt