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

Végrehajtás és az eredmény visszaadása

6. lecke 14 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. A lépés, amelyet teljes mértékben te irányítasz
  2. A függvény végrehajtása a kliens oldalon
  3. A tool üzenet felépítése
  4. Az eredmény elküldése és a végső válasz lekérése
  5. A teljes folyamat egy blokkban
  6. Az üzenetstruktúra minden lépésben
  7. Figyeld a tartalom formátumát
  8. Főbb megállapítások

A lépés, amelyet teljes mértékben te irányítasz

Megkaptad a modelltől a tool_call üzenetet. Ez csupán annyit közöl, melyik függvényt hívd meg és milyen argumentumokkal – semmi mást. Most a te kódod veszi át az irányítást: végrehajtja a függvényt, lekéri az eredményt, majd vissza küldi azt a modellnek egy tool szerepkörű üzenetként. Ez a lecke ezt a teljes oda-vissza utat tárgyalja. Ez a ciklus egyetlen olyan pillanata, amikor minden döntést te hozol meg.

A függvény végrehajtása a kliens oldalon

Nézzük át újra a 4. leckéből ismert dispatch szótárat, és kössük össze a modell válaszával.

import json
from functools import partial

# Függvények már definiálva
available_functions = {
    "retrieve_payment_status": partial(retrieve_payment_status, df),
    "retrieve_payment_date": partial(retrieve_payment_date, df),
}

# A modell visszaadott egy tool_call-t
tool_call = response.choices[0].message.tool_calls[0]
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)

# Függvény végrehajtása
if function_name in available_functions:
    result = available_functions[function_name](**function_params)
    print(f"Result: {result}")
    # → '{"status": "paid"}'
else:
    result = json.dumps({"error": f"Function {function_name} not available"})

Két mechanizmus működik itt egyszerre. Az első a **function_params, amely kibontja a JSON-ból származó szótárat név szerinti argumentumokká: ha a modell a {"transaction_id": "T1001"} értéket generálta, a hívás pontosan ekvivalens a retrieve_payment_status(transaction_id="T1001") hívással. A második mechanizmus az else ág. Ez kevésbé látványos, de elengedhetetlen. A modell hallucinálhat egy olyan függvénynevet, amely nem létezik a dispatch szótáradban; e ellenőrzés nélkül az alkalmazásod KeyError kivételt dob, és a beszélgetés azonnal megszakad. Ezzel a védelemmel azonban a hiba olyan adattá válik, amelyet a modell elegánsan kezelni tud.

A tool üzenet felépítése

Az eredményt egy speciális formátumban kell visszaküldeni a modellnek: egy "tool" szerepkörű üzenetként.

tool_message = {
    "role": "tool",
    "name": function_name,
    "content": result,  # Szövegnek (string) kell lennie
    "tool_call_id": tool_call.id
}
MezőSzerep
role"tool" – azonosítja az üzenetet mint függvényeredményt
nameA végrehajtott függvény neve
contentAz eredmény JSON szövegként (string)
tool_call_idAz eredeti tool_call azonosítója – lehetővé teszi a modell számára, hogy párosítsa az eredményt a megfelelő hívással

Az eredmény elküldése és a végső válasz lekérése

A modellnek nincs memóriája a hívások között: nem emlékszik arra, hogy bármit is kért tőled. Ezért neked kell újjáépítened számára a teljes beszélgetést, beleértve a saját, eszközlehívásra vonatkozó kérését is, mielőtt bemutatnád neki az eredményt.

# 1. Hozzáadjuk az asszisztens üzenetét (a tool_call-lal)
messages.append(response.choices[0].message)

# 2. Hozzáadjuk a függvény eredményét
messages.append({
    "role": "tool",
    "name": function_name,
    "content": result,
    "tool_call_id": tool_call.id
})

# 3. Újrahívjuk a modellt a teljes kontextussal
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

# 4. Kiírjuk a végső választ
print(final_response.choices[0].message.content)
# → "Payment T1001 status is: paid."

A két append művelet sorrendje nem tárgyalható: a tool_call-t tartalmazó asszisztens üzenetnek meg kell előznie azt a tool üzenetet, amely válaszol rá. Ha felcseréled őket, inkonzisztens előzményt hozol létre, amelyet az API elutasít.

A teljes folyamat egy blokkban

Íme az egész folyamat a felhasználó kérdésétől a végső válaszig:

import os
import json
from mistralai.client import Mistral
from functools import partial

# Konfiguráció
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"

# Függvények és eszközök (korábban definiálva)
available_functions = {
    "retrieve_payment_status": partial(retrieve_payment_status, df),
    "retrieve_payment_date": partial(retrieve_payment_date, df),
}

# 1-2. lépés: Felhasználói kérdés + API hívás
messages = [
    {"role": "user", "content": "What is the status of payment T1001?"}
]

response = client.chat.complete(
    model=model, messages=messages, tools=tools
)

# 3-4. lépés: A tool_call kinyerése és végrehajtása
message = response.choices[0].message

if message.tool_calls:
    tool_call = message.tool_calls[0]
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Kliens oldali végrehajtás
    result = available_functions[function_name](**function_params)

    # 5. lépés: Az eredmény visszaküldése a modellnek
    messages.append(message)
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

    final_response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )
    print(final_response.choices[0].message.content)
else:
    print(message.content)

Az üzenetstruktúra minden lépésben

Érdemes megvizsgálni a messages listát, miután a ciklus lefutott, mert ez a legjobb módszer a hibásan működő függvényhívások debuggolására. A lista négy üzenetet tartalmaz.

# 1. üzenet: A felhasználó kérdése
{"role": "user", "content": "What is the status of payment T1001?"}

# 2. üzenet: A modell válasza a tool_call-lal
{"role": "assistant", "tool_calls": [{"id": "call_abc123", ...}]}

# 3. üzenet: A függvény eredménye
{"role": "tool", "name": "retrieve_payment_status",
 "content": '{"status": "paid"}', "tool_call_id": "call_abc123"}

# 4. üzenet (implicit): A modell végső válasza
# → "Payment T1001 status is: paid."

Kövesd nyomon a call_abc123 azonosítót: ez a 2. üzenetben születik meg, és a 3. üzenetben tűnik fel újra. Ez a szál köti össze a kérést a válaszával. Ez a struktúra a függvényhívások alapvető mintázata; minden későbbi variáció, legyen az több körös vagy párhuzamos, csupán ismétli vagy duplikálja ezt.

Figyeld a tartalom formátumát

Egy hiba gyakrabban fordul elő, mint az összes többi együttvéve, és ennek oka a content mező adattípusa: ennek mindig szövegnek (string) kell lennie.

# Helyes – JSON szöveg
{"content": '{"status": "paid"}'}

# Helyes – sima szöveg
{"content": "The status is paid"}

# Helytelen – Python szótár (hibát okoz)
{"content": {"status": "paid"}}

A különbség az első és a harmadik példa között a JSON-t körülvevő idézőjelekben rejlik. Ha a függvényed szótárat ad vissza, alakítsd át json.dumps() segítségével, mielőtt elküldenéd – pontosan ezért végződtek mind a 4. leckében szereplő függvények egy json.dumps() hívással.

Főbb megállapítások

  • A függvényvégrehajtás a kliens oldalon, a te kódodban történik – soha nem a modell végzi
  • Az eredményt egy "tool" szerepkörű üzenetben küldjük vissza, a megfelelő tool_call_id-vel
  • A tool üzenet content mezőjének szövegnek (JSON szöveg) kell lennie
  • Az eredmény elküldése után újra meghívod a chat.complete() függvényt, hogy a modell megfogalmazhassa a végső választ
  • Mindig ellenőrizd, hogy a kért függvény létezik-e a dispatch szótáradban