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

Programmatikus eszközhívás: Modell által vezérelt eszközök

5. lecke 12 közül Frissítve 2026. november 5. Középhaladó
Ezen az oldalon
  1. Mi változik
  2. Bekapcsolás a Responses API-ban
  3. Mit kap az alkalmazásod
  4. Mely feladatok profitálnak belőle
  5. Próbáld ki te is
  6. Főbb megállapítások

Állapot: 2026. november 5. A GPT-6 család örökli a GPT-5.6 API-képességeit, beleértve a programmatikus eszközhívást is. Az Agents API ezt alapértelmezetten engedélyezi (10. lecke). Az OpenAI javasolja a modellkártya ellenőrzését a bekapcsolás előtt.

Hogy megértsd, mit hoz a programmatikus eszközhívás, először meg kell vizsgálnod a klasszikus függvényhívás költségeit. A modell kér egy eszköz végrehajtását, a kódod lefuttatja, az eredmény visszakerül a modellhez, amely elolvassa azt, és eldönti a következő lépést. Egy oda-vissza út nem jelent nagy gondot. Tíz oda-vissza út egyetlen feladat esetén már más történet: minden lépés növeli a késleltetést, és minden közbenső eredmény – még ha terjedelmes vagy irreleváns is a végső válasz szempontjából – áthalad a modell kontextusán, és tokenekben kerül elszámolásra. Eszköz-igényes feladatoknál ezek az oda-vissza utak dominálják mind a késleltetést, mind a költségeket.

Mi változik

A programmatikus eszközhívás 2026. július 9-én jelent meg a GPT-5.6-tal a Responses API-ban. Ahelyett, hogy egyesével kérné az eszközöket, a modell ír egy kis JavaScript programot azok koordinálására. Képes párhuzamosan indítani hívásokat, ciklusokat és feltételeket használni, valamint a közbenső eredményeket a végrehajtási környezeten belül tartani. Csak a csökkentett eredmény – az, ami a következő lépéshez számít – kerül vissza a kontextusba.

Vegyünk egy lapozott API-t. A klasszikus függvényhívásnál az eredmények minden oldala áthalad a kontextuson, hogy a modell eldönthesse, kérje-e a következőt. Programmatikus eszközhívással a modell ír egy ciklust, amely végigiterál az oldalakon, összeadja az szükséges adatokat, és csak az összegzést jelenti vissza: kevesebb token, kisebb késleltetés, és kevesebb karbantartandó orchestrációs kód a részedről.

Az OpenAI minden programot egy friss, izolált V8 környezetben futtat. Nincs Node.js, nincs csomagtelepítés, nincs közvetlen hálózati hozzáférés, nincs általános fájlrendszer, és a programok között nincs állapotmegőrzés. A program csak a számára exponált eszközökön keresztül lép kapcsolatba a külvilággal. A Responses API esetén ez a viselkedés kompatibilis a Zero Data Retention (ZDR) elvvel, feltéve, hogy a ZDR engedélyezve van a szervezetre vagy projektre.

Bekapcsolás a Responses API-ban

Két beállítás elegendő. Hozzáadod a programmatic_tool_calling hosztolt eszközt a kéréshez, majd megadod az allowed_callers mezővel, hogy ki hívhatja meg az egyes jogosult eszközöket: ["direct"] (az alapértelmezett viselkedés, ahol a modell maga hívja meg az eszközt), ["programmatic"] (csak egy program hívhatja meg), vagy mindkettőt. A dokumentáció azt is javasolja, hogy írd le az egyes függvények kimenetét az output_schema segítségével, így a generált kód támaszkodhat ezekre a mezőkre.

from openai import OpenAI

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "read_stock",
        "description": "Returns an object with sku (text) and units (number).",
        "parameters": {
            "type": "object",
            "properties": {"sku": {"type": "string"}},
            "required": ["sku"],
            "additionalProperties": False,
        },
        "output_schema": {
            "type": "object",
            "properties": {"sku": {"type": "string"}, "units": {"type": "number"}},
            "required": ["sku", "units"],
            "additionalProperties": False,
        },
        "allowed_callers": ["programmatic"],
    },
    {"type": "programmatic_tool_calling"},
]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Check stock for SKUs A12, B07, and C33 and flag those under 10 units.",
    tools=tools,
)

A programból hívható eszköztípusok közé tartoznak a függvények és egyedi eszközök, az MCP eszközök, az apply_patch, a helyi vagy hosztolt shell, valamint a kódértelmező. Egy jóváhagyást igénylő MCP eszköz esetén a program addig szünetel, amíg meg nem adod a hozzájárulást.

Mit kap az alkalmazásod

A válasz egy szabványos Responses objektum marad, három felismerendő elemtípussal. A program elem tartalmazza a generált JavaScriptet. A function_call elemek megfelelnek a program által végrehajtott függvényhívásaidnak; ezek caller mezője azonosítja a hívó programot. Végül egy program_output elem szállítja a program végső eredményét, completed vagy incomplete állapottal.

Az alkalmazásod soha nem futtatja a JavaScriptet; azt az OpenAI végzi. Te csak a saját függvényeidet hajtod végre, majd minden eredményt egy function_call_output objektumban adsz vissza úgy, hogy a caller mezőt változatlanul másolod át, így a megfelelő program folytathatja a munkát. Ezt addig ismétled, amíg a válaszban nincs több végrehajtandó hívás.

Ki mit hajt végre Három lépés: a modell ír egy JavaScript programot, amelyet az OpenAI egy izolált környezetben futtat; az alkalmazásod végrehajtja a programból származó függvényhívásokat, és visszaadja az eredményeket a caller mező érintetlenül hagyásával; a program egy csökkentett eredményt szállít a program_output-ban. PROGRAMMATIKUS ESZKÖZHÍVÁS Ki mit hajt végre 1 Program A modell írja 2 A te függvényeid Te hajtod végre 3 Eredmény Csökkentett program_output A JavaScript az OpenAI-nál fut, soha nem nálad. Az érzékeny írási műveletek közvetlen hívások maradnak.
Az OpenAI API dokumentációjának Programmatikus eszközhívás útmutatója alapján (2026. november).

Mely feladatok profitálnak belőle

Nem minden eszközintegráció érdemes a migrációra. Az OpenAI útmutatója világos szabályt kínál: a programmatikus eszközhívás olyan lépésekhez illik, ahol a folyamat kiszámítható, és a kód képes kisebb, strukturált eredményt visszaadni. Több eredmény szűrésére, egyesítésére, rendezésére, deduplikálására, aggregálására vagy validálására tervezték, illetve olyan függő hívások láncolására, ahol az adatfolyam kiszámítható. A közvetlen hívás továbbra is előnyösebb egyetlen keresés vagy művelet esetén, adaptív kereséseknél, ahol minden eredménynek irányítania kell a következő döntést, valamint a végső hivatkozások validálásánál. Ez marad az alapértelmezett választás írási műveleteknél és jóváhagyást igénylő akcióknál is, hogy egyértelmű maradjon a jogosultsági határ.

A döntési kritérium egyetlen kérdésre vezethető vissza: hol tölti az idő nagy részét az ágensed? Ha a válasz az „eszköz oda-vissza utak várakozása“, akkor a programmatikus eszközhívás az első terület, amit érdemes megvizsgálni. Ha az eszközhívásaid ritkák és az eredményeik rövidek, tartsd meg a jelenlegi architektúrádat, és máshová fordítsd az erőfeszítéseidet.

Próbáld ki te is

Azonosíts egy jelöltet. Vegyél egy folyamatot az ágensedben, amely több eszközt hív meg. Minden lépésnél jegyezd fel a hívások számát, a közbenső eredmények méretét, és hogy olvasásról vagy írásról van-e szó. Osztályozd az egyes lépéseket a fenti szabály alapján. A legígéretesebb lépéshez írj egy promptot, amely meghatározza az engedélyezett eszközöket, a várt eredményformátumot, a leállási feltételt, a maximális újrapróbálkozások számát, és azt, ami közvetlen hívás marad.

Hivatalos források: Programmatikus eszközhívás · GPT-6 használata (OpenAI API dokumentáció) · GPT-5.6 bejelentés (OpenAI, 2026. július 9.)

Főbb megállapítások

  • A modell JavaScriptet ír és futtat az eszközei koordinálására egy izolált környezetben, amelyet az OpenAI kezel
  • A programmatic_tool_calling eszközzel és az egyes eszközökön lévő allowed_callers mezővel engedélyezheted
  • Az alkalmazásod csak a saját függvényeit futtatja, és a caller mezőt érintetlenül adja vissza
  • Előnyben részesítsd szűréshez, aggregáláshoz vagy kiszámítható hívások láncolásához; az írási műveleteknél és jóváhagyásoknál a közvetlen hívás marad a szabály