Vestluse olek ja seansi haldus
Sellel lehel
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_idaheldab 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