Function Calling: az AI összekötése a rendszereiddel
Ezen az oldalon
Function Calling: az AI összekötése a rendszereiddel
A function calling lehetővé teszi, hogy a modell általad definiált függvényeket hívjon meg. Tartsd szem előtt ezt az egyetlen szabályt, mert minden más ebből következik: a modell nem hajtja végre ezeket. Csak azt közli veled, melyik függvényt kell meghívni és milyen argumentumokkal; a kódod végzi el a végrehajtást és adja vissza az eredményt. Az adatbázisod, hitelesítő adataid és üzleti logikád soha nem hagyja el a saját infrastruktúrádat.
A teljes folyamat, lépésről lépésre
A kommunikáció négy szakaszban zajlik:
- Deklarálod az elérhető függvényeket és paramétereiket
- A modell elemzi a kérést, és eldönti, hogy meghív egy függvényt
- A kódod végrehajtja a függvényt, és megszerzi az eredményt
- Visszaküldöd az eredményt a modellnek, hogy az megfogalmazhassa a válaszát
A deklaráció különös gondosságot igényel: a függvény description mezője és az egyes paraméterek leírása az egyetlen dokumentáció, amire a modellnek szüksége van a döntés meghozatalához. A homályos leírások hozzávetőleges hívásokhoz vezetnek. Figyeld meg azt is, hogyan zárul a kör: az eredményt azzal a call_id-vel küldöd vissza, amit kaptál; ez visszaigazolásként szolgál, és lehetővé teszi az API számára, hogy párosítsa a választ a kéréssel.
from openai import OpenAI
import json
client = OpenAI()
# 1. lépés: Elérhető függvények deklarálása
tools = [{
"type": "function",
"name": "get_meteo",
"description": "Get the current weather for a city",
"parameters": {
"type": "object",
"properties": {
"ville": {
"type": "string",
"description": "The name of the city"
},
"unite": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Temperature unit"
}
},
"required": ["ville"]
}
}]
# 2. lépés: A modell eldönti, hogy meghívja a függvényt
response = client.responses.create(
model="gpt-5.6-terra",
input="What's the weather like in Marseille?",
tools=tools
)
# 3. lépés: A függvény végrehajtása
for item in response.output:
if item.type == "function_call":
print(f"Function: {item.name}")
print(f"Arguments: {item.arguments}")
args = json.loads(item.arguments)
# A tényleges implementációd
resultat_meteo = {"temperature": 22, "condition": "sunny"}
# 4. lépés: Az eredmény visszaküldése a modellnek
final = client.responses.create(
model="gpt-5.6-terra",
input=[
{"role": "user", "content": "What's the weather like in Marseille?"},
{
"type": "function_call_output",
"call_id": item.call_id,
"output": json.dumps(resultat_meteo)
}
],
tools=tools
)
print(f"Response: {final.output_text}")
# Eredmény:
# Function: get_meteo
# Arguments: {"ville": "Marseille"}
# Response: It is currently 22 C in Marseille with sunny weather.
Több eszköz közül választó modell
Az igazi érték akkor mutatkozik meg, ha képességek teljes katalógusát teszed elérhetővé. Egy e-kereskedelmi asszisztens esetén deklarálnád a termékkeresést, a készletellenőrzést és a rendelésfeladást, majd hagynád, hogy a modell döntsön köztük. Ha azt a kérdést kapja, hogy „Elérhető az XPS gaming laptop?“, nem keresést indít, hanem közvetlenül a készletet kérdezi le: ezt a döntést a függvényeid leírásai vezérlik, nem pedig egy hardkódolt szabály.
tools = [
{
"type": "function",
"name": "rechercher_produit",
"description": "Search for a product in the catalog",
"parameters": {
"type": "object",
"properties": {
"requête": {"type": "string", "description": "Search terms"},
"categorie": {"type": "string", "description": "Category (optional)"}
},
"required": ["requête"]
}
},
{
"type": "function",
"name": "verifier_stock",
"description": "Check product availability",
"parameters": {
"type": "object",
"properties": {
"produit_id": {"type": "string", "description": "Product ID"}
},
"required": ["produit_id"]
}
},
{
"type": "function",
"name": "passer_commande",
"description": "Place an order for a product",
"parameters": {
"type": "object",
"properties": {
"produit_id": {"type": "string"},
"quantite": {"type": "integer", "description": "Number of units"}
},
"required": ["produit_id", "quantite"]
}
}
]
# A modell automatikusan kiválasztja a megfelelő függvényt
response = client.responses.create(
model="gpt-5.6-terra",
input="Is the XPS gaming laptop available?",
tools=tools
)
for item in response.output:
if item.type == "function_call":
print(f"Function chosen: {item.name}")
print(f"Arguments: {item.arguments}")
# Eredmény: Function chosen: verifier_stock
# Arguments: {"produit_id": "xps-gaming"}
Egyetlen kérés több párhuzamos hívást is kiválthat. Két város időjárásának összehasonlítása két független hívást eredményez: a kódodnak ezért végig kell iterálnia a response.output elemen, és kezelnie kell az összes function_call típust, soha nem csak az elsőt. Ez egyben lehetőség arra is, hogy ezeket a hívásokat párhuzamosan hajtsd végre, és felére csökkentsd a késleltetést.
response = client.responses.create(
model="gpt-5.6-terra",
input="Compare the weather between Paris and Lyon.",
tools=[{
"type": "function",
"name": "get_meteo",
"description": "Get the weather for a city",
"parameters": {
"type": "object",
"properties": {
"ville": {"type": "string"}
},
"required": ["ville"]
}
}]
)
# A modell két hívást indít párhuzamosan
function_calls = [item for item in response.output if item.type == "function_call"]
print(f"Number of calls: {len(function_calls)}")
for call in function_calls:
args = json.loads(call.arguments)
print(f" - get_meteo({args['ville']})")
# Eredmény:
# Number of calls: 2
# - get_meteo(Paris)
# - get_meteo(Lyon)
Az ügynök-ciklus (Agent Loop)
Egyetlen oda-vissza kommunikáció ritkán elég: egy függvény eredménye gyakran arra készteti a modellt, hogy meghívjon egy másikat. Ezért a kommunikációt egy ciklusba csomagolod, amely addig fut, amíg a válasz függvényhívásokat tartalmaz, és akkor áll meg, amikor már nem – ez annak a jele, hogy a modell megfogalmazta a végső válaszát. Ez minden ügynök (agent) váza, és különféle köntösben minden ügynök-keretrendszerben találkozni fogsz vele.
def executer_fonction(nom: str, arguments: str) -> str:
"""Execute a function and return the result."""
args = json.loads(arguments)
if nom == "get_meteo":
# Szimuláció – cseréld le a valódi API-dra
return json.dumps({"temp": 18, "condition": "cloudy"})
elif nom == "get_heure":
return json.dumps({"heure": "14:30", "timezone": "CET"})
return json.dumps({"error": "Unknown function"})
def agent_loop(question: str, tools: list) -> str:
"""Agent loop: call functions until the final response."""
input_messages = [{"role": "user", "content": question}]
while True:
response = client.responses.create(
model="gpt-5.6-terra",
input=input_messages,
tools=tools
)
# Függvényhívások keresése
function_calls = [i for i in response.output if i.type == "function_call"]
if not function_calls:
# Nincsenek függvényhívások = végső válasz
return response.output_text
# Minden függvény végrehajtása és az eredmények hozzáadása
for call in function_calls:
resultat = executer_fonction(call.name, call.arguments)
input_messages.append({
"type": "function_call_output",
"call_id": call.call_id,
"output": resultat
})
# Használat
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)
Egy figyelmeztetés ehhez a mintához: a while True ciklusnak nincsenek biztonsági korlátai. Éles környezetben adj hozzá egy maximális iterációs számlálót; ellenkező esetben egy modell, amely végtelenül ugyanazt az eszközt kéri, elégeti a költségkeretedet anélkül, hogy valaha is befejezné a feladatot.
Argumentumok szigorú módjának biztosítása
A szigorú mód (strict mode) ugyanazt a garanciát biztosítja a függvényparaméterekre, mint a strukturált kimenet (Structured Output) a válaszokra: az argumentumok szigorúan ragaszkodnak a deklarált sémához. Egy felhasználót létrehozó függvény esetén ez megakadályozza, hogy az életkort szövegként kapd meg, vagy olyan extra mezőt, amire a kódod nem számított.
tools = [{
"type": "function",
"name": "creer_utilisateur",
"description": "Create a new user",
"strict": True,
"parameters": {
"type": "object",
"properties": {
"nom": {"type": "string"},
"email": {"type": "string"},
"age": {"type": "integer"}
},
"required": ["nom", "email", "age"],
"additionalProperties": False
}
}]
Főbb megállapítások
- A function calling összeköti a modellt a rendszereiddel anélkül, hogy felfedné az adataidat
- A modell eldönti, melyik függvényt hívja meg; a kódod végrehajtja azt
- Az eredményt a
function_call_outputés acall_idhasználatával kell visszaküldeni - A modell több függvényt is meghívhat párhuzamosan
- Használj ügynök-ciklust (agent loop) a függvényeket érintő többmenetes beszélgetésekhez
- Engedélyezd a
strict: Truebeállítást az argumentumok megfelelőségének garantálásához