Estado conversacional

Gestión de historial conversacional

La gestión del historial conversacional es fundamental para crear aplicaciones que mantengan coherencia a lo largo de múltiples intercambios con el usuario. A diferencia de las consultas individuales, las conversaciones requieren que el modelo tenga acceso al contexto previo para proporcionar respuestas relevantes y mantener la continuidad temática.

Esta gestión conversacional se puede hacer manualmente acumulando mensajes:

La API Responses de OpenAI simplifica significativamente este proceso mediante el uso del parámetro previous_response_id, que permite encadenar respuestas de forma automática sin necesidad de gestionar manualmente el historial completo de mensajes.

Implementación básica del historial

El mecanismo más directo para mantener el estado conversacional consiste en referenciar la respuesta anterior al crear una nueva consulta:

from openai import OpenAI

client = OpenAI()

# Primera interacción
response = client.responses.create(
    model="gpt-4.1-mini",
    input="Explícame qué es la programación funcional"
)

print("Asistente:", response.output_text)

# Segunda interacción con contexto
follow_up = client.responses.create(
    model="gpt-4.1-mini",
    previous_response_id=response.id,
    input="¿Podrías darme un ejemplo práctico en Python?"
)

print("Asistente:", follow_up.output_text)

En este ejemplo, la segunda consulta mantiene automáticamente el contexto de la primera, permitiendo que el modelo comprenda que "un ejemplo práctico" se refiere específicamente a programación funcional.

De este modo el código se simplifica:

Construcción de conversaciones extensas

Para conversaciones que involucran múltiples turnos, cada nueva respuesta debe referenciar la respuesta inmediatamente anterior:

class ConversationManager:
    def __init__(self, model="gpt-4.1-mini"):
        self.client = OpenAI()
        self.model = model
        self.last_response_id = None
    
    def send_message(self, message):
        """Envía un mensaje manteniendo el contexto conversacional"""
        if self.last_response_id:
            response = self.client.responses.create(
                model=self.model,
                previous_response_id=self.last_response_id,
                input=message
            )
        else:
            # Primera interacción
            response = self.client.responses.create(
                model=self.model,
                input=message
            )
        
        # Actualizar el ID para la siguiente interacción
        self.last_response_id = response.id
        return response.output_text

# Uso práctico
conversation = ConversationManager()

print(conversation.send_message("Hola, soy desarrollador Python"))
print(conversation.send_message("¿Qué patrones de diseño me recomiendas?"))
print(conversation.send_message("Explícame el patrón Observer con más detalle"))

Esta implementación garantiza que cada mensaje tenga acceso al historial completo de la conversación, manteniendo la coherencia temática y contextual.

Gestión de memoria en conversaciones largas

Las conversaciones extensas pueden alcanzar los límites de contexto del modelo. Para gestionar esta situación, es necesario implementar estrategias de optimización del historial:

class OptimizedConversation:
    def __init__(self, model="gpt-4.1-mini", max_context_length=8000):
        self.client = OpenAI()
        self.model = model
        self.max_context_length = max_context_length
        self.conversation_history = []
        self.last_response_id = None
    
    def estimate_tokens(self, text):
        """Estimación aproximada de tokens (4 caracteres ≈ 1 token)"""
        return len(text) // 4
    
    def truncate_history_if_needed(self, new_message):
        """Trunca el historial si excede el límite de contexto"""
        total_tokens = sum(
            self.estimate_tokens(msg) for msg in self.conversation_history
        ) + self.estimate_tokens(new_message)
        
        if total_tokens > self.max_context_length:
            # Mantener los mensajes más recientes
            while (total_tokens > self.max_context_length * 0.8 and 
                   len(self.conversation_history) > 2):
                removed = self.conversation_history.pop(0)
                total_tokens -= self.estimate_tokens(removed)
            
            # Reiniciar la conversación con contexto resumido
            self.last_response_id = None
            return True
        return False
    
    def send_message(self, message):
        """Envía mensaje con gestión automática de memoria"""
        context_reset = self.truncate_history_if_needed(message)
        
        if context_reset:
            # Crear resumen del contexto perdido
            context_summary = "Contexto previo: " + " | ".join(
                self.conversation_history[-3:]  # Últimos 3 mensajes
            )
            full_input = f"{context_summary}\n\nUsuario: {message}"
        else:
            full_input = message
        
        # Enviar mensaje
        if self.last_response_id and not context_reset:
            response = self.client.responses.create(
                model=self.model,
                previous_response_id=self.last_response_id,
                input=full_input
            )
        else:
            response = self.client.responses.create(
                model=self.model,
                input=full_input
            )
        
        # Actualizar historial
        self.conversation_history.append(f"Usuario: {message}")
        self.conversation_history.append(f"Asistente: {response.output_text}")
        self.last_response_id = response.id
        
        return response.output_text

Persistencia del historial conversacional

Para aplicaciones que requieren persistencia entre sesiones, es necesario almacenar y recuperar el historial conversacional:

import json
from datetime import datetime

class PersistentConversation:
    def __init__(self, conversation_id, storage_path="conversations/"):
        self.conversation_id = conversation_id
        self.storage_path = storage_path
        self.client = OpenAI()
        self.conversation_data = self.load_conversation()
    
    def load_conversation(self):
        """Carga una conversación existente o crea una nueva"""
        try:
            with open(f"{self.storage_path}{self.conversation_id}.json", 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            return {
                "id": self.conversation_id,
                "created_at": datetime.now().isoformat(),
                "last_response_id": None,
                "messages": []
            }
    
    def save_conversation(self):
        """Guarda el estado actual de la conversación"""
        with open(f"{self.storage_path}{self.conversation_id}.json", 'w') as f:
            json.dump(self.conversation_data, f, indent=2)
    
    def send_message(self, message):
        """Envía mensaje y persiste el estado"""
        if self.conversation_data["last_response_id"]:
            response = self.client.responses.create(
                model="gpt-4.1-mini",
                previous_response_id=self.conversation_data["last_response_id"],
                input=message
            )
        else:
            response = self.client.responses.create(
                model="gpt-4.1-mini",
                input=message
            )
        
        # Actualizar datos de conversación
        self.conversation_data["last_response_id"] = response.id
        self.conversation_data["messages"].extend([
            {"role": "user", "content": message, "timestamp": datetime.now().isoformat()},
            {"role": "assistant", "content": response.output_text, "timestamp": datetime.now().isoformat()}
        ])
        
        # Persistir cambios
        self.save_conversation()
        
        return response.output_text

# Uso con persistencia
conversation = PersistentConversation("user_123_session_1")
response = conversation.send_message("Continuemos donde lo dejamos ayer")

Mejores prácticas para el contexto conversacional

La gestión eficiente del historial conversacional requiere considerar varios aspectos técnicos y de experiencia de usuario:

Optimización del rendimiento: Evita enviar historiales excesivamente largos que incrementen la latencia y el coste de las consultas. Implementa estrategias de truncamiento inteligente que preserven la información más relevante.

Gestión de errores: Implementa mecanismos de recuperación cuando se pierda el contexto conversacional, permitiendo que la conversación continúe de forma natural:

def robust_send_message(self, message, max_retries=3):
    """Envío robusto con recuperación de errores"""
    for attempt in range(max_retries):
        try:
            if self.last_response_id:
                response = self.client.responses.create(
                    model="gpt-4.1-mini",
                    previous_response_id=self.last_response_id,
                    input=message
                )
            else:
                response = self.client.responses.create(
                    model="gpt-4.1-mini",
                    input=message
                )
            
            self.last_response_id = response.id
            return response.output_text
            
        except Exception as e:
            if "invalid previous_response_id" in str(e):
                # Reiniciar conversación si el ID es inválido
                self.last_response_id = None
                continue
            elif attempt == max_retries - 1:
                raise e

Segmentación temática: Para conversaciones que abarcan múltiples temas, considera implementar segmentación automática que detecte cambios de contexto y reinicie el historial cuando sea apropiado, manteniendo la relevancia de las respuestas.