ai-agents-for-beginners

Diseño Multi-Agente

(Haz clic en la imagen de arriba para ver el video de esta lección)

Metacognición en Agentes de IA

Introducción

¡Bienvenido a la lección sobre metacognición en agentes de IA! Este capítulo está diseñado para principiantes que sienten curiosidad sobre cómo los agentes de IA pueden pensar acerca de sus propios procesos de pensamiento. Al final de esta lección, comprenderás conceptos clave y estarás equipado con ejemplos prácticos para aplicar la metacognición en el diseño de agentes de IA.

Objetivos de Aprendizaje

Después de completar esta lección, podrás:

  1. Entender las implicaciones de los ciclos de razonamiento en las definiciones de agentes.
  2. Usar técnicas de planificación y evaluación para ayudar a agentes que se autocorrigen.
  3. Crear tus propios agentes capaces de manipular código para cumplir tareas.

Introducción a la Metacognición

La metacognición se refiere a los procesos cognitivos de orden superior que implican pensar sobre el propio pensamiento. Para los agentes de IA, esto significa poder evaluar y ajustar sus acciones basándose en la autoconciencia y experiencias pasadas. La metacognición, o “pensar sobre el pensamiento,” es un concepto importante en el desarrollo de sistemas de IA con agencia. Involucra a sistemas de IA conscientes de sus propios procesos internos y capaces de monitorizar, regular y adaptar su comportamiento en consecuencia. Algo similar a cuando nosotros analizamos el ambiente o contemplamos un problema. Esta autoconciencia puede ayudar a los sistemas de IA a tomar mejores decisiones, identificar errores y mejorar su rendimiento con el tiempo—lo que vuelve a conectar con la prueba de Turing y el debate sobre si la IA dominará el mundo.

En el contexto de sistemas de IA con agencia, la metacognición puede ayudar a resolver varios retos, tales como:

¿Qué es la Metacognición?

La metacognición, o “pensar sobre el pensamiento,” es un proceso cognitivo de orden superior que implica autoconciencia y autorregulación de los propios procesos cognitivos. En el ámbito de la IA, la metacognición capacita a los agentes para evaluar y adaptar sus estrategias y acciones, conduciendo a una mejor capacidad para resolver problemas y tomar decisiones. Al comprender la metacognición, puedes diseñar agentes de IA que no solo sean más inteligentes sino también más adaptables y eficientes. En una verdadera metacognición, verías a la IA razonando explícitamente sobre su propio razonamiento.

Ejemplo: “Prioricé vuelos más baratos porque… podría estar perdiéndome los vuelos directos, así que déjame volver a revisar.”
Llevar un registro de cómo o por qué eligió cierta ruta.

Importancia de la Metacognición en Agentes de IA

La metacognición juega un papel crucial en el diseño de agentes de IA por varias razones:

Importancia de la Metacognición

Componentes de un Agente de IA

Antes de profundizar en los procesos metacognitivos, es esencial entender los componentes básicos de un agente de IA. Un agente de IA típicamente consiste en:

Estos componentes trabajan juntos para crear una “unidad de experticia” que pueda realizar tareas específicas.

Ejemplo:
Considera un agente de viajes, servicios de agentes que no solo planean tus vacaciones sino que también ajustan su ruta basándose en datos en tiempo real y experiencias anteriores del cliente.

Ejemplo: Metacognición en un Servicio de Agente de Viajes

Imagina que estás diseñando un servicio de agente de viajes impulsado por IA. Este agente, “Agente de Viajes,” asiste a los usuarios a planear sus vacaciones. Para incorporar la metacognición, Agente de Viajes necesita evaluar y ajustar sus acciones basándose en la autoconciencia y experiencias previas. Así es como la metacognición podría jugar un papel:

Tarea Actual

La tarea actual es ayudar a un usuario a planificar un viaje a París.

Pasos para Completar la Tarea

  1. Reunir Preferencias del Usuario: Preguntar al usuario sobre sus fechas de viaje, presupuesto, intereses (ej.: museos, gastronomía, compras), y cualquier requerimiento específico.
  2. Obtener Información: Buscar opciones de vuelos, alojamiento, atracciones y restaurantes que coincidan con las preferencias del usuario.
  3. Generar Recomendaciones: Proporcionar un itinerario personalizado con detalles de vuelo, reservaciones de hotel, y actividades sugeridas.
  4. Ajustar Según Retroalimentación: Preguntar al usuario su opinión sobre las recomendaciones y hacer los ajustes necesarios.

Recursos Requeridos

Experiencia y Auto-reflexión

Agente de Viajes usa la metacognición para evaluar su performance y aprender de experiencias pasadas. Por ejemplo:

  1. Analizar Retroalimentación del Usuario: Agente de Viajes revisa la retroalimentación del usuario para determinar qué recomendaciones fueron bien recibidas y cuáles no. Ajusta sus sugerencias futuras en consecuencia.
  2. Adaptabilidad: Si un usuario mencionó previamente que no le gustan lugares concurridos, Agente de Viajes evitará recomendar lugares turísticos populares en horas pico.
  3. Corrección de Errores: Si Agente de Viajes cometió un error en una reserva pasada, como sugerir un hotel completo, aprende a verificar disponibilidad más rigurosamente antes de hacer recomendaciones.

Ejemplo Práctico para Desarrolladores

Aquí hay un ejemplo simplificado de cómo se podría ver el código de Agente de Viajes incorporando metacognición:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        # Buscar vuelos, hoteles y atracciones según preferencias
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        # Analizar comentarios y ajustar recomendaciones futuras
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Ejemplo de uso
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

Por qué Importa la Metacognición

Al incorporar la metacognición, Agente de Viajes puede proporcionar recomendaciones de viaje más personalizadas y precisas, mejorando la experiencia general del usuario.

2. Planificación en Agentes

La planificación es un componente crítico del comportamiento de un agente de IA. Implica delinear los pasos necesarios para alcanzar un objetivo, considerando el estado actual, recursos y posibles obstáculos.

Elementos de la Planificación

Ejemplo:
Aquí están los pasos que Agente de Viajes necesita seguir para asistir a un usuario en la planificación efectiva de su viaje:

Pasos para Agente de Viajes

  1. Reunir Preferencias del Usuario
    • Preguntar al usuario detalles sobre sus fechas de viaje, presupuesto, intereses y requerimientos específicos.
    • Ejemplos: “¿Cuándo planeas viajar?” “¿Cuál es tu rango de presupuesto?” “¿Qué actividades disfrutas en vacaciones?”
  2. Obtener Información
    • Buscar opciones de viaje relevantes basadas en las preferencias del usuario.
    • Vuelos: Buscar vuelos disponibles dentro del presupuesto y fechas preferidas por el usuario.
    • Alojamiento: Encontrar hoteles o propiedades de alquiler que coincidan con las preferencias de ubicación, precio y servicios.
    • Atracciones y Restaurantes: Identificar atracciones populares, actividades y opciones gastronómicas alineadas con los intereses del usuario.
  3. Generar Recomendaciones
    • Compilar la información obtenida en un itinerario personalizado.
    • Proporcionar detalles como opciones de vuelos, reservaciones de hotel y actividades sugeridas, asegurándose de adaptar las recomendaciones a las preferencias del usuario.
  4. Presentar Itinerario al Usuario
    • Compartir el itinerario propuesto con el usuario para su revisión.
    • Ejemplo: “Aquí tienes un itinerario sugerido para tu viaje a París. Incluye detalles de vuelo, reservas de hotel y una lista de actividades y restaurantes recomendados. ¡Cuéntame qué te parece!”
  5. Recolectar Retroalimentación
    • Preguntar al usuario por su opinión sobre el itinerario propuesto.
    • Ejemplos: “¿Te gustan las opciones de vuelo?” “¿El hotel es adecuado para tus necesidades?” “¿Hay actividades que te gustaría agregar o eliminar?”
  6. Ajustar Según Retroalimentación
    • Modificar el itinerario basado en los comentarios del usuario.
    • Realizar cambios necesarios en recomendaciones de vuelos, alojamiento y actividades para ajustarlas mejor a sus preferencias.
  7. Confirmación Final
    • Presentar el itinerario actualizado al usuario para confirmación final.
    • Ejemplo: “He hecho los ajustes basados en tus comentarios. Aquí está el itinerario actualizado. ¿Está todo bien para ti?”
  8. Reservar y Confirmar Reservas
    • Una vez que el usuario aprueba el itinerario, proceder a reservar vuelos, alojamiento y cualquier actividad pre-planificada.
    • Enviar detalles de confirmación al usuario.
  9. Proporcionar Soporte Continuo
    • Estar disponible para asistir al usuario con cualquier cambio o solicitud adicional antes y durante su viaje.
    • Ejemplo: “Si necesitas más ayuda durante tu viaje, no dudes en contactarme en cualquier momento.”

Ejemplo de Interacción

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Ejemplo de uso dentro de una solicitud de reserva
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

3. Sistema Correctivo RAG

Primero, comencemos por entender la diferencia entre la Herramienta RAG y la Carga de Contexto Preemptiva

RAG vs Carga de Contexto

Generación Aumentada por Recuperación (RAG)

RAG combina un sistema de recuperación con un modelo generativo. Cuando se hace una consulta, el sistema de recuperación trae documentos o datos relevantes desde una fuente externa, y esta información recuperada se usa para aumentar la entrada al modelo generativo. Esto ayuda al modelo a generar respuestas más precisas y contextualmente relevantes.

En un sistema RAG, el agente recupera información relevante de una base de conocimiento y la usa para generar respuestas o acciones apropiadas.

Enfoque Correctivo RAG

El enfoque Correctivo RAG se centra en usar técnicas RAG para corregir errores y mejorar la precisión de los agentes de IA. Esto implica:

  1. Técnica de Prompting: Usar indicaciones específicas para guiar al agente en la recuperación de información relevante.
  2. Herramienta: Implementar algoritmos y mecanismos que permitan al agente evaluar la relevancia de la información recuperada y generar respuestas precisas.
  3. Evaluación: Evaluar continuamente el desempeño del agente y realizar ajustes para mejorar su precisión y eficiencia.

Ejemplo: Corrective RAG en un Agente de Búsqueda

Considera un agente de búsqueda que recupera información de la web para responder consultas del usuario. El enfoque Corrective RAG podría incluir:

  1. Técnica de Prompting: Formular consultas de búsqueda basadas en la entrada del usuario.
  2. Herramienta: Usar procesamiento de lenguaje natural y algoritmos de aprendizaje automático para clasificar y filtrar resultados de búsqueda.
  3. Evaluación: Analizar la retroalimentación del usuario para identificar y corregir imprecisiones en la información recuperada.

Corrective RAG en Agente de Viajes

Corrective RAG (Generación Aumentada por Recuperación) mejora la habilidad de una IA para recuperar y generar información mientras corrige cualquier inexactitud. Veamos cómo Agente de Viajes puede usar el enfoque Corrective RAG para ofrecer recomendaciones de viaje más precisas y relevantes.

Esto implica:

Pasos para Implementar Corrective RAG en Agente de Viajes

  1. Interacción Inicial con el Usuario
    • Agente de Viajes recopila preferencias iniciales del usuario, como destino, fechas de viaje, presupuesto e intereses.

    • Ejemplo:

      preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
  2. Recuperación de Información
    • Agente de Viajes recupera información sobre vuelos, alojamientos, atracciones y restaurantes basados en las preferencias del usuario.

    • Ejemplo:

      flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
  3. Generación de Recomendaciones Iniciales
    • Agente de Viajes usa la información recuperada para generar un itinerario personalizado.

    • Ejemplo:

      itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
  4. Recolectar Retroalimentación del Usuario
    • Agente de Viajes solicita al usuario comentarios sobre las recomendaciones iniciales.

    • Ejemplo:

      feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
  5. Proceso Correctivo RAG
    • Técnica de Prompting: Agente de Viajes formula nuevas consultas de búsqueda basadas en la retroalimentación del usuario.

      • Ejemplo:

        if "disliked" in feedback:
    preferences["avoid"] = feedback["disliked"]
    • Herramienta: Agente de Viajes utiliza algoritmos para clasificar y filtrar nuevos resultados de búsqueda, enfatizando la relevancia basada en la retroalimentación del usuario.

      • Ejemplo:

        new_attractions = search_attractions(preferences)
new_itinerary = create_itinerary(flights, hotels, new_attractions)
print("Updated Itinerary:", new_itinerary)
    • Evaluación: Agente de Viajes evalúa continuamente la relevancia y precisión de sus recomendaciones analizando la retroalimentación del usuario y haciendo los ajustes necesarios.

      • Ejemplo:

        def adjust_preferences(preferences, feedback):
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

preferences = adjust_preferences(preferences, feedback)

Ejemplo Práctico

Aquí hay un ejemplo simplificado en código Python que incorpora el enfoque Corrective RAG en Agente de Viajes:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)
        new_itinerary = self.generate_recommendations()
        return new_itinerary

# Ejemplo de uso
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Updated Itinerary:", new_itinerary)

Carga de Contexto Preemptiva

La carga contextual preventiva implica cargar información relevante o de fondo en el modelo antes de procesar una consulta. Esto significa que el modelo tiene acceso a esta información desde el inicio, lo que puede ayudarle a generar respuestas más informadas sin necesitar recuperar datos adicionales durante el proceso.

Aquí hay un ejemplo simplificado de cómo podría verse una carga contextual preventiva para una aplicación de agente de viajes en Python:

class TravelAgent:
    def __init__(self):
        # Pre-cargar destinos populares y su información
        self.context = {
            "Paris": {"country": "France", "currency": "Euro", "language": "French", "attractions": ["Eiffel Tower", "Louvre Museum"]},
            "Tokyo": {"country": "Japan", "currency": "Yen", "language": "Japanese", "attractions": ["Tokyo Tower", "Shibuya Crossing"]},
            "New York": {"country": "USA", "currency": "Dollar", "language": "English", "attractions": ["Statue of Liberty", "Times Square"]},
            "Sydney": {"country": "Australia", "currency": "Dollar", "language": "English", "attractions": ["Sydney Opera House", "Bondi Beach"]}
        }

    def get_destination_info(self, destination):
        # Obtener información del destino desde el contexto pre-cargado
        info = self.context.get(destination)
        if info:
            return f"{destination}:\nCountry: {info['country']}\nCurrency: {info['currency']}\nLanguage: {info['language']}\nAttractions: {', '.join(info['attractions'])}"
        else:
            return f"Sorry, we don't have information on {destination}."

# Ejemplo de uso
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

Explicación

  1. Inicialización (método __init__): La clase TravelAgent precarga un diccionario que contiene información sobre destinos populares como París, Tokio, Nueva York y Sídney. Este diccionario incluye detalles como el país, moneda, idioma y principales atracciones de cada destino.

  2. Recuperando Información (método get_destination_info): Cuando un usuario consulta sobre un destino específico, el método get_destination_info obtiene la información relevante del diccionario de contexto precargado.

Al precargar el contexto, la aplicación del agente de viajes puede responder rápidamente a las consultas de los usuarios sin tener que recuperar esta información de una fuente externa en tiempo real. Esto hace que la aplicación sea más eficiente y receptiva.

Inicializando el Plan con un Objetivo Antes de Iterar

Inicializar un plan con un objetivo implica comenzar con un objetivo claro o resultado deseado en mente. Al definir este objetivo desde el principio, el modelo puede usarlo como principio guía durante todo el proceso iterativo. Esto ayuda a garantizar que cada iteración se acerque a lograr el resultado deseado, haciendo el proceso más eficiente y enfocado.

Aquí tienes un ejemplo de cómo podrías inicializar un plan de viaje con un objetivo antes de iterar para un agente de viajes en Python:

Escenario

Un agente de viajes quiere planificar unas vacaciones personalizadas para un cliente. El objetivo es crear un itinerario de viaje que maximice la satisfacción del cliente basándose en sus preferencias y presupuesto.

Pasos

  1. Definir las preferencias y el presupuesto del cliente.
  2. Inicializar el plan inicial basado en estas preferencias.
  3. Iterar para refinar el plan, optimizando para la satisfacción del cliente.

Código en Python

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def bootstrap_plan(self, preferences, budget):
        plan = []
        total_cost = 0

        for destination in self.destinations:
            if total_cost + destination['cost'] <= budget and self.match_preferences(destination, preferences):
                plan.append(destination)
                total_cost += destination['cost']

        return plan

    def match_preferences(self, destination, preferences):
        for key, value in preferences.items():
            if destination.get(key) != value:
                return False
        return True

    def iterate_plan(self, plan, preferences, budget):
        for i in range(len(plan)):
            for destination in self.destinations:
                if destination not in plan and self.match_preferences(destination, preferences) and self.calculate_cost(plan, destination) <= budget:
                    plan[i] = destination
                    break
        return plan

    def calculate_cost(self, plan, new_destination):
        return sum(destination['cost'] for destination in plan) + new_destination['cost']

# Ejemplo de uso
destinations = [
    {"name": "Paris", "cost": 1000, "activity": "sightseeing"},
    {"name": "Tokyo", "cost": 1200, "activity": "shopping"},
    {"name": "New York", "cost": 900, "activity": "sightseeing"},
    {"name": "Sydney", "cost": 1100, "activity": "beach"},
]

preferences = {"activity": "sightseeing"}
budget = 2000

travel_agent = TravelAgent(destinations)
initial_plan = travel_agent.bootstrap_plan(preferences, budget)
print("Initial Plan:", initial_plan)

refined_plan = travel_agent.iterate_plan(initial_plan, preferences, budget)
print("Refined Plan:", refined_plan)

Explicación del Código

  1. Inicialización (método __init__): La clase TravelAgent se inicializa con una lista de destinos potenciales, cada uno con atributos como nombre, costo y tipo de actividad.

  2. Inicializando el Plan (método bootstrap_plan): Este método crea un plan de viaje inicial basado en las preferencias y presupuesto del cliente. Itera por la lista de destinos y los añade al plan si coinciden con las preferencias del cliente y se ajustan al presupuesto.

  3. Coincidencia de Preferencias (método match_preferences): Este método verifica si un destino coincide con las preferencias del cliente.

  4. Iterando el Plan (método iterate_plan): Este método refina el plan inicial tratando de reemplazar cada destino del plan por una mejor opción, considerando las preferencias y limitaciones presupuestarias del cliente.

  5. Cálculo del Costo (método calculate_cost): Este método calcula el costo total del plan actual, incluyendo un posible nuevo destino.

Ejemplo de Uso

Al inicializar el plan con un objetivo claro (por ejemplo, maximizar la satisfacción del cliente) e iterar para refinarlo, el agente de viajes puede crear un itinerario personalizado y optimizado para el cliente. Este enfoque asegura que el plan esté alineado desde el principio con las preferencias y presupuesto del cliente y mejore en cada iteración.

Aprovechando los LLM para Reordenar y Puntuar

Los Modelos de Lenguaje Grande (LLMs) pueden usarse para reordenar y puntuar evaluando la relevancia y calidad de documentos recuperados o respuestas generadas. Así es como funciona:

Recuperación: El paso inicial recupera un conjunto de documentos o respuestas candidatas basado en la consulta.

Reordenamiento: El LLM evalúa estos candidatos y los reordena según su relevancia y calidad. Este paso asegura que la información más relevante y de mayor calidad se presente primero.

Puntuación: El LLM asigna puntajes a cada candidato, reflejando su relevancia y calidad. Esto ayuda a seleccionar la mejor respuesta o documento para el usuario.

Al aprovechar los LLMs para el reordenamiento y puntuación, el sistema puede ofrecer información más precisa y relevante contextualmente, mejorando la experiencia general del usuario.

Aquí tienes un ejemplo de cómo un agente de viajes podría usar un Modelo de Lenguaje Grande (LLM) para reordenar y puntuar destinos de viaje basándose en las preferencias del usuario en Python:

Escenario - Viajes Basados en Preferencias

Un agente de viajes quiere recomendar los mejores destinos de viaje a un cliente según sus preferencias. El LLM ayudará a reordenar y puntuar los destinos para asegurar que se presenten las opciones más relevantes.

Pasos:

  1. Recopilar las preferencias del usuario.
  2. Recuperar una lista de destinos potenciales.
  3. Usar el LLM para reordenar y puntuar los destinos basado en las preferencias del usuario.

Aquí te mostramos cómo actualizar el ejemplo anterior para usar Azure OpenAI Services:

Requisitos

  1. Necesitas una suscripción a Azure.
  2. Crear un recurso Azure OpenAI y obtener tu clave API.

Código de ejemplo en Python

import requests
import json

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def get_recommendations(self, preferences, api_key, endpoint):
        # Generar un prompt para Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # Definir encabezados y carga útil para la solicitud
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # Llamar a la API de Azure OpenAI para obtener los destinos reordenados y puntuados
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # Extraer y devolver las recomendaciones
        recommendations = response_data['choices'][0]['text'].strip().split('\n')
        return recommendations

    def generate_prompt(self, preferences):
        prompt = "Here are the travel destinations ranked and scored based on the following user preferences:\n"
        for key, value in preferences.items():
            prompt += f"{key}: {value}\n"
        prompt += "\nDestinations:\n"
        for destination in self.destinations:
            prompt += f"- {destination['name']}: {destination['description']}\n"
        return prompt

# Ejemplo de uso
destinations = [
    {"name": "Paris", "description": "City of lights, known for its art, fashion, and culture."},
    {"name": "Tokyo", "description": "Vibrant city, famous for its modernity and traditional temples."},
    {"name": "New York", "description": "The city that never sleeps, with iconic landmarks and diverse culture."},
    {"name": "Sydney", "description": "Beautiful harbour city, known for its opera house and stunning beaches."},
]

preferences = {"activity": "sightseeing", "culture": "diverse"}
api_key = 'your_azure_openai_api_key'
endpoint = 'https://your-endpoint.com/openai/deployments/your-deployment-name/completions?api-version=2022-12-01'

travel_agent = TravelAgent(destinations)
recommendations = travel_agent.get_recommendations(preferences, api_key, endpoint)
print("Recommended Destinations:")
for rec in recommendations:
    print(rec)

Explicación del Código - Preference Booker

  1. Inicialización: La clase TravelAgent se inicializa con una lista de destinos potenciales, cada uno con atributos como nombre y descripción.

  2. Obteniendo Recomendaciones (método get_recommendations): Este método genera un prompt para el servicio Azure OpenAI basado en las preferencias del usuario y hace una petición HTTP POST a la API Azure OpenAI para obtener destinos reordenados y puntuados.

  3. Generando el Prompt (método generate_prompt): Este método construye un prompt para Azure OpenAI, incluyendo las preferencias del usuario y la lista de destinos. El prompt guía al modelo para reordenar y puntuar los destinos según las preferencias proporcionadas.

  4. Llamada a la API: Se utiliza la biblioteca requests para hacer una petición HTTP POST al endpoint de la API Azure OpenAI. La respuesta contiene los destinos reordenados y puntuados.

  5. Ejemplo de Uso: El agente de viajes recopila las preferencias del usuario (por ejemplo, interés en turismo y cultura diversa) y usa el servicio Azure OpenAI para obtener recomendaciones reordenadas y puntuadas.

Asegúrate de reemplazar your_azure_openai_api_key con tu clave API real de Azure OpenAI y https://your-endpoint.com/... con la URL real del endpoint de tu despliegue de Azure OpenAI.

Al aprovechar el LLM para reordenar y puntuar, el agente de viajes puede ofrecer recomendaciones de viaje más personalizadas y relevantes a los clientes, mejorando su experiencia general.

RAG: Técnica de Prompting vs Herramienta

La Generación Aumentada por Recuperación (Retrieval-Augmented Generation, RAG) puede ser tanto una técnica de prompting como una herramienta en el desarrollo de agentes de IA. Entender la diferencia entre ambas te puede ayudar a aprovechar RAG de manera más efectiva en tus proyectos.

RAG como Técnica de Prompting

¿Qué es?

Cómo funciona:

  1. Formular Prompts: Crear prompts o consultas bien estructuradas basadas en la tarea o input del usuario.
  2. Recuperar Información: Usar los prompts para buscar datos relevantes en una base de conocimiento o conjunto de datos preexistente.
  3. Generar Respuesta: Combinar la información recuperada con modelos generativos para producir una respuesta completa y coherente.

Ejemplo en Agente de Viajes:

RAG como Herramienta

¿Qué es?

Cómo funciona:

  1. Integración: Insertar RAG dentro de la arquitectura del agente de IA, permitiendo que maneje automáticamente las tareas de recuperación y generación.
  2. Automatización: La herramienta gestiona todo el proceso, desde recibir la entrada del usuario hasta generar la respuesta final, sin requerir prompts explícitos en cada paso.
  3. Eficiencia: Mejora el rendimiento del agente al agilizar la recuperación y generación, permitiendo respuestas más rápidas y precisas.

Ejemplo en Agente de Viajes:

Comparación

Aspecto Técnica de Prompting Herramienta
Manual vs Automático Formulación manual de prompts para cada consulta. Proceso automatizado para recuperación y generación.
Control Ofrece más control sobre el proceso de recuperación. Simplifica y automatiza recuperación y generación.
Flexibilidad Permite prompts personalizados según necesidades específicas. Más eficiente para implementaciones a gran escala.
Complejidad Requiere crear y ajustar prompts. Más fácil de integrar en la arquitectura de un agente AI.

Ejemplos Prácticos

Ejemplo de Técnica de Prompting:

def search_museums_in_paris():
    prompt = "Find top museums in Paris"
    search_results = search_web(prompt)
    return search_results

museums = search_museums_in_paris()
print("Top Museums in Paris:", museums)

Ejemplo de Herramienta:

class Travel_Agent:
    def __init__(self):
        self.rag_tool = RAGTool()

    def get_museums_in_paris(self):
        user_input = "I want to visit museums in Paris."
        response = self.rag_tool.retrieve_and_generate(user_input)
        return response

travel_agent = Travel_Agent()
museums = travel_agent.get_museums_in_paris()
print("Top Museums in Paris:", museums)

Evaluando la Relevancia

Evaluar la relevancia es un aspecto crucial del desempeño de un agente de IA. Asegura que la información recuperada y generada por el agente sea adecuada, precisa y útil para el usuario. Exploremos cómo evaluar la relevancia en agentes de IA, incluyendo ejemplos y técnicas prácticas.

Conceptos Clave en la Evaluación de Relevancia

  1. Conciencia del Contexto:
    • El agente debe entender el contexto de la consulta del usuario para recuperar y generar información relevante.
    • Ejemplo: Si un usuario pide “mejores restaurantes en París”, el agente debe considerar las preferencias del usuario, como tipo de cocina y presupuesto.
  2. Precisión:
    • La información proporcionada por el agente debe ser correcta y actualizada.
    • Ejemplo: Recomendar restaurantes actualmente abiertos con buenas reseñas en vez de opciones antiguas o cerradas.
  3. Intención del Usuario:
    • El agente debe inferir la intención detrás de la consulta para ofrecer la información más relevante.
    • Ejemplo: Si un usuario pregunta por “hoteles económicos,” el agente debe priorizar opciones asequibles.
  4. Bucle de Retroalimentación:
    • Recoger y analizar feedback constante de los usuarios ayuda a mejorar el proceso de evaluación de relevancia.
    • Ejemplo: Incorporar las calificaciones y opiniones de usuarios sobre recomendaciones previas para mejorar las respuestas futuras.

Técnicas Prácticas para Evaluar la Relevancia

  1. Puntuación de Relevancia:
    • Asignar una puntuación de relevancia a cada ítem recuperado según qué tan bien coincide con la consulta y preferencias del usuario.

    • Ejemplo:

      def relevance_score(item, query):
    score = 0
    if item['category'] in query['interests']:
        score += 1
    if item['price'] <= query['budget']:
        score += 1
    if item['location'] == query['destination']:
        score += 1
    return score
  2. Filtrado y Ordenamiento:
    • Filtrar ítems irrelevantes y ordenar los restantes según sus puntuaciones de relevancia.

    • Ejemplo:

      def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # Devuelve los 10 elementos más relevantes
  3. Procesamiento de Lenguaje Natural (NLP):
    • Usar técnicas NLP para entender la consulta del usuario y recuperar información relevante.

    • Ejemplo:

      def process_query(query):
    # Utilice PLN para extraer información clave de la consulta del usuario
    processed_query = nlp(query)
    return processed_query
  4. Integración de Retroalimentación del Usuario:
    • Recoger feedback sobre las recomendaciones dadas y usarlo para ajustar las evaluaciones de relevancia futuras.

    • Ejemplo:

      def adjust_based_on_feedback(feedback, items):
    for item in items:
        if item['name'] in feedback['liked']:
            item['relevance'] += 1
        if item['name'] in feedback['disliked']:
            item['relevance'] -= 1
    return items

Ejemplo: Evaluando la Relevancia en Agente de Viajes

Aquí tienes un ejemplo práctico de cómo Travel Agent puede evaluar la relevancia de recomendaciones de viaje:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        ranked_hotels = self.filter_and_rank(hotels, self.user_preferences)
        itinerary = create_itinerary(flights, ranked_hotels, attractions)
        return itinerary

    def filter_and_rank(self, items, query):
        ranked_items = sorted(items, key=lambda item: self.relevance_score(item, query), reverse=True)
        return ranked_items[:10]  # Devolver los 10 elementos más relevantes

    def relevance_score(self, item, query):
        score = 0
        if item['category'] in query['interests']:
            score += 1
        if item['price'] <= query['budget']:
            score += 1
        if item['location'] == query['destination']:
            score += 1
        return score

    def adjust_based_on_feedback(self, feedback, items):
        for item in items:
            if item['name'] in feedback['liked']:
                item['relevance'] += 1
            if item['name'] in feedback['disliked']:
                item['relevance'] -= 1
        return items

# Ejemplo de uso
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_items = travel_agent.adjust_based_on_feedback(feedback, itinerary['hotels'])
print("Updated Itinerary with Feedback:", updated_items)

Búsqueda con Intención

Buscar con intención implica comprender e interpretar el propósito o meta subyacente detrás de la consulta de un usuario para recuperar y generar la información más relevante y útil. Este enfoque va más allá de simplemente coincidir palabras clave y se centra en captar las necesidades y contexto reales del usuario.

Conceptos Clave en Búsqueda con Intención

  1. Comprender la Intención del Usuario:
    • La intención del usuario puede clasificarse en tres tipos principales: informacional, de navegación y transaccional.
      • Intención Informacional: El usuario busca información sobre un tema (por ejemplo, “¿Cuáles son los mejores museos en París?”).
      • Intención de Navegación: El usuario quiere ir a un sitio o página específica (por ejemplo, “sitio oficial del Museo del Louvre”).
      • Intención Transaccional: El usuario desea realizar una acción, como reservar un vuelo o hacer una compra (por ejemplo, “Reservar un vuelo a París”).
  2. Conciencia del Contexto:
    • Analizar el contexto de la consulta ayuda a identificar correctamente la intención. Esto incluye considerar interacciones previas, preferencias del usuario y detalles específicos de la consulta.
  3. Procesamiento de Lenguaje Natural (NLP):
    • Se emplean técnicas de NLP para entender e interpretar las consultas en lenguaje natural brindadas por los usuarios. Incluye tareas como reconocimiento de entidades, análisis de sentimiento y análisis sintáctico de consultas.
  4. Personalización:
    • Personalizar los resultados de búsqueda basado en historial, preferencias y feedback del usuario mejora la relevancia de la información recuperada.

Ejemplo Práctico: Búsqueda con Intención en Agente de Viajes

Veamos cómo implementar la búsqueda con intención en Travel Agent.

  1. Recopilando Preferencias del Usuario

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. Comprendiendo la Intención del Usuario

    def identify_intent(query):
    if "book" in query or "purchase" in query:
        return "transactional"
    elif "website" in query or "official" in query:
        return "navigational"
    else:
        return "informational"
  3. Conciencia del Contexto 
    def analyze_context(query, user_history):
    # Combine la consulta actual con el historial del usuario para entender el contexto
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

  4. Buscar y Personalizar Resultados

    def search_with_intent(query, preferences, user_history):
    intent = identify_intent(query)
    context = analyze_context(query, user_history)
    if intent == "informational":
        search_results = search_information(query, preferences)
    elif intent == "navigational":
        search_results = search_navigation(query)
    elif intent == "transactional":
        search_results = search_transaction(query, preferences)
    personalized_results = personalize_results(search_results, user_history)
    return personalized_results

def search_information(query, preferences):
    # Ejemplo de lógica de búsqueda para intención informativa
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # Ejemplo de lógica de búsqueda para intención de navegación
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # Ejemplo de lógica de búsqueda para intención transaccional
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # Ejemplo de lógica de personalización
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # Devolver los 10 mejores resultados personalizados

  5. Ejemplo de Uso

    travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
user_history = ["Louvre Museum website", "Book flight to Paris"]
query = "best museums in Paris"
results = search_with_intent(query, preferences, user_history)
print("Search Results:", results)

4. Generación de Código como Herramienta

Los agentes generadores de código utilizan modelos de IA para escribir y ejecutar código, resolviendo problemas complejos y automatizando tareas.

Agentes Generadores de Código

Los agentes generadores de código usan modelos de IA generativa para escribir y ejecutar código. Estos agentes pueden resolver problemas complejos, automatizar tareas y proporcionar ideas valiosas generando y ejecutando código en varios lenguajes de programación.

Aplicaciones Prácticas

  1. Generación Automática de Código: Generar fragmentos de código para tareas específicas, como análisis de datos, extracción web o aprendizaje automático.
  2. SQL como un RAG: Utilizar consultas SQL para recuperar y manipular datos de bases de datos.
  3. Resolución de Problemas: Crear y ejecutar código para resolver problemas específicos, como optimizar algoritmos o analizar datos.

Ejemplo: Agente Generador de Código para Análisis de Datos

Imagina que estás diseñando un agente generador de código. Así podría funcionar:

  1. Tarea: Analizar un conjunto de datos para identificar tendencias y patrones.
  2. Pasos:
    • Cargar el conjunto de datos en una herramienta de análisis de datos.
    • Generar consultas SQL para filtrar y agregar los datos.
    • Ejecutar las consultas y obtener los resultados.
    • Usar los resultados para generar visualizaciones y conclusiones.
  3. Recursos Requeridos: Acceso al conjunto de datos, herramientas de análisis de datos y capacidades SQL.
  4. Experiencia: Utilizar resultados anteriores de análisis para mejorar la precisión y relevancia de futuros análisis.

Ejemplo: Agente Generador de Código para Agente de Viajes

En este ejemplo, diseñaremos un agente generador de código, Agente de Viajes, para ayudar a los usuarios a planificar sus viajes generando y ejecutando código. Este agente puede manejar tareas como obtener opciones de viaje, filtrar resultados y compilar un itinerario usando IA generativa.

Descripción General del Agente Generador de Código

  1. Recolección de Preferencias del Usuario: Recopila la entrada del usuario como destino, fechas de viaje, presupuesto e intereses.
  2. Generación de Código para Obtener Datos: Genera fragmentos de código para recuperar datos sobre vuelos, hoteles y atracciones.
  3. Ejecución del Código Generado: Ejecuta el código generado para obtener información en tiempo real.
  4. Generación del Itinerario: Compila los datos obtenidos en un plan de viaje personalizado.
  5. Ajuste según Retroalimentación: Recibe la retroalimentación del usuario y regenera código si es necesario para refinar los resultados.

Implementación Paso a Paso

  1. Recolección de Preferencias del Usuario

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. Generación de Código para Obtener Datos

    def generate_code_to_fetch_data(preferences):
    # Ejemplo: Generar código para buscar vuelos según las preferencias del usuario
    code = f"""
    def search_flights():
        import requests
        response = requests.get('https://api.example.com/flights', params={preferences})
        return response.json()
    """
    return code

def generate_code_to_fetch_hotels(preferences):
    # Ejemplo: Generar código para buscar hoteles
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

  3. Ejecución del Código Generado

    def execute_code(code):
    # Ejecutar el código generado usando exec
    exec(code)
    result = locals()
    return result

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
   
flight_code = generate_code_to_fetch_data(preferences)
hotel_code = generate_code_to_fetch_hotels(preferences)
   
flights = execute_code(flight_code)
hotels = execute_code(hotel_code)

print("Flight Options:", flights)
print("Hotel Options:", hotels)

  4. Generación del Itinerario

    def generate_itinerary(flights, hotels, attractions):
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

attractions = search_attractions(preferences)
itinerary = generate_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)

  5. Ajuste según Retroalimentación

    def adjust_based_on_feedback(feedback, preferences):
    # Ajustar las preferencias según los comentarios del usuario
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences)
   
# Regenerar y ejecutar el código con las preferencias actualizadas
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)
   
updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)
   
updated_itinerary = generate_itinerary(updated_flights, updated_hotels, attractions)
print("Updated Itinerary:", updated_itinerary)

Aprovechando la conciencia ambiental y el razonamiento

Basarse en el esquema de la tabla puede mejorar efectivamente el proceso de generación de consultas al aprovechar la conciencia ambiental y el razonamiento.

Aquí hay un ejemplo de cómo se puede hacer esto:

  1. Comprensión del Esquema: El sistema entenderá el esquema de la tabla y usará esta información para fundamentar la generación de consultas.
  2. Ajuste según Retroalimentación: El sistema ajustará las preferencias del usuario basándose en la retroalimentación y razonará sobre qué campos del esquema necesitan ser actualizados.
  3. Generación y Ejecución de Consultas: El sistema generará y ejecutará consultas para obtener datos actualizados de vuelos y hoteles basados en las nuevas preferencias.

Aquí hay un ejemplo actualizado en Python que incorpora estos conceptos:

def adjust_based_on_feedback(feedback, preferences, schema):
    # Ajustar las preferencias según la retroalimentación del usuario
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Razonamiento basado en el esquema para ajustar otras preferencias relacionadas
    for field in schema:
        if field in preferences:
            preferences[field] = adjust_based_on_environment(feedback, field, schema)
    return preferences

def adjust_based_on_environment(feedback, field, schema):
    # Lógica personalizada para ajustar preferencias basadas en el esquema y la retroalimentación
    if field in feedback["liked"]:
        return schema[field]["positive_adjustment"]
    elif field in feedback["disliked"]:
        return schema[field]["negative_adjustment"]
    return schema[field]["default"]

def generate_code_to_fetch_data(preferences):
    # Generar código para obtener datos de vuelos basados en las preferencias actualizadas
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Generar código para obtener datos de hoteles basados en las preferencias actualizadas
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Simular la ejecución del código y devolver datos simulados
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Generar itinerario basado en vuelos, hoteles y atracciones
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# Ejemplo de esquema
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# Ejemplo de uso
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# Regenerar y ejecutar código con las preferencias actualizadas
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)

updated_itinerary = generate_itinerary(updated_flights, updated_hotels, feedback["liked"])
print("Updated Itinerary:", updated_itinerary)

Explicación - Reserva Basada en Retroalimentación

  1. Conciencia del Esquema: El diccionario schema define cómo deben ajustarse las preferencias basándose en la retroalimentación. Incluye campos como favorites y avoid, con ajustes correspondientes.
  2. Ajuste de Preferencias (método adjust_based_on_feedback): Este método ajusta las preferencias basándose en la retroalimentación del usuario y el esquema.
  3. Ajustes Basados en el Entorno (método adjust_based_on_environment): Este método personaliza los ajustes basándose en el esquema y la retroalimentación.
  4. Generación y Ejecución de Consultas: El sistema genera código para obtener datos actualizados de vuelos y hoteles basados en las preferencias ajustadas y simula la ejecución de estas consultas.
  5. Generación del Itinerario: El sistema crea un itinerario actualizado basado en los nuevos datos de vuelos, hoteles y atracciones.

Al hacer que el sistema sea consciente del entorno y razone en base al esquema, puede generar consultas más precisas y relevantes, lo que conduce a mejores recomendaciones de viaje y una experiencia de usuario más personalizada.

Uso de SQL como Técnica de Generación Aumentada por Recuperación (RAG)

SQL (Structured Query Language) es una herramienta poderosa para interactuar con bases de datos. Cuando se usa como parte de un enfoque de Generación Aumentada por Recuperación (RAG), SQL puede recuperar datos relevantes de bases de datos para informar y generar respuestas o acciones en agentes de IA. Exploremos cómo se puede usar SQL como técnica RAG en el contexto del Agente de Viajes.

Conceptos Clave

  1. Interacción con Bases de Datos:
    • SQL se usa para consultar bases de datos, recuperar información relevante y manipular datos.
    • Ejemplo: Obtener detalles de vuelos, información de hoteles y atracciones de una base de datos de viajes.
  2. Integración con RAG:
    • Las consultas SQL se generan basándose en la entrada y preferencias del usuario.
    • Los datos recuperados se usan para generar recomendaciones personalizadas o acciones.
  3. Generación Dinámica de Consultas:
    • El agente de IA genera consultas SQL dinámicas basándose en el contexto y las necesidades del usuario.
    • Ejemplo: Personalizar consultas SQL para filtrar resultados según presupuesto, fechas e intereses.

Aplicaciones

Ejemplo: Un agente de análisis de datos:

  1. Tarea: Analizar un conjunto de datos para encontrar tendencias.
  2. Pasos:
    • Cargar el conjunto de datos.
    • Generar consultas SQL para filtrar datos.
    • Ejecutar consultas y obtener resultados.
    • Generar visualizaciones y conclusiones.
  3. Recursos: Acceso al conjunto de datos, capacidades SQL.
  4. Experiencia: Usar resultados anteriores para mejorar futuros análisis.

Ejemplo Práctico: Uso de SQL en Agente de Viajes

  1. Recolección de Preferencias del Usuario

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. Generación de Consultas SQL

    def generate_sql_query(table, preferences):
    query = f"SELECT * FROM {table} WHERE "
    conditions = []
    for key, value in preferences.items():
        conditions.append(f"{key}='{value}'")
    query += " AND ".join(conditions)
    return query

  3. Ejecución de Consultas SQL

    import sqlite3

def execute_sql_query(query, database="travel.db"):
    connection = sqlite3.connect(database)
    cursor = connection.cursor()
    cursor.execute(query)
    results = cursor.fetchall()
    connection.close()
    return results

  4. Generación de Recomendaciones

    def generate_recommendations(preferences):
    flight_query = generate_sql_query("flights", preferences)
    hotel_query = generate_sql_query("hotels", preferences)
    attraction_query = generate_sql_query("attractions", preferences)
       
    flights = execute_sql_query(flight_query)
    hotels = execute_sql_query(hotel_query)
    attractions = execute_sql_query(attraction_query)
       
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = generate_recommendations(preferences)
print("Suggested Itinerary:", itinerary)

Consultas SQL de Ejemplo

  1. Consulta de Vuelos

    SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate';

  2. Consulta de Hoteles

    SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';

  3. Consulta de Atracciones

    SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';

Al aprovechar SQL como parte de la técnica de Generación Aumentada por Recuperación (RAG), agentes de IA como el Agente de Viajes pueden recuperar y utilizar datos relevantes dinámicamente para ofrecer recomendaciones precisas y personalizadas.

Ejemplo de Metacognición

Para demostrar una implementación de metacognición, vamos a crear un agente simple que reflexione sobre su proceso de toma de decisiones mientras resuelve un problema. Para este ejemplo, construiremos un sistema en el que un agente intenta optimizar la elección de un hotel, pero luego evalúa su propio razonamiento y ajusta su estrategia cuando comete errores o decisiones subóptimas.

Simularemos esto usando un ejemplo básico donde el agente selecciona hoteles basándose en una combinación de precio y calidad, pero “reflexionará” sobre sus decisiones y hará ajustes en consecuencia.

Cómo ilustra esto la metacognición:

  1. Decisión Inicial: El agente escogerá el hotel más barato, sin entender el impacto de la calidad.
  2. Reflexión y Evaluación: Después de la elección inicial, el agente verificará si el hotel fue una mala elección usando la retroalimentación del usuario. Si encuentra que la calidad del hotel fue muy baja, reflexionará sobre su razonamiento.
  3. Ajuste de Estrategia: El agente ajustará su estrategia basándose en su reflexión, cambiando de “más barato” a “máxima calidad”, mejorando así su proceso de toma de decisiones en futuras iteraciones.

Aquí hay un ejemplo:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Almacena los hoteles elegidos previamente
        self.corrected_choices = []  # Almacena las elecciones corregidas
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Estrategias disponibles

    def recommend_hotel(self, hotels, strategy):
        """
        Recommend a hotel based on the chosen strategy.
        The strategy can either be 'cheapest' or 'highest_quality'.
        """
        if strategy == 'cheapest':
            recommended = min(hotels, key=lambda x: x['price'])
        elif strategy == 'highest_quality':
            recommended = max(hotels, key=lambda x: x['quality'])
        else:
            recommended = None
        self.previous_choices.append((strategy, recommended))
        return recommended

    def reflect_on_choice(self):
        """
        Reflect on the last choice made and decide if the agent should adjust its strategy.
        The agent considers if the previous choice led to a poor outcome.
        """
        if not self.previous_choices:
            return "No choices made yet."

        last_choice_strategy, last_choice = self.previous_choices[-1]
        # Supongamos que tenemos algunos comentarios de los usuarios que nos indican si la última elección fue buena o no
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # Ajustar la estrategia si la elección anterior fue insatisfactoria
            new_strategy = 'highest_quality' if last_choice_strategy == 'cheapest' else 'cheapest'
            self.corrected_choices.append((new_strategy, last_choice))
            return f"Reflecting on choice. Adjusting strategy to {new_strategy}."
        else:
            return "The choice was good. No need to adjust."

    def get_user_feedback(self, hotel):
        """
        Simulate user feedback based on hotel attributes.
        For simplicity, assume if the hotel is too cheap, the feedback is "bad".
        If the hotel has quality less than 7, feedback is "bad".
        """
        if hotel['price'] < 100 or hotel['quality'] < 7:
            return "bad"
        return "good"

# Simular una lista de hoteles (precio y calidad)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Crear un agente
agent = HotelRecommendationAgent()

# Paso 1: El agente recomienda un hotel usando la estrategia "más barato"
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# Paso 2: El agente reflexiona sobre la elección y ajusta la estrategia si es necesario
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# Paso 3: El agente recomienda nuevamente, esta vez usando la estrategia ajustada
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

Habilidades Metacognitivas de los Agentes

Lo clave aquí es la habilidad del agente para:

Esta es una forma simple de metacognición donde el sistema es capaz de ajustar su proceso de razonamiento basándose en retroalimentación interna.

Conclusión

La metacognición es una herramienta poderosa que puede mejorar significativamente las capacidades de los agentes de IA. Al incorporar procesos metacognitivos, puedes diseñar agentes que sean más inteligentes, adaptativos y eficientes. Usa los recursos adicionales para explorar más a fondo el fascinante mundo de la metacognición en agentes de IA.

¿Tienes Más Preguntas sobre el Patrón de Diseño de Metacognición?

Únete al Microsoft Foundry Discord para conocer a otros aprendices, asistir a horas de oficina y resolver tus preguntas sobre Agentes de IA.

Lección Anterior

Patrón de Diseño Multi-Agente

Próxima Lección

Agentes de IA en Producción

Descargo de responsabilidad:
Este documento ha sido traducido utilizando el servicio de traducción AI Co-op Translator. Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automáticas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de ningún malentendido o interpretación errónea que pueda surgir del uso de esta traducción.

This site is open source. Improve this page.