Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Vestluse olek ja seansi haldus

Õppetund 11 / 22 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Vestluse olek ja seansi haldus
  2. Aheldamine eelmise previous_response_id abil
  3. Mitme vestluse samaaegne käivitamine
  4. Millal võtta ajalugu oma kontrolli alla
  5. Taaskäivituse üle elamine
  6. Peamised punktid

Vestluse olek ja seansi haldus

Responses API toetab vestluse olekut loomupäraselt, mis lihtsustab oluliselt konteksti säilitamist erinevate pöörete vahel. Sa ei pea enam iga päringu jaoks ajalugu uuesti üles ehitama: server teeb selle sinu eest ära ja sina edastad vaid identifikaatori.

Aheldamine eelmise previous_response_id abil

Mehhanism taandub ühele väljale. Igal vastusel on id; edasta see järgmisel väljakutsel parameetris previous_response_id ja mudelil on juurdepääs kogu eelnevale. Allpool toodud vahetuses ei oma kolmas küsimus – „Kuidas ma neid liidan?“ – isoleeritult mingit mõtet: aheldamine annab mudelile teada, et jutt käib murdudest ja et kasutaja on algaja.

from openai import OpenAI
client = OpenAI()

# Esimene vahetus
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}")

# Teine vahetus — kontekst säilib automaatselt
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}")

# Kolmas vahetus — kogu vestlus on kättesaadav
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}")
# Mudel teab, et oleme algusest peale rääkinud murdudest

Mõtle erinevusele võrreldes eelmise lähenemisviisiga. Chat Completionsi puhul elas vestlus loendis, mida haldasid ise ja saatsid igal pöördel täies mahus uuesti, mistõttu kulud kasvasid vahetuse pikenedes.

# VANA — pidid kõike ise haldama
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?"},
]
# Saadeti igal väljakutsel täies mahus = kasvavad kulud

Sama vahetus taandub nüüd ühele viitele:

# UUS — piisab ühest ID-st
r = client.responses.create(
    model="gpt-5.6-terra",
    input="How do I add them?",
    previous_response_id="previous_response_id"
)
# Server haldab ajalugu sinu eest

Mitme vestluse samaaegne käivitamine

Niipea kui sinu rakendus teenindab mitut kasutajat, tekib küsimus: milline identifikaator kellele kuulub? Vastuseks on vastendustabel kasutaja ja tema vestluse viimase response.id vahel. Allpool olev haldur kapseldab selle loogika: see lisab previous_response_id ainult siis, kui seanss on juba olemas, ja salvestab seejärel uue identifikaatori. Alice ja Bob saavad seega vestelda paralleelselt ilma, et nende kontekstid seguneksid, ja „uus seanss“ tähendab lihtsalt praeguse identifikaatori unustamist.

class SessionManager:
    """Vestluse seansi haldur."""

    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:
        """Saadab sõnumi kasutaja seansis."""
        kwargs = {
            "model": "gpt-5.6-terra",
            "input": message,
        }

        # Lisa juhised, kui need on olemas
        if instructions:
            kwargs["instructions"] = instructions

        # Ahelda eelmise vastusega, kui see on olemas
        if user_id in self.sessions:
            kwargs["previous_response_id"] = self.sessions[user_id]

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

        # Salvesta ID järgmiseks pöördeks
        self.sessions[user_id] = response.id

        return response.output_text

    def new_session(self, user_id: str):
        """Alustab kasutajale uut vestlust."""
        if user_id in self.sessions:
            del self.sessions[user_id]

# Kasutamine
manager = SessionManager()

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

# Kasutaja Bob (sõltumatu vestlus)
print(manager.send_message("bob", "Hello, tell me about Rust."))

# Alice jätkab oma vestlust Pythonist
print(manager.send_message("alice", "How do I get started?"))

Millal võtta ajalugu oma kontrolli alla

Automaatsel aheldamisel on piirang: sa ei saa muuta seda, mis on juba öeldud. Kui sinu rakendus vajab varasemate pöörete kokkuvõtmist, isikuandmeid sisaldava sõnumi kustutamist või ümber sõnastatud konteksti uuesti sisestamist, lülitu struktureeritud sisendile ja halda loendit ise. Sa kaotad lihtsuse, kuid võidad täieliku kontrolli – ja võime jälgida tokenite kasvu pööre haaval.

def manual_conversation():
    """Vestlus ajaloo käsitsi haldamisega."""
    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"  (Kumulatiivsed tokenid: {response.usage.input_tokens})")

# manual_conversation()

Taaskäivituse üle elamine

Mälus olev sõnastik kaob esimesel ümberpaigutamisel, viies kaasa kõik aktiivsed vestlused. Tootmiskeskkonnas salvesta identifikaatorid püsivalt – allpool olev JSON-fail illustreerib printsiipi, mida saad kohandada oma andmebaasi või Redise jaoks. Pane tähele, et salvestame ka ajatempli ja tokenite kasutuse, kaks teavet, mida kasutatakse vastavalt aegumise ja kulude jälgimiseks.

import json
from datetime import datetime

class PersistentSessionManager:
    """Püsivad seansid varundusega."""

    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

Lõpuks rakenda aegumine. Ilma puhastamiseta kasvab sinu seansitabel ainult suuremaks ja kasutaja, kes naaseb kolme nädala pärast, jätkaks vestlust, mida ta enam ei mäleta. Kakskümmend neli tundi on mõistlik lähtepunkt, mida saab kohandada vastavalt sinu kasutusjuhtumile.

from datetime import datetime, timedelta

def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
    """Eemaldab aegunud seansid."""
    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} aegunud seanss(id) eemaldatud")

    return active

Nende valikute kokkuvõtteks: kasuta lihtsate vestluste jaoks previous_response_id – see on kõige tõhusam; lülitu struktureeritud sisendile, kui vajad ajaloo muutmist; salvesta response.id usaldusväärselt, andmebaasi, mitte mällu; puhasta mitteaktiivsed seansid; ja jälgi kumulatiivseid tokeneid, vastasel juhul jõuab arve sulle kätte.

Peamised punktid

  • previous_response_id aheldab vastuseid automaatselt, ilma ajaloo uuesti saatmiseta
  • Igal vastusel on kordumatu id, mida saab aheldamiseks kasutada
  • Halda mitut seanssi sõnastikuga kasutaja_id -> vastuse_id
  • Struktureeritud sisend (sõnumite loend) pakub ajaloo üle suuremat kontrolli
  • Rakenda tootmiskeskkonnas seansside püsivus ja aegumine