Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Būsenos valdymas pokalbiuose ir sesijų administravimas

Paskaita 11 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Būsenos valdymas pokalbiuose ir sesijų administravimas
  2. Grandininis ryšys naudojant previous_response_id
  3. Kelių pokalbių vykdymas
  4. Kada perimti istorijos valdymą
  5. Išgyvenimas po paleidimo iš naujo
  6. Svarbiausi punktai

Būsenos valdymas pokalbiuose ir sesijų administravimas

„Responses API“ natūraliai palaiko pokalbio būseną, todėl išlaikyti kontekstą tarp skirtingų žingsnių tampa daug paprasčiau. Tau nebereikia kiekvienam užklausai iš naujo kurti istorijos: serveris tai atlieka už tave, o tau tereikia perduoti identifikatorių.

Grandininis ryšys naudojant previous_response_id

Visas mechanizmas remiasi vienu lauku. Kiekvienas atsakymas turi id; perduok jį kaip previous_response_id kitame kvietime, ir modelis turės prieigą prie visko, kas buvo anksčiau. Toliau pateiktame pavyzdyje trečiasis klausimas – „Kaip juos sudėti?“ – atskirai neturi prasmės: grandininis ryšys leidžia modeliui suprasti, kad kalbame apie trupmenas ir kad vartotojas yra pradedantysis.

from openai import OpenAI
client = OpenAI()

# Pirmasis mainai
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}")

# Antrieji mainai – kontekstas išsaugomas automatiškai
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}")

# Tretieji mainai – visas pokalbis yra pasiekiamas
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}")
# Modelis žino, kad nuo pat pradžių kalbėjome apie trupmenas

Pagalvok apie skirtumą, lyginant su ankstesniu požiūriu. Naudojant „Chat Completions“, pokalbis egzistavo sąraše, kurį turėjai valdyti pats ir siųsti visą iš naujo kiekviename žingsnyje, todėl ilgėjant pokalbiui didėjo ir išlaidos.

# SENAS BŪDAS – viską turėjai valdyti pats
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?"},
]
# Siunčiama visa informacija kiekvieno kvietimo metu = didėjančios išlaidos

Tas pats pokalbis dabar sumažėja iki vienos nuorodos:

# NAUJAS BŪDAS – pakanka vieno ID
r = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I add them?",
    previous_response_id="previous_response_id"
)
# Serveris valdo istoriją už tave

Kelių pokalbių vykdymas

Kai tavo programa aptarnauja kelis vartotojus, kyla klausimas: kuriam vartotojui priklauso kuris identifikatorius? Atsakymas – tai atitikmenų lentelė tarp vartotojo ir naujausio jo pokalbio response.id. Toliau pateiktas valdytojas apima šią logiką: jis prideda previous_response_id tik tada, kai sesija jau egzistuoja, ir tada išsaugo naują identifikatorių. Taip Alisa ir Bobas gali bendrauti lygiagrečiai nesumaišydami savo kontekstų, o „nauja sesija“ tiesiog reiškia dabartinio identifikatoriaus pamiršimą.

class SessionManager:
    """Pokalbio sesijų valdytojas."""

    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:
        """Siunčia žinutę vartotojo sesijoje."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Prideda instrukcijas, jei jos pateiktos
        if instructions:
            kwargs["instructions"] = instructions

        # Sujungia su ankstesniu atsakymu, jei jis egzistuoja
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

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

        # Išsaugo ID kitam žingsniui
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Pradeda naują pokalbį vartotojui."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Naudojimas
manager = SessionManager()

# Vartotoja Alisa
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))

# Vartotojas Bobas (nepriklausomas pokalbis)
print(manager.send_message("bob", "Hello, tell me about Rust."))

# Alisa tęsia savo pokalbį apie Python
print(manager.send_message("alice", "How do I get started?"))

Kada perimti istorijos valdymą

Automatinis grandininis ryšys turi ribą: negali modifikuoti to, kas jau buvo pasakyta. Jei tavo programai reikia apibendrinti ankstesnius žingsnius, ištrinti žinutę su asmeniniais duomenimis arba iš naujo įterpti performuluotą kontekstą, pereik prie struktūrizuotos įvesties ir valdyk sąrašą pats. Prarandi paprastumą, bet įgyji visišką kontrolę – ir galimybę stebėti žetonų kaupimąsi nuo žingsnio iki žingsnio.

def manual_conversation():
    """Pokalbis rankiniu būdu valdant istoriją."""
    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"  (Sukaupti žetonai: {response.usage.input_tokens})")

# manual_conversation()

Išgyvenimas po paleidimo iš naujo

Atmintyje saugomas žodynas išnyksta jau po pirmojo diegimo iš naujo, kartu prarandant visas aktyvias pokalbių sesijas. Gamybinėje aplinkoje identifikatorius reikia išsaugoti nuolatinei saugyklai – toliau pateiktas JSON failas iliustruoja principą, kurį gali pritaikyti savo duomenų bazei arba „Redis“. Atkreipk dėmesį, kad taip pat įrašome laiko žymą ir žetonų naudojimą – tai dvi informacijos dalys, naudojamos atitinkamai galiojimo laikui ir išlaidų stebėsenai.

import json
from datetime import datetime

class PersistentSessionManager:
    """Nuolatinės sesijos su atsargine kopija."""

    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

Galiausiai įgyvendink galiojimo laiko nustatymą. Be valymo tavo sesijų lentelė tik didės, o vartotojas, grįžęs po trijų savaičių, pratęstų pokalbį, kurio jau nebeprisimena. Dvidešimt keturios valandos yra pagrįstas pradinis taškas, kurį galima koreguoti pagal tavo naudojimo atvejį.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Pašalina pasenusias sesijas."""
    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} pasenusi(-ių) sesija(-os) pašalinta(-os)")

    return active

Apibendrinant šiuos pasirinkimus: naudok previous_response_id paprastiems pokalbiams – tai efektyviausias būdas; pereik prie struktūrizuotos įvesties, kai reikia modifikuoti istoriją; patikimai saugok response.id duomenų bazėje, o ne atmintyje; valyk neaktyvias sesijas; ir stebėk sukauptus žetonus, kitaip sąskaita netrukus tau primins apie save.

Svarbiausi punktai

  • previous_response_id automatiškai sujungia atsakymus nesiunčiant istorijos iš naujo
  • Kiekvienas atsakymas turi unikalų id, tinkamą grandininiam ryšiui kurti
  • Kelias sesijas valdyk naudodamas žodyną user_id -> response_id
  • Struktūrizuota įvestis (žinučių sąrašas) suteikia daugiau kontrolės over istoriją
  • Gamybinėje aplinkoje įgyvendink sesijų išsaugojimą ir galiojimo laiko nustatymą