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

Többmenetes beszélgetés

7. lecke 14 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Túl az egyszeri hívásokon
  2. Az elv: Az előzmények megőrzése
  3. Teljes beszélgetési ciklus
  4. Többmenetes beszélgetés példa
  5. Szekvenciális hívások láncolása
  6. Az előzmények méretének kezelése
  7. Főbb megállapítások

Túl az egyszeri hívásokon

Egy valós alkalmazásban a felhasználók nem tesznek fel egy kérdést, majd tűnnek el. Láncolt kéréseket küldenek, visszatérnek korábbi témákhoz, és olyan utalásokat ejtenek, mint például „mi a helyzet ezzel?“, amelyeket önmagában a mondat nem tud feloldani. A függvényhívásnak ebben a többmenetes beszélgetési kontextusban kell működnie, ahol a modell a párbeszéd minden lépésében képes függvényeket hívni anélkül, hogy valaha is elveszítené a fonalat az előzmények tekintetében.

Az elv: Az előzmények megőrzése

A kulcs egyetlen mondatra vezethető vissza: tartsd meg az összes üzenetet egy listában, amely minden egyes váltással bővül. A modellnek nincs saját memóriája az API-hívások között; az egyetlen kontextusa az, amit visszaküldesz neki. Ez a teljes előzmény teszi lehetővé, hogy megértse az implicit hivatkozásokat.

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

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"

# Beszélgetési előzmények
messages = [
    {
        "role": "system",
        "content": "You are a payment tracking assistant. "
                   "Respond in concise English."
    }
]

Teljes beszélgetési ciklus

Az alábbi kód két szakaszban működik. A process_tool_calls végrehajtja a modell által kért összes hívást, és újraindítja a beszélgetést az eredményekkel; a chat pedig kezel egy teljes menetet, a felhasználó bemenetétől a végső szövegig.

def process_tool_calls(response, messages, available_functions, tools):
    """Feldolgozza a tool_calls-okat, és visszaadja a végső választ."""
    message = response.choices[0].message
    messages.append(message)

    # Minden tool_call végrehajtása
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)

        if function_name in available_functions:
            result = available_functions[function_name](**function_params)
        else:
            result = json.dumps({"error": f"Unknown function {function_name}"})

        messages.append({
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        })

    # A modell ismételt meghívása az eredményekkel
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Kezel egy teljes beszélgetési menetet."""
    messages.append({"role": "user", "content": user_input})

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

    message = response.choices[0].message

    # Ciklus addig, amíg a modell függvényeket akar hívni
    while message.tool_calls and len(message.tool_calls) > 0:
        response = process_tool_calls(
            response, messages, available_functions, tools
        )
        message = response.choices[0].message

    # A modell végzett – szöveges választ ad
    messages.append(message)
    return message.content

A while ciklus a kritikus elem. Miután megkapta egy függvény eredményét, a modell akár egy újabbat is kérhet: a ciklus addig fut, amíg tool_calls keletkezik, és csak akkor áll le, amikor a modell végre szöveget ad vissza. Egy egyszerű if csak az első hívást kezelné, majd üres választ adna minden olyan esetben, ahol két hívásra lenne szükség.

Többmenetes beszélgetés példa

Nézzük meg, hogyan néz ki ez a ciklus négy összeláncolt menet során.

# 1. menet
reponse = chat("What is the status of payment T1001?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 status: paid."

# 2. menet — utánkövető kérdés
reponse = chat("When was it made?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."

# 3. menet — új tranzakció
reponse = chat("Compare with payment T1003.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."

# 4. menet — kérdés függvény nélkül
reponse = chat("Thanks, that's all for today.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "You're welcome! Feel free to ask if you have other questions."

A 2. menetet érdemes alaposan megvizsgálni. A „Mikor történt?“ kérdés nem tartalmaz azonosítót; az előzmények teszik lehetővé, hogy a modell megértse: ez még mindig a T1001-re vonatkozik, és a helyes argumentummal hívja meg a retrieve_payment_date függvényt. Ha eltávolítanád az 1. menet üzeneteit, ez a mondat megoldhatatlanná válna. A 3. menetben a modell dönthet úgy, hogy több függvényt is meghív – státuszt és dátumot a T1003-hoz –, hogy felépítse az összehasonlítást a T1001-hez már megszerzett eredményekkel. A 4. menet egyáltalán nem indít hívásokat: a modell azt is tudja, mikor kell visszafognia magát.

Szekvenciális hívások láncolása

Egyes kérések megkövetelik, hogy a modell megvárjon egy eredményt, mielőtt tudná, mit kérjen legközelebb. A chat() függvényben lévő while ciklus ezt az esetet is kezeli, egyetlen extra sor kód nélkül.

# A felhasználó olyat kér, ami 2 szekvenciális hívást igényel
reponse = chat(
    "Show me the status and date of payment T1002.",
    messages, tools, available_functions
)
# A modell teheti a következőket:
# 1. Meghívja a retrieve_payment_status(T1002) függvényt
# 2. Megkapja az eredményt
# 3. Meghívja a retrieve_payment_date(T1002) függvényt
# 4. Megkapja az eredményt
# 5. Megfogalmazza a végső választ mindkét információ birtokában

Az üzenetelőzmények felől nézve a szekvenciális folyamat így néz ki:

user → assistant(tool_call_1) → tool(result_1) → assistant(tool_call_2) → tool(result_2) → assistant(response)

Számold meg az asszisztens meneteit: három, ami három, az API-nak számlázott kérést jelent. Ez a szekvenciális végrehajtás költsége, és ez az oka annak, hogy a következő leckében a párhuzamos hívásokra fókuszálunk.

Az előzmények méretének kezelése

Éles környezetben egy hosszú ideig futó beszélgetés drágává válik: minden menet visszaküldi az összes korábbi üzenetet, és a tokenköltség négyzetesen nő. Egy egyszerű stratégia, ha csak a rendszerüzenetet és a legfrissebb váltásokat tartjuk meg.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Megtartja a rendszerüzenetet és az utolsó N üzenetet."""
    system_messages = [m for m in messages if hasattr(m, "role")
                       and m.get("role") == "system"
                       or (isinstance(m, dict) and m.get("role") == "system")]

    non_system = [m for m in messages if m not in system_messages]

    if len(non_system) > max_messages:
        non_system = non_system[-max_messages:]

    return system_messages + non_system

Egy óvintézkedés, mielőtt bekötnéd ezt a függvényt: soha ne vágj el egy tool_call-t a hozzá tartozó tool üzenet nélkül. Ha a csonkítás a kettő közé esik, az API egy megválaszolatlan hívási kérést kap, és elutasítja a lekérdezést. Igazítsd a vágási pontot úgy, hogy megőrizd a teljes párokat, ahelyett, hogy vakon számolnád az üzeneteket.

Főbb megállapítások

  • Tarts meg egy teljes előzményt az üzenetekről, hogy a modell megértse a kontextust
  • Használj egy while ciklust a szekvenciális függvényhívások kezelésére
  • A modell az implicit hivatkozásokat („ezt“, „az előzőt“) a kontextusnak köszönhetően érti meg
  • Éles környezetben korlátozd az előzmények méretét, miközben érintetlenül hagyod a tool_call/tool párokat
  • Az itt bemutatott chat() függvény egy újrafelhasználható minta bármilyen függvényhívó alkalmazáshoz