Būsenos valdymas pokalbiuose ir sesijų administravimas
Šiame puslapyje
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_idautomatiš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ą