Stato della conversazione e gestione delle sessioni
In questa pagina
Stato della conversazione e gestione delle sessioni
Le API Responses supportano nativamente lo stato della conversazione, semplificando drasticamente il mantenimento del contesto tra i vari turni. Non devi più ricostruire la cronologia per ogni richiesta: il server se ne occupa per te e tu devi solo passare un identificatore.
Concatenazione con previous_response_id
Il meccanismo si riduce a un singolo campo. Ogni risposta ha un id; passalo nel parametro previous_response_id alla chiamata successiva e il modello avrà accesso a tutto ciò che è stato detto prima. Nello scambio seguente, la terza domanda—«Come le sommo?»—non avrebbe senso isolata: la concatenazione permette al modello di sapere che stiamo parlando di frazioni e che l’utente è un principiante.
from openai import OpenAI
client = OpenAI()
# Primo scambio
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}")
# Secondo scambio — il contesto viene preservato automaticamente
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}")
# Terzo scambio — l'intera conversazione è accessibile
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}")
# Il modello sa che stiamo parlando di frazioni dall'inizio
Considera la differenza rispetto all’approccio precedente. Con Chat Completions, la conversazione viveva in una lista che dovevi mantenere tu stesso e reinviare integralmente a ogni turno, con costi che crescevano man mano che lo scambio si allungava.
# VECCHIO — dovevi gestire tutto da solo
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?"},
]
# Inviato integralmente a ogni chiamata = costi in aumento
Lo stesso scambio si riduce ora a un singolo riferimento:
# NUOVO — basta un singolo ID
r = client.responses.create(
model="gpt-5.6-terra",
input="How do I add them?",
previous_response_id="previous_response_id"
)
# Il server gestisce la cronologia per te
Esecuzione di conversazioni multiple
Non appena la tua applicazione serve più utenti, sorge la domanda: a chi appartiene quale identificatore? La risposta è una tabella di mappatura tra l’utente e l’ultimo response.id della sua conversazione. Il gestore seguente incapsula questa logica: aggiunge previous_response_id solo se esiste già una sessione, quindi memorizza il nuovo identificatore. Alice e Bob possono così conversare in parallelo senza che i loro contesti si mescolino, e «nuova sessione» significa semplicemente dimenticare l’identificatore corrente.
class SessionManager:
"""Gestore di sessioni per conversazioni."""
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:
"""Invia un messaggio nella sessione dell'utente."""
kwargs = {
"model": "gpt-5.6-terra",
"input": message,
}
# Aggiungi istruzioni se fornite
if instructions:
kwargs["instructions"] = instructions
# Concatena con la risposta precedente se esiste
if user_id in self.sessions:
kwargs["previous_response_id"] = self.sessions[user_id]
response = client.responses.create(**kwargs)
# Salva l'ID per il prossimo turno
self.sessions[user_id] = response.id
return response.output_text
def new_session(self, user_id: str):
"""Avvia una nuova conversazione per l'utente."""
if user_id in self.sessions:
del self.sessions[user_id]
# Utilizzo
manager = SessionManager()
# Utente Alice
print(manager.send_message("alice", "Hello, tell me about Python."))
print(manager.send_message("alice", "What are its advantages?"))
# Utente Bob (conversazione indipendente)
print(manager.send_message("bob", "Hello, tell me about Rust."))
# Alice continua la sua conversazione su Python
print(manager.send_message("alice", "How do I get started?"))
Quando prendere il controllo della cronologia
La concatenazione automatica ha un limite: non puoi modificare ciò che è già stato detto. Se la tua applicazione ha bisogno di riassumere i turni passati, eliminare un messaggio contenente dati personali o reiniettare un contesto riformulato, passa all’input strutturato e gestisci la lista da solo. Perdi in semplicità, ma guadagni il pieno controllo e la capacità di tracciare l’inflazione dei token turno dopo turno.
def manual_conversation():
"""Conversazione con gestione manuale della cronologia."""
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" (Cumulative tokens: {response.usage.input_tokens})")
# manual_conversation()
Sopravvivere a un riavvio
Un dizionario in memoria scompare al primo ridispiegamento, portando con sé tutte le conversazioni attive. In produzione, persisti gli identificatori: il file JSON seguente illustra il principio, che puoi adattare al tuo database o a Redis. Nota che registriamo anche il timestamp e l’uso dei token, due informazioni utilizzate rispettivamente per la scadenza e il tracciamento dei costi.
import json
from datetime import datetime
class PersistentSessionManager:
"""Sessioni persistenti con 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
Infine, implementa la scadenza. Senza pulizia, la tua tabella delle sessioni non farà che crescere e un utente che torna dopo tre settimane riprenderebbe una conversazione che non ricorda più. Ventiquattro ore sono un punto di partenza ragionevole, aggiustabile in base al tuo caso d’uso.
from datetime import datetime, timedelta
def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
"""Rimuove le sessioni scadute."""
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} expired session(s) removed")
return active
Per riassumere queste scelte: usa previous_response_id per conversazioni semplici, è il metodo più efficiente; passa all’input strutturato quando devi modificare la cronologia; memorizza response.id in modo affidabile, in un database piuttosto che in memoria; pulisci le sessioni inattive; e monitora i token cumulativi, altrimenti la fatturazione ti raggiungerà.
Punti chiave
previous_response_idconcatena le risposte automaticamente senza reinviare la cronologia- Ogni risposta ha un
idunico utilizzabile per la concatenazione - Gestisci più sessioni con un dizionario
user_id -> response_id - L’input strutturato (lista di messaggi) offre maggior controllo sulla cronologia
- Implementa la persistenza e la scadenza delle sessioni in produzione