Ir al contenido principal
Español— Elegir un idioma
Menú

Estado de la conversación y gestión de sesiones

Lección 11 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Estado de la conversación y gestión de sesiones
  2. Encadenamiento con previous_response_id
  3. Ejecución de múltiples conversaciones
  4. Cuándo tomar el control del historial
  5. Supervivencia a un reinicio
  6. Puntos clave

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_id encadena 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