Estado de la conversación y gestión de sesiones
En esta página
Estado de la conversación y gestión de sesiones
La API de Responses admite el estado de la conversación de forma nativa, lo que simplifica drásticamente el mantenimiento del contexto entre turnos. Ya no necesitas reconstruir el historial para cada solicitud: el servidor se encarga de ello por ti y solo debes pasar un identificador.
Encadenamiento con previous_response_id
El mecanismo se reduce a un único campo. Cada respuesta tiene un id; pásalo en previous_response_id en la siguiente llamada y el modelo tendrá acceso a todo lo anterior. En el intercambio siguiente, la tercera pregunta («¿Cómo los sumo?») carece de sentido por sí sola: el encadenamiento permite al modelo saber que estamos hablando de fracciones y que el usuario es principiante.
from openai import OpenAI
client = OpenAI()
# Primer intercambio
r1 = client.responses.create(
model="gpt-5.6-terra",
instructions="Eres un profesor de matemáticas paciente.",
input="Me gustaría aprender sobre fracciones."
)
print(f"R1: {r1.output_text}")
# Segundo intercambio — el contexto se conserva automáticamente
r2 = client.responses.create(
model="gpt-5.6-terra",
input="¿Puedes darme un ejemplo concreto?",
previous_response_id=r1.id
)
print(f"R2: {r2.output_text}")
# Tercer intercambio — toda la conversación está accesible
r3 = client.responses.create(
model="gpt-5.6-terra",
input="¿Y cómo los sumo?",
previous_response_id=r2.id
)
print(f"R3: {r3.output_text}")
# El modelo sabe que hemos estado hablando de fracciones desde el principio
Observa la diferencia respecto al enfoque anterior. Con Chat Completions, la conversación vivía en una lista que mantenías tú mismo y reenviabas completa en cada turno, con costes que crecían a medida que se alargaba el intercambio.
# ANTIGUO — tenías que gestionarlo todo tú mismo
history = [
{"role": "system", "content": "Eres un profesor de matemáticas."},
{"role": "user", "content": "Me gustaría aprender sobre fracciones."},
{"role": "assistant", "content": "¡Claro! Las fracciones..."},
{"role": "user", "content": "¿Un ejemplo concreto?"},
{"role": "assistant", "content": "Tomemos una pizza..."},
{"role": "user", "content": "¿Cómo los sumo?"},
]
# Se envía completo en cada llamada = costes crecientes
El mismo intercambio se reduce ahora a una única referencia:
# NUEVO — basta con un solo ID
r = client.responses.create(
model="gpt-5.6-terra",
input="¿Cómo los sumo?",
previous_response_id="previous_response_id"
)
# El servidor gestiona el historial por ti
Ejecución de múltiples conversaciones
En cuanto tu aplicación da servicio a varios usuarios, surge la pregunta: ¿a quién pertenece cada identificador? La respuesta es una tabla de mapeo entre el usuario y el último response.id de su conversación. El gestor siguiente encapsula esta lógica: añade previous_response_id solo si ya existe una sesión y, a continuación, almacena el nuevo identificador. Así, Alicia y Bob pueden conversar en paralelo sin que se mezclen sus contextos, y «nueva sesión» significa simplemente olvidar el identificador actual.
class SessionManager:
"""Gestor de sesiones de conversación."""
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:
"""Envía un mensaje en la sesión del usuario."""
kwargs = {
"model": "gpt-5.6-terra",
"input": message,
}
# Añade instrucciones si se proporcionan
if instructions:
kwargs["instructions"] = instructions
# Encadena con la respuesta anterior si existe
if user_id in self.sessions:
kwargs["previous_response_id"] = self.sessions[user_id]
response = client.responses.create(**kwargs)
# Guarda el ID para el siguiente turno
self.sessions[user_id] = response.id
return response.output_text
def new_session(self, user_id: str):
"""Inicia una nueva conversación para el usuario."""
if user_id in self.sessions:
del self.sessions[user_id]
# Uso
manager = SessionManager()
# Usuario Alicia
print(manager.send_message("alice", "Hola, háblame de Python."))
print(manager.send_message("alice", "¿Cuáles son sus ventajas?"))
# Usuario Bob (conversación independiente)
print(manager.send_message("bob", "Hola, háblame de Rust."))
# Alicia continúa su conversación sobre Python
print(manager.send_message("alice", "¿Cómo empiezo?"))
Cuándo tomar el control del historial
El encadenamiento automático tiene un límite: no puedes modificar lo que ya se ha dicho. Si tu aplicación necesita resumir turnos pasados, eliminar un mensaje que contenga datos personales o volver a inyectar un contexto reformulado, cambia a entrada estructurada y gestiona la lista tú mismo. Pierdes simplicidad, pero ganas control total, así como la capacidad de rastrear la inflación de tokens turno tras turno.
def manual_conversation():
"""Conversación con gestión manual del historial."""
history = []
while True:
user_input = input("Tú: ")
if user_input.lower() == "quit":
break
history.append({"role": "user", "content": user_input})
response = client.responses.create(
model="gpt-5.6-terra",
instructions="Eres un asistente conciso.",
input=history
)
assistant_msg = response.output_text
history.append({"role": "assistant", "content": assistant_msg})
print(f"Asistente: {assistant_msg}")
print(f" (Tokens acumulados: {response.usage.input_tokens})")
# manual_conversation()
Supervivencia a un reinicio
Un diccionario en memoria desaparece en el primer redespliegue, arrastrando consigo todas las conversaciones activas. En producción, persiste los identificadores; el archivo JSON siguiente ilustra el principio, que puedes adaptar a tu base de datos o a Redis. Ten en cuenta que también registramos la marca de tiempo y el uso de tokens, dos datos utilizados para la expiración y el seguimiento de costes, respectivamente.
import json
from datetime import datetime
class PersistentSessionManager:
"""Sesiones persistentes con copia de seguridad."""
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
Por último, implementa la expiración. Sin limpieza, tu tabla de sesiones solo crecerá, y un usuario que vuelva tres semanas después retomaría una conversación que ya no recuerda. Veinticuatro horas es un punto de partida razonable, ajustable según tu caso de uso.
from datetime import datetime, timedelta
def clean_sessions(sessions: dict, max_age_hours: int = 24) -> dict:
"""Elimina sesiones caducadas."""
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} sesión(es) caducada(s) eliminada(s)")
return active
Para resumir estas elecciones: usa previous_response_id para conversaciones sencillas, es lo más eficiente; cambia a entrada estructurada cuando necesites modificar el historial; almacena response.id de forma fiable, en una base de datos y no en memoria; limpia las sesiones inactivas; y monitoriza los tokens acumulados, o la facturación te pasará factura.
Puntos clave
previous_response_idencadena respuestas automáticamente sin reenviar el historial- Cada respuesta tiene un
idúnico utilizable para el encadenamiento - Gestiona múltiples sesiones con un diccionario
user_id -> response_id - La entrada estructurada (lista de mensajes) ofrece más control sobre el historial
- Implementa persistencia y expiración de sesiones en producción