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

Function Calling: az AI összekötése a rendszereiddel

10. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Function Calling: az AI összekötése a rendszereiddel
  2. A teljes folyamat, lépésről lépésre
  3. Több eszköz közül választó modell
  4. Az ügynök-ciklus (Agent Loop)
  5. Argumentumok szigorú módjának biztosítása
  6. Főbb megállapítások

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:

  1. Deklarálod az elérhető függvényeket és paramétereiket
  2. A modell elemzi a kérést, és eldönti, hogy meghív egy függvényt
  3. A kódod végrehajtja a függvényt, és megszerzi az eredményt
  4. 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 a call_id haszná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: True beállítást az argumentumok megfelelőségének garantálásához