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

Beszélgetési állapot és munkamenet-kezelés

11. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Beszélgetési állapot és munkamenet-kezelés
  2. Láncolás a previous_response_id segítségével
  3. Több beszélgetés futtatása
  4. Mikor vedd át az irányítást az előzmények felett?
  5. Újraindítás túlélése
  6. Főbb megállapítások

Beszélgetési állapot és munkamenet-kezelés

A Responses API natívan támogatja a beszélgetési állapotot, ami drasztikusan leegyszerűsíti a kontextus fenntartását a fordulók között. Többé nem kell minden kérésnél újjáépítened az előzményeket: a szerver elvégzi ezt helyetted, neked csak egy azonosítót kell átadnod.

Láncolás a previous_response_id segítségével

A mechanizmus egyetlen mezőre redukálódik. Minden válasznak van egy id-je; add át ezt a previous_response_id paraméterben a következő híváskor, és a modell hozzáfér minden korábbi információhoz. Az alábbi párbeszédben a harmadik kérdés – „Hogyan adjam őket össze?“ – önmagában értelmetlen: a láncolás révén a modell tudja, hogy törtekről beszélgetünk, és hogy a felhasználó kezdő.

from openai import OpenAI
client = OpenAI()

# Első csere
r1 = client.responses.create(
    model="gpt-5.6-terra",
    instructions="You are a patient math teacher.",
    input="I'd like to learn about fractions."
)
print(f"R1: {r1.output_text}")

# Második csere — a kontextus automatikusan megmarad
r2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Can you give me a concrete example?",
    previous_response_id=r1.id
)
print(f"R2: {r2.output_text}")

# Harmadik csere — a teljes beszélgetés elérhető
r3 = client.responses.create(
    model="gpt-5.6-terra",
    input="And how do I add them?",
    previous_response_id=r2.id
)
print(f"R3: {r3.output_text}")
# A modell tudja, hogy a kezdetektől fogva törtekről beszélgettünk

Vesd össze ezt a korábbi megközelítéssel. A Chat Completions esetén a beszélgetés egy általad kezelt listában élt, amelyet minden fordulóban teljes egészében újraküldtél, így a költségek a beszélgetés hosszával nőttek.

# RÉGI — mindent neked kellett kezelned
history = [
    {"role": "system", "content": "You are a math teacher."},
    {"role": "user", "content": "I'd like to learn about fractions."},
    {"role": "assistant", "content": "Sure! Fractions..."},
    {"role": "user", "content": "A concrete example?"},
    {"role": "assistant", "content": "Let's take a pizza..."},
    {"role": "user", "content": "How do I add them?"},
]
# Minden híváskor teljes egészében elküldve = növekvő költségek

Ugyanez a csere most egyetlen hivatkozásra redukálódik:

# ÚJ — egyetlen azonosító is elég
r = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I add them?",
    previous_response_id="previous_response_id"
)
# A szerver kezeli helyetted az előzményeket

Több beszélgetés futtatása

Amint az alkalmazásod több felhasználót is kiszolgál, felmerül a kérdés: melyik azonosító kihez tartozik? A válasz egy lekérdezési tábla a felhasználó és a beszélgetésük legutóbbi response.id-je között. Az alábbi kezelő egységbe zárja ezt a logikát: csak akkor adja hozzá a previous_response_id-t, ha már létezik munkamenet, majd eltárolja az új azonosítót. Így Alice és Bob párhuzamosan beszélgethet anélkül, hogy a kontextusaik keverednének, az „új munkamenet“ pedig egyszerűen a jelenlegi azonosító elfelejtését jelenti.

class SessionManager:
    """Beszélgetési munkamenet-kezelő."""

    def __init__(self):
        self.sessions: dict[str, str] = {}  # user_id -> last_response_id

    def send_message(self, user_id: str, message: str,
                     instructions: str = "") -> str:
        """Üzenet küldése a felhasználó munkamenetében."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Utasítások hozzáadása, ha megadva
        if instructions:
            kwargs["instructions"] = instructions

        # Láncolás az előző válasszal, ha létezik
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

        response = client.responses.create(**kwargs)

        # Az azonosító mentése a következő fordulóhoz
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Új beszélgetés indítása a felhasználó számára."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Használat
manager = SessionManager()

# Alice felhasználó
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))

# Bob felhasználó (független beszélgetés)
print(manager.send_message("bob", "Hello, tell me about Rust."))

# Alice folytatja a beszélgetést a Pythonról
print(manager.send_message("alice", "How do I get started?"))

Mikor vedd át az irányítást az előzmények felett?

Az automatikus láncolásnak van határa: nem módosíthatod azt, ami már elhangzott. Ha az alkalmazásodnak összegeznie kell a korábbi fordulókat, törölnie kell egy személyes adatokat tartalmazó üzenetet, vagy újra be kell injektálnia egy átfogalmazott kontextust, válts strukturált bemenetre, és kezeld magad a listát. Elveszíted az egyszerűséget, cserébe teljes kontrollt nyersz – és lehetőséget kapsz a tokeninfláció fordulóról fordulóra történő nyomon követésére.

def manual_conversation():
    """Beszélgetés kézi előzménykezeléssel."""
    history = []

    while True:
        user_input = input("You: ")
        if user_input.lower() == "quit":
            break

        history.append({"role": "user", "content": user_input})

        response = client.responses.create(
            model="gpt-5.6-terra",
            instructions="You are a concise assistant.",
            input=history
        )

        assistant_msg = response.output_text
        history.append({"role": "assistant", "content": assistant_msg})

        print(f"Assistant: {assistant_msg}")
        print(f"  (Kumulatív tokenek: {response.usage.input_tokens})")

# manual_conversation()

Újraindítás túlélése

Egy memóriában tárolt szótár az első újratelepítéskor eltűnik, magával ragadva az összes aktív beszélgetést. Éles környezetben tartósítsd az azonosítókat – az alábbi JSON-fájl szemlélteti az elvet, amelyet saját adatbázisodhoz vagy Redishez igazíthatsz. Figyeld meg, hogy az időbélyeget és a tokenhasználatot is rögzítjük; ez a két információ rendre a lejárat és a költségek nyomon követésére szolgál.

import json
from datetime import datetime

class PersistentSessionManager:
    """Tartós munkamenetek biztonsági mentéssel."""

    def __init__(self, db_path: str = "sessions.json"):
        self.db_path = db_path
        self.sessions = self._load()

    def _load(self) -> dict:
        try:
            with open(self.db_path, "r") as f:
                return json.load(f)
        except FileNotFoundError:
            return {}

    def _save(self):
        with open(self.db_path, "w") as f:
            json.dump(self.sessions, f, indent=2)

    def send(self, session_id: str, message: str) -> str:
        kwargs = {"model": "gpt-5.6-terra", "input": message}

        if session_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[session_id]["last_id"]

        response = client.responses.create(**kwargs)

        self.sessions[session_id] = {
            "last_id": response.id,
            "updated_at": datetime.now().isoformat(),
            "total_tokens": response.usage.total_tokens
        }
        self._save()

        return response.output_text

Végül implementáld a lejáratot. Takarítás nélkül a munkamenet-táblád csak nő, és egy három hét múlva visszatérő felhasználó olyan beszélgetést folytatna, amire már nem emlékszik. A huszonnégy óra ésszerű kiindulópont, amely használati eseted alapján állítható.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Lejárt munkamenetek eltávolítása."""
    now = datetime.now()
    active = {}

    for sid, data in sessions.items():
        updated = datetime.fromisoformat(data["updated_at"])
        if now - updated < timedelta(hours=max_age_hours):
            active[sid] = data

    deleted = len(sessions) - len(active)
    if deleted > 0:
        print(f"{deleted} lejárt munkamenet törölve")

    return active

Összefoglalva ezeket a döntéseket: használd a previous_response_id-t az egyszerű beszélgetésekhez – ez a leghatékonyabb; válts strukturált bemenetre, ha módosítanod kell az előzményeket; tárold megbízhatóan a response.id-t, inkább adatbázisban, mint memóriában; takarítsd ki az inaktív munkameneteket; és figyeld a kumulatív tokeneket, különben a számlázás utolér.

Főbb megállapítások

  • A previous_response_id automatikusan láncolja a válaszokat az előzmények újraküldése nélkül
  • Minden válasznak van egy egyedi id-je, amely láncolásra használható
  • Kezelj több munkamenetet egy user_id -> response_id szótárral
  • A strukturált bemenet (üzenetlista) nagyobb kontrollt biztosít az előzmények felett
  • Éles környezetben valósítsd meg a munkamenetek tartósítását és lejáratát