Sarunu stāvoklis un sesiju pārvaldība
Šajā lapā
Sarunu stāvoklis un sesiju pārvaldība
Responses API atbalsta sarunu stāvokli dabiski, kas ievērojami vienkāršo konteksta uzturēšanu starp dialoga gājieniem. Tev vairs nav jārekonstruē vēsture katram pieprasījumam: serveris to paveic tavā vietā, un tev ir tikai jānodod identifikators.
Ķēdēšana ar previous_response_id
Mehānisms reducējas uz vienu lauku. Katrai atbildei ir id; nodod to kā previous_response_id nākamajā izsaukumā, un modelim būs pieejama visa iepriekšējā informācija. Turpmākajā dialogā trešais jautājums — „Kā es tos saskaitu?” — izolēti nav jēdzīgs: ķēdēšana ļauj modelim saprast, ka runa ir par daļskaitļiem un ka lietotājs ir iesācējs.
from openai import OpenAI
client = OpenAI()
# Pirmā apmaiņa
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}")
# Otrā apmaiņa — konteksts tiek saglabāts automātiski
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}")
# Trešā apmaiņa — visa saruna ir pieejama
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 zina, ka no paša sākuma esam runājuši par daļskaitļiem
Apsver atšķirību no iepriekšējās pieejas. Izmantojot Chat Completions, saruna glabājās sarakstā, ko uzturēji pats un nosūtīji pilnībā katrā gājienā, līdz ar to izmaksas pieauga, sarunai ievelkoties.
# VECĀ PIEEJA — tev bija viss jāpārvalda pašam
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?"},
]
# Nosūtīts pilnībā katrā izsaukumā = augošas izmaksas
Tagad tā pati apmaiņa reducējas uz vienu atsauces vērtību:
# JAUNĀ PIEEJA — pietiek ar vienu ID
r = client.responses.create(
model="gpt-5.6-terra",
input="How do I add them?",
previous_response_id="previous_response_id"
)
# Serveris pārvalda vēsturi tavā vietā
Vairāku sarunu vienlaicīga vadīšana
Tiklīdz tava lietotne apkalpo vairākus lietotājus, rodas jautājums: kurš identifikators pieder kam? Atbilde ir kartēšanas tabula starp lietotāju un jaunāko response.id viņa sarunai. Tālāk redzamais pārvaldnieks ietver šo loģiku: tas pievieno previous_response_id tikai tad, ja sesija jau pastāv, un pēc tam saglabā jauno identifikatoru. Tādējādi Alise un Bobs var sarunāties paralēli, nesajaucot savus kontekstus, bet „jauna sesija” vienkārši nozīmē aizmirst pašreizējo identifikatoru.
class SessionManager:
"""Sarunu sesiju pārvaldnieks."""
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:
"""Nosūta ziņojumu lietotāja sesijā."""
kwargs = {
"model": "gpt-5.6-terra",
"input": message,
}
# Pievieno instrukcijas, ja tās ir norādītas
if instructions:
kwargs["instructions"] = instructions
# Ķēdē ar iepriekšējo atbildi, ja tāda eksistē
if user_id in self.sessions:
kwargs["previous_response_id"] = self.sessions[user_id]
response = client.responses.create(**kwargs)
# Saglabā ID nākamajam gājienam
self.sessions[user_id] = response.id
return response.output_text
def new_session(self, user_id: str):
"""Sāk jaunu sarunu lietotājam."""
if user_id in self.sessions:
del self.sessions[user_id]
# Lietošana
manager = SessionManager()
# Lietotājs Alise
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))
# Lietotājs Bobs (neatkarīga saruna)
print(manager.send_message("bob", "Hello, tell me about Rust."))
# Alise turpina sarunu par Python
print(manager.send_message("alice", "How do I get started?"))
Kad pārņemt vēstures kontroli
Automātiskajai ķēdēšanai ir robeža: tu nevari modificēt jau teikto. Ja tavai lietotnei ir jāapkopo pagātnes gājieni, jādzēš ziņojums, kas satur personas datus, vai atkārtoti jāievada reformulēts konteksts, pārej uz strukturētu ievadi un pārvaldi sarakstu pats. Tu zaudē vienkāršību, bet iegūsti pilnu kontroli — un spēju izsekot tokena pieaugumam katrā gājienā.
def manual_conversation():
"""Saruna ar manuālu vēstures pārvaldību."""
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īvie tokeni: {response.usage.input_tokens})")
# manual_conversation()
Izdzīvošana pēc restarta
Atmiņā glabāts vārdnīcas objekts pazūd jau pirmās izvietošanas reizē, līdzi paņemot visas aktīvās sarunas. Produkcijas vidē identifikatorus ir jāpersistē — tālāk redzamais JSON fails ilustrē principu, ko vari pielāgot savai datubāzei vai Redis. Ņem vērā, ka mēs reģistrējam arī laika zīmogu un tokena izmantojumu: divus datus, ko attiecīgi izmanto derīguma termiņa noteikšanai un izmaksu uzskaitē.
import json
from datetime import datetime
class PersistentSessionManager:
"""Persistētas sesijas ar dublējumu."""
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
Visbeidzot, ievies derīguma termiņu. Bez tīrīšanas tavu sesiju tabula tikai augs, un lietotājs, kas atgriežas pēc trim nedēļām, atsāktu sarunu, ko vairs neatceras. Divdesmit četras stundas ir saprātīgs sākumpunkts, ko vari pielāgot atkarībā no lietojuma gadījuma.
from datetime import datetime, timedelta
def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
"""Noņem beigušās 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} beigusies(-ušās) sesija(-s) noņemta(-s)")
return active
Apkopojot šīs izvēles: izmanto previous_response_id vienkāršām sarunām — tā ir visefektīvākā metode; pārej uz strukturētu ievadi, kad tev ir jāmodificē vēsture; glabā response.id droši, datubāzē, nevis atmiņā; attīri neaktīvās sesijas; un uzraugi kumulatīvos tokenus, pretējā gadījumā rēķini tevi panāks.
Galvenās atziņas
previous_response_idautomātiski ķēdē atbildes, nenosūtot vēsturi atkārtoti- Katrai atbildei ir unikāls
id, ko var izmantot ķēdēšanai - Pārvaldi vairākas sesijas ar vārdnīcu
user_id -> response_id - Strukturēta ievade (ziņojumu saraksts) nodrošina lielāku kontroli pār vēsturi
- Produkcijas vidē ievies sesiju persistenci un derīguma termiņu