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

Az 5 lépéses folyamat

2. lecke 14 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Egyértelmű protokoll közted és a modell között
  2. A folyamat részletesen
  3. Folyamatminták
  4. Főbb megállapítások

Egyértelmű protokoll közted és a modell között

A Mistral függvényhívása egy jól meghatározott, öt lépésből álló folyamatot követ. A protokoll átláthatóságát az biztosítja, hogy minden lépésnek egyetlen felelőse van: vagy te (a fejlesztő), vagy a modell, vagy a felhasználó. Egyetlen lépés sem közös, és egyik sem ambiguus. Szánj időt arra, hogy megjegyezd ezt a munkamegosztást, mielőtt egyetlen sor kódot is írnál: a függvényhívással kapcsolatos hibák többsége abból adódik, hogy a fejlesztő azt várja a modelltől, hogy olyan lépést hajtson végre, amely valójában az ő feladata.

1

A függvények definiálása (Fejlesztő)

Minden elérhető függvényt egy JSON sémával írsz le: név, leírás, paraméterek, típusok és kötelező mezők. A modell csak ezt a specifikációt látja, a kódodat nem.

2

A felhasználó felteszi a kérdését (Felhasználó)

A felhasználó természetes nyelven teszi fel a kérdését. Te ezt a kérést elküldöd a Mistral modellnek az elérhető eszközök listájával együtt.

3

Argumentumok generálása (Modell)

A modell elemzi a kérést, kiválasztja a megfelelő függvényt, és JSON formátumban generálja az argumentumokat. Nem hajtja végre a függvényt – csupán megmondja neked, mit hívj meg és milyen paraméterekkel.

4

A függvény végrehajtása (Fejlesztő)

A kódod kinyeri a függvény nevét és az argumentumokat a modell válaszából, futtatja a megfelelő függvényt, majd lekéri az eredményt.

5

A végső válasz generálása (Modell)

Visszaküldöd a függvény eredményét a modellnek. Az beépíti az eredményt a beszélgetés kontextusába, és természetes választ fogalmaz meg a felhasználó számára.

A folyamat részletesen

Ez az öt lépés közvetlenül leképezhető a kódra. Nézzük végig őket egyetlen, szándékosan minimalista példán keresztül: a felhasználó tudni szeretné a T1001-es fizetés státuszát. Ezt a példát használjuk futó szálként a „Python megvalósítás“ blokk végéig, ezért most ismerkedj meg az azonosítóival.

1. lépés: Te definiálod az eszközöket

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_payment_status",
            "description": "Retrieves the status of a payment given its transaction ID",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "The unique transaction identifier (e.g., T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    }
]

Itt semmi sem végrehajtható kód: ez csupán egy leírás. A modell megtanulja, hogy létezik egy get_payment_status nevű függvény, mit csinál, és hogy egy transaction_id nevű, string típusú paramétert igényel. Soha nem tudja meg, hogyan van implementálva a függvény.

2. lépés: A felhasználó felteszi a kérdését

messages = [
    {"role": "user", "content": "What is the status of payment T1001?"}
]

3. lépés: A modell generálja az argumentumokat

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

# The model returns a tool_call:
# function.name = "get_payment_status"
# function.arguments = '{"transaction_id": "T1001"}'

A modell kinyerte a „T1001“ értéket a mondatból, és a megfelelő mezőbe helyezte. Vegyed észre, hogy az arguments stringként érkezik, nem szótárként: ezt a részletet a következő lépésben kezeled majd.

4. lépés: Te végrehajtod a függvényt

import json

tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_payment_status(**args)
# → {"status": "paid", "date": "2026-03-15"}

5. lépés: A modell megfogalmazza a választ

messages.append(response.choices[0].message)
messages.append({
    "role": "tool",
    "name": "get_payment_status",
    "content": json.dumps(result),
    "tool_call_id": tool_call.id
})

final = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)
print(final.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026."

Két üzenet kerül a történetbe, soha nem csak egy: az asszisztens üzenete, amely tartalmazza a hívási kérést, majd az eredményt hordozó üzenet. A tool_call_id köti össze a kettőt. Ha bármelyiket kihagyod, az API elutasítja a kérést, vagy a modell témán kívüli választ ad.

Folyamatminták

A kérés összetettségétől függően ez a folyamat különböző formákat ölthet. A legegyszerűbb eset, amikor nincs szó függvényről: a felhasználó általános kérdést tesz fel – „Mit tudsz csinálni?“ –, és a modell közvetlenül válaszol anélkül, hogy valaha is érintené az eszközöket. Ezt követi az imént végigvett egyszerű hívás: egy függvény, egy eredmény, egy válasz.

A következő két forma érdekesebb. Egy szekvenciális láncolatban a modell meghív egy első függvényt, elolvassa az eredményt, és ennek alapján dönt egy második hívásról – jellemzően először lekéri az ügyfélazonosítót, mielőtt lekérdezné a számláikat. Egy párhuzamos hívás esetén több függvény végrehajtását kéri egyszerre, mert egyik sem függ a másiktól. E két mintának teljes leckéket szentelünk; egyelőre csak jegyezd meg, hogy mindkettő pontosan a fenti öt lépésre épül, csupán ismétlődnek.

Főbb megállapítások

  • A függvényhívás egy 5 lépéses folyamatot követ, egyértelmű felelősségi körökkel
  • A modell soha nem hajthat végre közvetlenül függvényt – csupán argumentumokat generál
  • A kódod a kapuőr: ez dönti el, hogy végrehajtja-e a függvényt vagy sem
  • A függvény eredményét visszaküldjük a modellnek, hogy az természetes választ fogalmazhasson meg
  • A folyamat lehet egyszerű (egy hívás) vagy összetett (szekvenciális, párhuzamos)