Starea conversației și gestionarea sesiunilor
Pe această pagină
Starea conversației și gestionarea sesiunilor
API-ul Responses gestionează nativ starea conversației, ceea ce simplifică drastic menținerea contextului între diferitele intervenții. Nu mai este nevoie să reconstruiți istoricul pentru fiecare cerere: serverul se ocupă de acest lucru, iar dumneavoastră transmiteți doar un identificator.
Înlănțuirea prin previous_response_id
Mecanismul se rezumă la un singur câmp. Fiecare răspuns are un id; transmiteți-l în previous_response_id la apelul următor, iar modelul va avea acces la tot ce s-a spus anterior. În schimbul de mai jos, a treia întrebare — „Cum le adun?“ — nu ar avea sens izolată: înlănțuirea permite modelului să înțeleagă că discutați despre fracții și că utilizatorul este începător.
from openai import OpenAI
client = OpenAI()
# Primul schimb
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}")
# Al doilea schimb — contextul este păstrat automat
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}")
# Al treilea schimb — întreaga conversație este accesibilă
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}")
# Modelul știe că am vorbit despre fracții de la început
Analizați diferența față de abordarea anterioară. Cu Chat Completions, conversația exista într-o listă pe care o gestionați dumneavoastră și o retransmiteți integral la fiecare intervenție, costurile crescând pe măsură ce schimbul se lunghea.
# VECHI — trebuia să gestionați totul manual
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?"},
]
# Transmis integral la fiecare apel = costuri în creștere
Același schimb se reduce acum la o simplă referință:
# NOU — un singur ID este suficient
r = client.responses.create(
model="gpt-5.6-terra",
input="How do I add them?",
previous_response_id="previous_response_id"
)
# Serverul gestionează istoricul pentru dumneavoastră
Derularea mai multor conversații
De îndată ce aplicația dumneavoastră deservește mai mulți utilizatori, apare întrebarea: cărui utilizator îi aparține哪个 identificator? Răspunsul constă într-un tabel de corespondență între utilizator și ultimul response.id al conversației sale. Managerul de mai jos încapsulează această logică: adaugă previous_response_id doar dacă există deja o sesiune, apoi stochează noul identificator. Astfel, Alice și Bob pot conversa în paralel fără ca contextele lor să se amestece, iar „sesiune nouă“ înseamnă pur și simplu uitarea identificatorului curent.
class SessionManager:
"""Manager de sesiuni pentru conversații."""
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:
"""Trimite un mesaj în sesiunea utilizatorului."""
kwargs = {
"model": "gpt-5.6-terra",
"input": message,
}
# Adaugă instrucțiuni dacă sunt furnizate
if instructions:
kwargs["instructions"] = instructions
# Înlănțuiește cu răspunsul anterior dacă există
if user_id in self.sessions:
kwargs["previous_response_id"] = self.sessions[user_id]
response = client.responses.create(**kwargs)
# Salvează ID-ul pentru următoarea intervenție
self.sessions[user_id] = response.id
return response.output_text
def new_session(self, user_id: str):
"""Pornește o conversație nouă pentru utilizator."""
if user_id in self.sessions:
del self.sessions[user_id]
# Utilizare
manager = SessionManager()
# Utilizatorul Alice
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))
# Utilizatorul Bob (conversație independentă)
print(manager.send_message("bob", "Hello, tell me about Rust."))
# Alice își continuă conversația despre Python
print(manager.send_message("alice", "How do I get started?"))
Când să preluați controlul asupra istoricului
Înlănțuirea automată are o limită: nu puteți modifica ceea ce s-a spus deja. Dacă aplicația dumneavoastră trebuie să rezume intervențiile anterioare, să șteargă un mesaj conținând date personale sau să reinjecteze un context reformulat, treceți la intrarea structurată și gestionați lista dumneavoastră. Pierdeți simplitatea, dar câștigați control total — și capacitatea de a urmări inflația tokenilor la fiecare intervenție.
def manual_conversation():
"""Conversație cu gestionarea manuală a istoricului."""
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" (Tokeni cumulati: {response.usage.input_tokens})")
# manual_conversation()
Supraviețuirea unei reporniri
Un dicționar în memorie dispare la prima reimplementare, luând cu el toate conversațiile active. În producție, persistați identificatorii — fișierul JSON de mai jos ilustrează principiul, pe care îl puteți adapta bazei de date sau Redis-ului dumneavoastră. Rețineți că înregistrăm și marcajul temporal și utilizarea tokenilor, două informații folosite respectiv pentru expirare și urmărirea costurilor.
import json
from datetime import datetime
class PersistentSessionManager:
"""Sesiuni persistente cu backup."""
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
În final, implementați expirarea. Fără curățare, tabelul de sesiuni doar crește, iar un utilizator care se întoarce după trei săptămâni ar relua o conversație pe care nu și-o mai amintește. Douăzeci și patru de ore reprezintă un punct de plecare rezonabil, ajustabil în funcție de cazul dumneavoastră de utilizare.
from datetime import datetime, timedelta
def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
"""Elimină sesiunile expirate."""
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} sesiune(i) expirată(e) eliminată(e)")
return active
Pentru a rezuma aceste alegeri: utilizați previous_response_id pentru conversații simple — este cea mai eficientă metodă; treceți la intrarea structurată când aveți nevoie să modificați istoricul; stocați response.id în mod fiabil, într-o bază de date și nu în memorie; curățați sesiunile inactive; și monitorizați tokenii cumulați, altfel facturile vă vor ajunge din urmă.
Puncte cheie
previous_response_idînlănțuie răspunsurile automat fără a retransmite istoricul- Fiecare răspuns are un
idunic utilizabil pentru înlănțuire - Gestionați mai multe sesiuni cu un dicționar
user_id -> response_id - Intrarea structurată (lista de mesaje) oferă mai mult control asupra istoricului
- Implementați persistența și expirarea sesiunilor în producție