Salt la conținutul principal
Română— Alege o limbă
Meniu

Starea conversației și gestionarea sesiunilor

Lecția 11 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Starea conversației și gestionarea sesiunilor
  2. Înlănțuirea prin previous_response_id
  3. Derularea mai multor conversații
  4. Când să preluați controlul asupra istoricului
  5. Supraviețuirea unei reporniri
  6. Puncte cheie

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 id unic 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