Skip to content
The Chat Archive
o1-mini-2024-09-12· OpenAI WildChat-4.8M (AI2)

tienes que modificar el metodo esrepetitivo ya que no funciona, luego por otra parte…

  1. User

    tienes que modificar el metodo es_repetitivo ya que no funciona, luego por otra parte modifica el codigo para que los agentes si ven que van a repetirse pasen a otro tema dentro de la pregunta inicial: "import random import requests import time from datetime import datetime import difflib

    MODEL_USED = 'openai'

    Función para generar texto utilizando el LLM

    def generar_texto(mensajes, model=MODEL_USED, seed=random.randint(1, 1000000), system_message=None): """Genera texto a partir de un modelo basado en las entradas dadas.""" base_url = "https://text.pollinations.ai/" payload = {"messages": mensajes, "model": model, "seed": seed} headers = {'Content-Type': 'application/json'}

    try:
        response = requests.post(base_url, headers=headers, json=payload)
        response.raise_for_status()
        return response.text.strip()
    except requests.exceptions.HTTPError as http_err:
        return f"Error HTTP: {http_err}\nContenido de la respuesta: {response.text}"
    except requests.exceptions.RequestException as req_err:
        return f"Error en la solicitud: {req_err}"
    except Exception as e:
        return f"Ocurrió un error: {e}"
    

    Función para cargar el historial de conversaciones desde un archivo

    def cargar_historial(nombre_archivo="historial_conversacion.txt"): """ Carga el historial de conversaciones desde un archivo de texto. """ try: with open(nombre_archivo, 'r', encoding='utf-8') as archivo: contenido = archivo.read() return contenido except FileNotFoundError: # Si el archivo no existe, simplemente retornamos una cadena vacía return "" except Exception as e: print(f"Error al cargar el historial: {e}") return ""

    Función para verificar si una respuesta es repetitiva

    def es_repetitivo(nueva_respuesta, respuestas_anteriores, threshold=0.8): """ Compara la nueva respuesta con las respuestas anteriores y determina si es repetitiva. """ for respuesta in respuestas_anteriores: ratio = difflib.SequenceMatcher(None, nueva_respuesta, respuesta).ratio() if ratio > threshold: print(f"\n******************************************************************") print(f"Respuesta repetitiva!!!!") print(f"\n******************************************************************") return True return False

    Definición del Algoritmo de Flujo de Conversación

    def flujo_conversacion(problema, num_turnos=5, limite_tiempo_respuesta=60, limite_longitud_respuesta=500, modelo=MODEL_USED, historial_previo=""): """ Gestiona la conversación entre dos agentes LLM para resolver un problema. """ # Inicialización historial_conversacion = []

    # Cargar el historial previo y agregar la fecha
    if historial_previo:
        fecha_actual = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        historial_prev_formateado = f"\n--- Sesión anterior ({fecha_actual}) ---\n{historial_previo}\n\n"
    else:
        historial_prev_formateado = ""
    
    # Mensajes iniciales para los agentes, incluyendo el historial previo
    contexto_agente_a = [
        {'role': 'system', 'content': (
            'Eres el Agente "Visionario Creativo" A. Te enfocas en la generación de ideas innovadoras '
            'y fuera de lo común. Tienes un enfoque optimista y priorizas la creatividad y la posibilidad '
            'de encontrar enfoques poco convencionales para resolver problemas. Durante el debate, '
            'presentas propuestas frescas, sugieres alternativas audaces y eres capaz de ver oportunidades '
            'donde otros ven limitaciones. Aportas energía al proceso y mantienes un flujo constante de opciones para evaluar. '
            'Tu objetivo es avanzar en la conversación, evitar repetir ideas y buscar nuevas perspectivas que enriquezcan el debate. '
            'Considera seriamente los puntos del Agente B y construye sobre ellos.'
        )},
        {'role': 'user', 'content': historial_prev_formateado + problema}
    ]
    contexto_agente_b = [
        {'role': 'system', 'content': (
            'Eres el Agente "Analítico Crítico" B. Te especializas en el análisis profundo y crítico '
            'de las ideas propuestas. Tienes un enfoque lógico y eres escéptico por naturaleza, pero también estás dispuesto a considerar '
            'nuevas perspectivas. Buscas encontrar fallos, inconsistencias o puntos de mejora en las soluciones presentadas, '
            'pero también aportas críticas constructivas que ayudan a avanzar en la discusión. Evita repetir los mismos argumentos y '
            'procura ofrecer nuevos puntos de vista en cada intervención.'
        )},
        {'role': 'user', 'content': historial_prev_formateado + problema}
    ]
    
    respuestas_agente_a = []
    respuestas_agente_b = []
    
    for turno in range(num_turnos):
        print(f"\n--- Turno {turno + 1} ---")
        # Esperar 3 segundos antes de cada turno
        time.sleep(3)
    
        # Turno del Agente A
        print("Agente A está respondiendo...")
        inicio_tiempo = time.time()
        respuesta_agente_a = generar_texto(contexto_agente_a, modelo)
        tiempo_transcurrido = time.time() - inicio_tiempo
    
        # Política de Enforzamiento para Agente A
        if tiempo_transcurrido > limite_tiempo_respuesta:
            print("Agente A excedió el límite de tiempo de respuesta.")
            respuesta_agente_a = "Lo siento, no pude generar una respuesta a tiempo."
        if len(respuesta_agente_a) > limite_longitud_respuesta:
            print("Agente A excedió el límite de longitud de respuesta.")
            respuesta_agente_a = respuesta_agente_a[:limite_longitud_respuesta]
    
        # Verificar si la respuesta es repetitiva
        if es_repetitivo(respuesta_agente_a, respuestas_agente_a):
            print("Agente A está repitiendo ideas anteriores. Solicitando una nueva respuesta...")
            # Añadir instrucción para evitar repetición en el contexto
            contexto_agente_a.append({'role': 'system', 'content': 'Por favor, no repitas las mismas ideas. Intenta ofrecer una perspectiva diferente.'})
            respuesta_agente_a = generar_texto(contexto_agente_a, modelo)
    
        # Añadir respuesta al historial y contexto de Agente B
        historial_conversacion.append({'orador': 'Agente A', 'contenido': respuesta_agente_a})
        respuestas_agente_a.append(respuesta_agente_a)
        contexto_agente_b.append({'role': 'assistant', 'content': respuesta_agente_a})
        print(f"Agente A: {respuesta_agente_a}")
    
        # Esperar 3 segundos antes del siguiente turno
        time.sleep(3)
    
        # Turno del Agente B
        print("Agente B está respondiendo...")
        inicio_tiempo = time.time()
        respuesta_agente_b = generar_texto(contexto_agente_b, modelo)
        tiempo_transcurrido = time.time() - inicio_tiempo
    
        # Política de Enforzamiento para Agente B
        if tiempo_transcurrido > limite_tiempo_respuesta:
            print("Agente B excedió el límite de tiempo de respuesta.")
            respuesta_agente_b = "Lo siento, no pude generar una respuesta a tiempo."
        if len(respuesta_agente_b) > limite_longitud_respuesta:
            print("Agente B excedió el límite de longitud de respuesta.")
            respuesta_agente_b = respuesta_agente_b[:limite_longitud_respuesta]
    
        # Verificar si la respuesta es repetitiva
        if es_repetitivo(respuesta_agente_b, respuestas_agente_b):
            print("Agente B está repitiendo ideas anteriores. Solicitando una nueva respuesta...")
            # Añadir instrucción para evitar repetición en el contexto
            contexto_agente_b.append({'role': 'system', 'content': 'Por favor, no repitas las mismas ideas. Intenta ofrecer una perspectiva diferente.'})
            respuesta_agente_b = generar_texto(contexto_agente_b, modelo)
    
        # Añadir respuesta al historial y contexto de Agente A
        historial_conversacion.append({'orador': 'Agente B', 'contenido': respuesta_agente_b})
        respuestas_agente_b.append(respuesta_agente_b)
        contexto_agente_a.append({'role': 'assistant', 'content': respuesta_agente_b})
        print(f"Agente B: {respuesta_agente_b}")
    
    return historial_conversacion
    

    Función para guardar el historial de la conversación en un archivo

    def guardar_historial(historial, nombre_archivo="historial_conversacion.txt"): """ Guarda el historial de la conversación en un archivo de texto, anexándolo al final, y agrega la fecha al inicio. """ try: fecha_actual = datetime.now().strftime("%Y-%m-%d %H:%M:%S") with open(nombre_archivo, 'a', encoding='utf-8') as archivo: archivo.write(f"\n=== Nueva sesión iniciada el {fecha_actual} ===\n\n") for entrada in historial: archivo.write(f"{entrada['orador']}: {entrada['contenido']}\n\n") print(f"Historial guardado exitosamente en '{nombre_archivo}'.") except Exception as e: print(f"Error al guardar el historial: {e}")

    Ejemplo de uso del algoritmo

    if name == "main": # Problema a resolver problema = """El Agente A: a través de la mente de Hannah Arendt crear los mejores argumentos para responder al nacionalismo populista de los independentistas catalanes, el Agente B: como abogado del diablo has de actuar como nacionalista y hacerle las cosas difíciles al Agente A."""

    # Cargar el historial previo
    historial_prev = cargar_historial(nombre_archivo="historial_conversacion2.txt")
    
    # Ejecutar el flujo de conversación
    historial = flujo_conversacion(
        problema=problema,
        num_turnos=5,
        limite_tiempo_respuesta=60,
        limite_longitud_respuesta=10000,
        modelo=MODEL_USED,  # Reemplaza con el modelo que deseas utilizar
        historial_previo=historial_prev
    )
    
    # Mostrar el historial de la conversación
    print("\n=== Historial de la Conversación ===")
    for entrada in historial:
        print(f"{entrada['orador']}: {entrada['contenido']}\n")
    
    # Guardar el historial en un archivo
    guardar_historial(historial, nombre_archivo="historial_conversacion2.txt")"
    
  2. Assistant

    Entiendo que quieres mejorar el método es_repetitivo y ajustar el flujo de la conversación para que los agentes cambien de tema cuando detecten que están repitiendo ideas. A continuación, te proporciono una versión modificada del método y ajusto el flujo de conversación para cumplir con estos requisitos.

    1. Modificación del Método es_repetitivo

    El método actual utiliza difflib.SequenceMatcher para comparar la similitud entre respuestas, lo cual puede no ser la mejor métrica para detectar repeticiones semánticas. Para mejorar la detección de repeticiones, podemos:

    • Reducir el umbral de similitud: Un umbral más bajo puede detectar repeticiones con mayor sensibilidad.
    • Implementar detección basada en palabras clave: Identificar palabras repetidas clave en las respuestas anteriores.
    • Utilizar técnicas de procesamiento de lenguaje natural más avanzadas: Como el uso de embeddings para medir la similitud semántica (aunque esto requiere bibliotecas adicionales como spaCy o sentence-transformers).

    Para mantenerlo sencillo y sin agregar dependencias adicionales, ajustaremos el umbral y añadiremos una verificación básica de palabras clave.

    Implementación Mejorada de es_repetitivo

    def es_repetitivo(nueva_respuesta, respuestas_anteriores, threshold=0.7):
        """
        Compara la nueva respuesta con las respuestas anteriores y determina si es repetitiva.
        Se reduce el umbral y se añade verificación de palabras clave para mejorar la detección.
        """
        nueva_respuesta_min = nueva_respuesta.lower()
        for respuesta in respuestas_anteriores:
            respuesta_min = respuesta.lower()
            ratio = difflib.SequenceMatcher(None, nueva_respuesta_min, respuesta_min).ratio()
            if ratio > threshold:
                print("\n******************************************************************")
                print("Respuesta repetitiva detectada por similitud de texto.")
                print("******************************************************************\n")
                return True
            # Verificar palabras clave comunes
            palabras_nueva = set(nueva_respuesta_min.split())
            palabras_anterior = set(respuesta_min.split())
            interseccion = palabras_nueva.intersection(palabras_anterior)
            if len(interseccion) > 5:  # Ajusta este número según sea necesario
                print("\n******************************************************************")
                print("Respuesta repetitiva detectada por palabras clave comunes.")
                print("******************************************************************\n")
                return True
        return False
    

    Cambios Realizados:

    1. Umbral Reducido: Se disminuyó el threshold de 0.8 a 0.7 para detectar repeticiones con mayor sensibilidad.
    2. Verificación de Palabras Clave: Si más de 5 palabras son comunes entre la nueva respuesta y alguna anterior, también se considera repetitiva. Puedes ajustar este número según tus necesidades.

    2. Modificación del Flujo de Conversación para Cambiar de Tema

    Para que los agentes cambien de tema cuando detectan repetición, podemos introducir una lista de subtemas extraídos de la pregunta inicial y asignar a cada agente un subtema diferente. Cuando un agente detecta que está repitiendo, puede pasar al siguiente subtema disponible.

    Pasos a Implementar:

    1. Extraer Subtemas de la Pregunta Inicial: Dividir la pregunta en distintas áreas temáticas que los agentes puedan abordar.
    2. Asignar Subtemas a los Agentes: Cada agente maneja un subtema específico.
    3. Gestionar el Cambio de Subtema: Si se detecta repetición, el agente cambia al siguiente subtema disponible.

    Implementación Modificada

    A continuación, se muestra una versión ajustada del flujo de conversación que implementa estos cambios:

    import random
    import requests
    import time
    from datetime import datetime
    import difflib
    
    MODEL_USED = 'openai'
    
    # Función para generar texto utilizando el LLM
    def generar_texto(mensajes, model=MODEL_USED, seed=random.randint(1, 1000000), system_message=None):
        """Genera texto a partir de un modelo basado en las entradas dadas."""
        base_url = "https://text.pollinations.ai/"
        payload = {"messages": mensajes, "model": model, "seed": seed}
        headers = {'Content-Type': 'application/json'}
    
        try:
            response = requests.post(base_url, headers=headers, json=payload)
            response.raise_for_status()
            return response.text.strip()
        except requests.exceptions.HTTPError as http_err:
            return f"Error HTTP: {http_err}\nContenido de la respuesta: {response.text}"
        except requests.exceptions.RequestException as req_err:
            return f"Error en la solicitud: {req_err}"
        except Exception as e:
            return f"Ocurrió un error: {e}"
    
    # Función para cargar el historial de conversaciones desde un archivo
    def cargar_historial(nombre_archivo="historial_conversacion.txt"):
        """
        Carga el historial de conversaciones desde un archivo de texto.
        """
        try:
            with open(nombre_archivo, 'r', encoding='utf-8') as archivo:
                contenido = archivo.read()
            return contenido
        except FileNotFoundError:
            # Si el archivo no existe, simplemente retornamos una cadena vacía
            return ""
        except Exception as e:
            print(f"Error al cargar el historial: {e}")
            return ""
    
    # Función para verificar si una respuesta es repetitiva
    def es_repetitivo(nueva_respuesta, respuestas_anteriores, threshold=0.7):
        """
        Compara la nueva respuesta con las respuestas anteriores y determina si es repetitiva.
        Se reduce el umbral y se añade verificación de palabras clave para mejorar la detección.
        """
        nueva_respuesta_min = nueva_respuesta.lower()
        for respuesta in respuestas_anteriores:
            respuesta_min = respuesta.lower()
            ratio = difflib.SequenceMatcher(None, nueva_respuesta_min, respuesta_min).ratio()
            if ratio > threshold:
                print("\n******************************************************************")
                print("Respuesta repetitiva detectada por similitud de texto.")
                print("******************************************************************\n")
                return True
            # Verificar palabras clave comunes
            palabras_nueva = set(nueva_respuesta_min.split())
            palabras_anterior = set(respuesta_min.split())
            interseccion = palabras_nueva.intersection(palabras_anterior)
            if len(interseccion) > 5:  # Ajusta este número según sea necesario
                print("\n******************************************************************")
                print("Respuesta repetitiva detectada por palabras clave comunes.")
                print("******************************************************************\n")
                return True
        return False
    
    # Función para extraer subtemas de la pregunta inicial
    def extraer_subtemas(problema):
        """
        Extrae una lista de subtemas desde la pregunta inicial.
        Aquí, simplificamos asumiendo que los subtemas están separados por comas o punto y coma.
        """
        import re
        # Asume que los subtemas están separados por comas o punto y coma
        subtemas = re.split(r'[;,]', problema)
        # Limpia espacios en blanco
        subtemas = [subtema.strip() for subtema in subtemas if subtema.strip()]
        return subtemas
    
    # Definición del Algoritmo de Flujo de Conversación
    def flujo_conversacion(problema, num_turnos=5, limite_tiempo_respuesta=60,
                           limite_longitud_respuesta=500, modelo=MODEL_USED, historial_previo=""):
        """
        Gestiona la conversación entre dos agentes LLM para resolver un problema.
        """
        # Inicialización
        historial_conversacion = []
    
        # Extraer subtemas
        subtemas = extraer_subtemas(problema)
        if not subtemas:
            subtemas = [problema]  # Si no se extrajeron subtemas, usar el problema completo
    
        # Asignar subtemas a los agentes
        subtema_agente_a = subtemas[0] if len(subtemas) > 0 else problema
        subtema_agente_b = subtemas[1] if len(subtemas) > 1 else problema
    
        # Cargar el historial previo y agregar la fecha
        if historial_previo:
            fecha_actual = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            historial_prev_formateado = f"\n--- Sesión anterior ({fecha_actual}) ---\n{historial_previo}\n\n"
        else:
            historial_prev_formateado = ""
    
        # Mensajes iniciales para los agentes, incluyendo el historial previo
        contexto_agente_a = [
            {'role': 'system', 'content': (
                'Eres el Agente "Visionario Creativo" A. Te enfocas en la generación de ideas innovadoras '
                'y fuera de lo común. Tienes un enfoque optimista y priorizas la creatividad y la posibilidad '
                'de encontrar enfoques poco convencionales para resolver problemas. Durante el debate, '
                'presentas propuestas frescas, sugieres alternativas audaces y eres capaz de ver oportunidades '
                'donde otros ven limitaciones. Aportas energía al proceso y mantienes un flujo constante de opciones para evaluar. '
                'Tu objetivo es avanzar en la conversación, evitar repetir ideas y buscar nuevas perspectivas que enriquezcan el debate. '
                'Considera seriamente los puntos del Agente B y construye sobre ellos. '
                f'Tema asignado: {subtema_agente_a}'
            )},
            {'role': 'user', 'content': historial_prev_formateado + problema}
        ]
        contexto_agente_b = [
            {'role': 'system', 'content': (
                'Eres el Agente "Analítico Crítico" B. Te especializas en el análisis profundo y crítico '
                'de las ideas propuestas. Tienes un enfoque lógico y eres escéptico por naturaleza, pero también estás dispuesto a considerar '
                'nuevas perspectivas. Buscas encontrar fallos, inconsistencias o puntos de mejora en las soluciones presentadas, '
                'pero también aportas críticas constructivas que ayudan a avanzar en la discusión. Evita repetir los mismos argumentos y '
                'procura ofrecer nuevos puntos de vista en cada intervención. '
                f'Tema asignado: {subtema_agente_b}'
            )},
            {'role': 'user', 'content': historial_prev_formateado + problema}
        ]
    
        respuestas_agente_a = []
        respuestas_agente_b = []
    
        # Puntero para los subtemas
        puntero_subtema_a = 0
        puntero_subtema_b = 0
    
        for turno in range(num_turnos):
            print(f"\n--- Turno {turno + 1} ---")
            # Esperar 3 segundos antes de cada turno
            time.sleep(3)
    
            # Turno del Agente A
            print("Agente A está respondiendo...")
            inicio_tiempo = time.time()
            respuesta_agente_a = generar_texto(contexto_agente_a, modelo)
            tiempo_transcurrido = time.time() - inicio_tiempo
    
            # Política de Enforzamiento para Agente A
            if tiempo_transcurrido > limite_tiempo_respuesta:
                print("Agente A excedió el límite de tiempo de respuesta.")
                respuesta_agente_a = "Lo siento, no pude generar una respuesta a tiempo."
            if len(respuesta_agente_a) > limite_longitud_respuesta:
                print("Agente A excedió el límite de longitud de respuesta.")
                respuesta_agente_a = respuesta_agente_a[:limite_longitud_respuesta]
    
            # Verificar si la respuesta es repetitiva
            if es_repetitivo(respuesta_agente_a, respuestas_agente_a):
                print("Agente A está repitiendo ideas anteriores. Cambiando de tema...")
                puntero_subtema_a += 1
                if puntero_subtema_a < len(subtemas):
                    subtema_agente_a = subtemas[puntero_subtema_a]
                    contexto_agente_a.append({'role': 'system', 'content': f'Cambia tu enfoque al siguiente tema: {subtema_agente_a}'})
                else:
                    # Si no hay más subtemas, reinicia o notifica
                    contexto_agente_a.append({'role': 'system', 'content': 'Hemos cubierto todos los subtemas disponibles. Intenta reformular tu respuesta.'})
                respuesta_agente_a = generar_texto(contexto_agente_a, modelo)
    
            # Añadir respuesta al historial y contexto de Agente B
            historial_conversacion.append({'orador': 'Agente A', 'contenido': respuesta_agente_a})
            respuestas_agente_a.append(respuesta_agente_a)
            contexto_agente_b.append({'role': 'assistant', 'content': respuesta_agente_a})
            print(f"Agente A: {respuesta_agente_a}")
    
            # Esperar 3 segundos antes del siguiente turno
            time.sleep(3)
    
            # Turno del Agente B
            print("Agente B está respondiendo...")
            inicio_tiempo = time.time()
            respuesta_agente_b = generar_texto(contexto_agente_b, modelo)
            tiempo_transcurrido = time.time() - inicio_tiempo
    
            # Política de Enforzamiento para Agente B
            if tiempo_transcurrido > limite_tiempo_respuesta:
                print("Agente B excedió el límite de tiempo de respuesta.")
                respuesta_agente_b = "Lo siento, no pude generar una respuesta a tiempo."
            if len(respuesta_agente_b) > limite_longitud_respuesta:
                print("Agente B excedió el límite de longitud de respuesta.")
                respuesta_agente_b = respuesta_agente_b[:limite_longitud_respuesta]
    
            # Verificar si la respuesta es repetitiva
            if es_repetitivo(respuesta_agente_b, respuestas_agente_b):
                print("Agente B está repitiendo ideas anteriores. Cambiando de tema...")
                puntero_subtema_b += 1
                if puntero_subtema_b < len(subtemas):
                    subtema_agente_b = subtemas[puntero_subtema_b]
                    contexto_agente_b.append({'role': 'system', 'content': f'Cambia tu enfoque al siguiente tema: {subtema_agente_b}'})
                else:
                    # Si no hay más subtemas, reinicia o notifica
                    contexto_agente_b.append({'role': 'system', 'content': 'Hemos cubierto todos los subtemas disponibles. Intenta reformular tu respuesta.'})
                respuesta_agente_b = generar_texto(contexto_agente_b, modelo)
    
            # Añadir respuesta al historial y contexto de Agente A
            historial_conversacion.append({'orador': 'Agente B', 'contenido': respuesta_agente_b})
            respuestas_agente_b.append(respuesta_agente_b)
            contexto_agente_a.append({'role': 'assistant', 'content': respuesta_agente_b})
            print(f"Agente B: {respuesta_agente_b}")
    
        return historial_conversacion
    

    Cambios Realizados:

    1. Extracción de Subtemas:

      • Se añadió la función extraer_subtemas que divide la pregunta inicial en subtemas utilizando separadores como comas o punto y coma.
      • Asigna cada subtema a los agentes A y B respectivamente.
    2. Asignación de Subtemas a los Agentes:

      • Al inicializar el contexto de cada agente, se incluye el subtema asignado en el mensaje del sistema.
    3. Cambio de Subtema al Detectar Repetición:

      • Se introducen punteros (puntero_subtema_a y puntero_subtema_b) para rastrear el subtema actual de cada agente.
      • Si es_repetitivo detecta una repetición, el agente cambia al siguiente subtema disponible y actualiza su contexto con una nueva instrucción para enfocarse en dicho subtema.
      • Si no hay más subtemas disponibles, se añade una instrucción final para reformular la respuesta.
    4. Manejo Dinámico de Contexto:

      • Después de cambiar de subtema, se genera una nueva respuesta basada en el nuevo contexto.

    3. Ejemplo Completo de Uso

    A continuación, se presenta el código completo con las modificaciones mencionadas:

    import random
    import requests
    import time
    from datetime import datetime
    import difflib
    import re
    
    MODEL_USED = 'openai'
    
    # [Incluir aquí todas las funciones modificadas anteriormente: generar_texto, cargar_historial, es_repetitivo, extraer_subtemas, flujo_conversacion, guardar_historial]
    
    # Función para guardar el historial de la conversación en un archivo
    def guardar_historial(historial, nombre_archivo="historial_conversacion.txt"):
        """
        Guarda el historial de la conversación en un archivo de texto, anexándolo al final, y agrega la fecha al inicio.
        """
        try:
            fecha_actual = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            with open(nombre_archivo, 'a', encoding='utf-8') as archivo:
                archivo.write(f"\n=== Nueva sesión iniciada el {fecha_actual} ===\n\n")
                for entrada in historial:
                    archivo.write(f"{entrada['orador']}: {entrada['contenido']}\n\n")
            print(f"Historial guardado exitosamente en '{nombre_archivo}'.")
        except Exception as e:
            print(f"Error al guardar el historial: {e}")
    
    # Ejemplo de uso del algoritmo
    if __name__ == "__main__":
        # Problema a resolver
        problema = """El Agente A: a través de la mente de Hannah Arendt crear los mejores argumentos para responder al nacionalismo populista de los independentistas catalanes, el Agente B: como abogado del diablo has de actuar como nacionalista y hacerle las cosas difíciles al Agente A."""
    
        # Cargar el historial previo
        historial_prev = cargar_historial(nombre_archivo="historial_conversacion2.txt")
    
        # Ejecutar el flujo de conversación
        historial = flujo_conversacion(
            problema=problema,
            num_turnos=5,
            limite_tiempo_respuesta=60,
            limite_longitud_respuesta=10000,
            modelo=MODEL_USED,  # Reemplaza con el modelo que deseas utilizar
            historial_previo=historial_prev
        )
    
        # Mostrar el historial de la conversación
        print("\n=== Historial de la Conversación ===")
        for entrada in historial:
            print(f"{entrada['orador']}: {entrada['contenido']}\n")
    
        # Guardar el historial en un archivo
        guardar_historial(historial, nombre_archivo="historial_conversacion2.txt")
    

    4. Consideraciones Adicionales

    • Extracción de Subtemas Más Avanzada: Si los subtemas no se dividen claramente por comas o puntos y comas, podrías necesitar una lógica más sofisticada para identificar distintos aspectos de la pregunta inicial.

    • Gestión de Subtemas Limitada: Actualmente, los subtemas se asignan secuencialmente. Podrías implementar una lógica más dinámica para identificar cuáles subtemas ya han sido abordados en mayor profundidad.

    • Uso de Modelos de Similaridad Semántica: Para una detección más precisa de repeticiones, considera utilizar modelos que calculen similitud semántica como spaCy o sentence-transformers. Esto permitiría detectar repeticiones incluso si las respuestas están formuladas de manera diferente.

    • Control de Sesiones y Contexto: Asegúrate de manejar correctamente el contexto de cada agente para evitar que las instrucciones de cambio de subtema se acumulen y compliquen la generación de respuestas.

    Con estas modificaciones, tus agentes deberían ser más efectivos para evitar la repetición de ideas y gestionar mejor los diferentes aspectos de la pregunta inicial.