A függvényhívás architektúrája a Responses API-ban
Ezen az oldalon
Frissítve: 2026. november 2. az OpenAI dokumentációja alapján: a Code Interpreter eszköz mostantól igényli a
containerparamétert (hozzáadva minden példához), a bemeneti szövegrészek azinput_texttípust használják, a webes keresés pedig aweb_searcheszközt alkalmazza (aweb_search_previewimmár elavult eszköz, domain-szűrők nélkül). A generált fájlok a 10. leckéből ismertfichiers_genereséstelechargerfüggvényekkel érhetők el. Források: Code Interpreter · Web search.
A függvényhívás architektúrája a Responses API-ban
A függvényhívás az a központi mechanizmus, amely lehetővé teszi az OpenAI modellek számára a külvilággal való interakciót. A Responses API-ban ezt a mechanizmust újratervezték, hogy robusztusabb, kiszámíthatóbb legyen, és natívan integrálódjon a beépített eszközökkel, mint például a Web Search és a Code Interpreter.
Az alapelv
A modell sosem végez közvetlenül műveleteket. Ehelyett strukturált szándékokat bocsát ki, amelyeket a te kódod interceptál és hajt végre. Így megfogalmazva technikai korlátozásnak tűnhet; a valóságban azonban ez az a tervezési döntés, amely minden mást lehetővé tesz.
Gondold végig az alternatívát. Ha a modell maga hajtaná végre a műveleteket, át kellene adnod neki az adatbázis-hitelesítő adataidat, az API-kulcsaidat és az írási engedélyeket – és nem lenne egyetlen pont sem, ahol bármit is ellenőrizhetnél. A leválasztással minden szándék áthalad a te kódodon: te validálod az argumentumokat, érvényesíted az üzleti szabályokat, és szükség esetén elutasítod a kérést. A modell javasol, a te kódod dönt, és ez a határvonal az, ami lehetővé teszi, hogy a függvényhívást éles környezetben használd anélkül, hogy elveszítenéd az irányítást.
from openai import OpenAI
client = OpenAI()
# Egyéni eszköz deklarálása
tools = [{
"type": "function",
"name": "rechercher_client",
"description": "Search for a client in the CRM by name or email",
"parameters": {
"type": "object",
"properties": {
"terme": {
"type": "string",
"description": "Client name, email, or ID"
},
"champ": {
"type": "string",
"enum": ["nom", "email", "id"],
"description": "Field to search in"
}
},
"required": ["terme"]
}
}]
response = client.responses.create(
model="gpt-5.6-terra",
input="Find the client Jean Dupont",
tools=tools
)
Egy válasz anatómiája
Egy válasz nem tartalmaz vagy szöveget vagy eszköz hívásokat: az output egy heterogén lista, amely mindkettőt keverheti. Az első sor kódtól kezdve azt a szokást kell kialakítanod, hogy iterálsz ezen a listán, ahelyett, hogy csak az output[0] elemet olvasnád ki – egy olyan modell, amely mielőtt függvényt hívna, először kifejti az érvelését, pontosan ezt az esetet produkálja, és az a kód, amely csak az első elemet olvassa ki, összeomlik azon a napon, amikor a modell kommentárokat kezd fűzni a híváshoz.
for item in response.output:
if item.type == "function_call":
print(f"Call ID : {item.call_id}")
print(f"Function : {item.name}")
print(f"Args : {item.arguments}")
A call_id elengedhetetlen: ez köti össze a hívást az eredményével, amikor visszaküldöd a választ a modellnek. Egyetlen hívásnál alig veszed észre; három párhuzamos hívásnál viszont ez az egyetlen dolog, ami megakadályozza, hogy Lyon időjárását tulajdonítsd a Marseille-lel kapcsolatos kérésnek. Mindig azzal a call_id-vel add vissza az eredményt, amit kaptál, sosem egy általad újraépített azonosítóval.
A teljes ciklus
Ez a négy lépésből álló ciklus változatlan: érvényes egy függvényre és húszra is, egy egyszerű hívásra és egy tíz eszközt láncoló ágensre is. Minden későbbi komplexitás – párhuzamosítás, hibakezelés, tartalék megoldások – e ciklus instrumentálásából áll, sosem annak helyettesítéséből.
import json
# 1. Első hívás a deklarált eszközökkel
response = client.responses.create(
model="gpt-5.6-terra",
input="What is the balance for client [email protected]?",
tools=tools
)
# 2. Függvényhívások észlelése és végrehajtása
resultats = []
for item in response.output:
if item.type == "function_call":
if item.name == "rechercher_client":
args = json.loads(item.arguments)
resultat = votre_crm.rechercher(args["terme"])
resultats.append({
"type": "function_call_output",
"call_id": item.call_id,
"output": json.dumps(resultat)
})
# 3. Eredmények visszaküldése a modellnek
response_finale = client.responses.create(
model="gpt-5.6-terra",
input=response.output + resultats,
tools=tools
)
# 4. A modell megfogalmazza a természetes válaszát
print(response_finale.output_text)
Fő különbségek a Chat Completions-höz képest
A Responses API számos architektúrális fejlesztést hoz.
A beépített eszközök natív kezelése
A beépített eszközöket pontosan úgy deklarálod, mint a saját függvényeidet, de azok az OpenAI oldalán futnak. A gyakorlati előny kellemes: nem kell hozzájuk ciklust írnod. A modell hív, megkapja az eredményt, és folytatja, mindezt egyetlen kör alatt. A fent leírt ciklus csak a te függvényeidre vonatkozik – azokra, amelyek a te gépeden futnak.
# Beépített és egyéni eszközök keverése
tools = [
{"type": "web_search"},
{"type": "code_interpreter", "container": {"type": "auto"}},
{
"type": "function",
"name": "ma_fonction",
"description": "My custom function",
"parameters": {"type": "object", "properties": {}}
}
]
Stabil hívásazonosítók
Minden függvényhívás egy egyedi call_id-t kap, amely lehetővé teszi, hogy pontosan nyomon kövesd, melyik eredmény tartozik melyik híváshoz, még párhuzamos hívások esetén is.
Egyszerűsített folyamat
Nincs szükség az assistant és tool szerepkörök kézi kezelésére az üzenetekben. Az input mező közvetlenül elfogadja a korábbi kimenetek és a függvényeredmények összefűzését.
Mikor hív a modell egy függvényt?
A modell akkor dönt úgy, hogy függvényt hív, amikor a felhasználó kérése olyan információt igényel, amellyel nem rendelkezik, amikor a függvény leírása illeszkedik az azonosított szükségletre, és amikor a szükséges paraméterek a kontextusból következtethetők.
Három feltételnek kell tehát egyszerre teljesülnie, és ez hasznos a hibakereséshez: amikor egy függvényt nem hívnak meg, pedig kellene, az ok szinte mindig a második – egy olyan leírás, amely nem fedi le azt a módot, ahogyan a felhasználó megfogalmazta a kérését. A tool_choice paraméter lehetővé teszi a viselkedés kényszerítését, amikor a leírás nem elég:
# Hagyd, hogy a modell döntsön
tool_choice = "auto"
# Kényszeríts ki egy hívást egy adott függvényre
tool_choice = {"type": "function", "name": "rechercher_client"}
# Tilts le minden függvényhívást
tool_choice = "none"
# Kötelezővé tesz legalább egy hívást anélkül, hogy megadnád, melyiket
tool_choice = "required"
Főbb megállapítások
- A függvényhívás egy szándékprotokoll, nem pedig egy végrehajtási protokoll
- A hívás-végrehajtás-visszatérés ciklus az alapvető minta
- A beépített és az egyéni eszközök ugyanabban a
toolstömbben coexistálnak - A
call_idbiztosítja az egyes hívások nyomon követhetőségét - A
tool_choicelehetővé teszi a modell viselkedésének finomhangolását