Exploración del marco AutoGen de Microsoft para el flujo de trabajo de Agentic

Introducción

En el campo de la IA generativa, que evoluciona rápidamente, los modelos potentes solo funcionan con la ayuda de los seres humanos hasta que llegan los agentes. Es como si los modelos fueran cerebros y los agentes fueran extremidades, por lo que se introduce el flujo de trabajo agéntico para realizar tareas de forma autónoma utilizando agentes que aprovechan el modelo GenAI. En el mundo del desarrollo de la IA, los agentes son el futuro porque pueden realizar tareas complejas sin la participación directa de los seres humanos. Los marcos AutoGen de Microsoft se destacan como una herramienta poderosa para crear y gestionar conversaciones entre múltiples agentes. AutoGen simplifica el proceso de creación de un sistema de IA que puede colaborar, razonar y resolver problemas complejos a través de interacciones entre agentes.

En este artículo, exploraremos las características clave de AutoGen, cómo funciona y cómo puedes aprovechar sus capacidades en los proyectos.

Los resultados del aprendizaje

• Comprender el concepto y la funcionalidad de los agentes de IA y su papel en la ejecución de tareas autónomas.
• Explore las características y los beneficios del marco AutoGen para sistemas de IA multiagente.
• Aprenda a implementar y gestionar interacciones de agente a agente utilizando AutoGen.
• Adquiera experiencia práctica a través de proyectos prácticos que involucran análisis de datos y generación de informes con agentes de AutoGen.
• Descubra aplicaciones reales y casos de uso de AutoGen en diversos dominios, como resolución de problemas, generación de código y educación.

Este artículo fue publicado como parte de la Blogatón sobre ciencia de datos.

¿Qué es un Agente?

Un agente es una entidad que puede enviar mensajes, recibir mensajes y generar respuestas utilizando modelos GenAI, herramientas, entradas humanas o una combinación de todo ello. Esta abstracción no solo permite a los agentes modelar entidades del mundo real y abstractas, como personas y algoritmos, sino que también simplifica la implementación de flujos de trabajo complejos.

¿Qué es lo interesante de AutoGen Framework?

AutoGen es desarrollado por una comunidad de investigadores e ingenieros. Incorpora las últimas investigaciones en sistemas multiagente y se ha utilizado en muchas aplicaciones del mundo real. AutoGen Framework es extensible y componible, lo que significa que puede ampliar un agente simple con componentes personalizables y crear flujos de trabajo que combinen estos agentes para crear un agente más potente. Es modular y fácil de implementar.

Agentes de AutoGen

Exploremos ahora los agentes de AutoGen.

Agentes Conversables

En el corazón de AutoGen se encuentran los agentes conversacionales. Es el agente con funcionalidad básica y es la clase base para todos los demás agentes de AutoGen. Un agente conversacional es capaz de entablar conversaciones, procesar información y realizar tareas.

Tipos de agentes

AutoGen proporciona varios tipos de agentes predefinidos, cada uno diseñado para roles específicos.

• Agente asistente: Un asistente de inteligencia artificial de uso general capaz de comprender y responder consultas.
• Agente Proxy de usuario: Simular el comportamiento del usuario, permitiendo probar y desarrollar la interacción del agente.
• Grupo de chat: Utiliza múltiples agentes para agrupar y funcionarán como un sistema para realizar tareas específicas.

Patrones de conversación

Los patrones nos permiten resolver problemas complejos y completar tareas a través de la interacción de agentes colaboradores.

• conversación uno a uno entre agentes
• Chats grupales con múltiples agentes
• Conversación jerárquica donde los agentes pueden delegar tareas a subagentes

¿Cómo funciona AutoGen?

AutoGen facilita la conversación entre múltiples agentes y la ejecución de tareas a través de una sofisticada orquestación de agentes de IA.

Proceso clave

Inicialización del agente: En AutoGen, primero iniciamos los agentes. Esto implica crear instancias de los tipos de agentes que necesita y configurarlos con parámetros específicos.

Ejemplo:

from autogen import AssistantAgent, UserProxyAgent

assistant1 = AssistantAgent("assistant1", llm_config={"model": "gpt-4","api_key":""})
assistant2 = AssistantAgent("assistant2", llm_config={"model": "gpt-4","api_key":""})

Flujo de conversación: Una vez inicializados los agentes, AutoGen gestiona el flujo de conversación entre ellos.

Patrón de flujo típico:

• Se introduce una tarea o consulta
• Los agentes apropiados procesan la entrada
• Las respuestas se generan y se pasan a los siguientes agentes o al usuario.
• Este ciclo continúa hasta que se completen las tareas o se cumpla una condición de finalización.

Este es el flujo de conversación básico en AutoGen. Para trabajar con procesos de tareas más complejos, podemos combinar varios agentes en un grupo llamado GroupChat y luego usar el Administrador de grupo para administrar la conversación. Cada grupo y administrador de grupo será responsable de tareas específicas.

Ejecución de tareas

A medida que avanza la conversación, es posible que los agentes necesiten realizar tareas específicas. AutoGen admite varios métodos de ejecución de tareas.

• Proceso de lenguaje natural: los agentes pueden interpretar y generar texto similar al humano en múltiples idiomas.
• Ejecución de código: los agentes pueden crear, escribir, ejecutar y depurar código en varios lenguajes de programación automáticamente.
• Llamadas API externas: los agentes pueden interactuar con servicios externos para obtener o procesar datos.
• Búsqueda en la Web: el agente puede buscar automáticamente en la Web, como Wikipedia, para extraer información para consultas específicas.

Manejo de errores e interacción

AutoGen implementa un sólido proceso de gestión de errores. Si un agente encuentra un error, a menudo puede diagnosticarlo e intentar solucionarlo de forma autónoma. Esto crea un ciclo de mejora continua y resolución de problemas.

Terminación de la conversación

Las conversaciones en AutoGen pueden finalizar según condiciones predefinidas.

• La terminación de la tarea
• Alcanzar un número predefinido de vueltas
• Comando de terminación explícita
• Umbrales de error

La flexibilidad de esta condición de terminación permite una interacción rápida y específica.

Casos de uso y ejemplos

Exploremos ahora casos de uso y ejemplos de AutoGen Framework de Microsoft.

Resolución de problemas complejos

AutoGen se destaca por descomponer y resolver problemas complejos mediante la colaboración entre múltiples agentes. Se puede utilizar en la investigación científica para analizar datos, formular hipótesis y diseñar experimentos.

Generación de código y depuración

AutoGen puede generar, ejecutar y depurar código en varios lenguajes de programación. Esto resulta especialmente útil para tareas de automatización y desarrollo de software.

Sistema de publicidad automatizado

El marco AutoGen es ideal para la gestión de publicidad automatizada de múltiples agentes. Puede rastrear las reseñas de los clientes, los clics en la publicidad, realizar pruebas AB automatizadas en publicidad dirigida y utilizar modelos GenAI como Gemini y Stable Difusion para generar publicidad específica para el cliente.

Tutoría educativa

AutoGen puede crear experiencias de tutoría interactivas, donde diferentes agentes asumen roles como profesor, estudiante y evaluador.

Ejemplo de modelo docente-alumno-evaluador

Exploremos ahora un ejemplo sencillo del modelo Profesor-Estudiante-Evaluador.

from autogen import AssistantAgent, UserProxyAgent

teacher = AssistantAgent("Teacher", llm_config={"model": "gpt-4","api_key":""})
student = UserProxyAgent("Student")
evaluator = AssistantAgent("Evaluator", llm_config={"model": "gpt-4","api_key":""})

def tutoring_session():
    student.initiate_chat(teacher, message="I need help understanding quadratic equations.")
    # Teacher explains concept
    student.send(evaluator, "Did I understand correctly? A quadratic equation is ax^2 + bx + c = 0")
    # Evaluator assesses understanding and provides feedback
    teacher.send(student, "Let's solve this equation: x^2 - 5x + 6 = 0")
    # Student attempts solution
    evaluator.send(teacher, "Assess the student's solution and provide guidance if needed.")

tutoring_session()

Hasta ahora hemos reunido todos los conocimientos necesarios para trabajar con AutoGen Framework. Ahora, implementemos un proyecto práctico para consolidar nuestros conocimientos.

Implementación de AutoGen en un proyecto

En este proyecto, utilizaremos AutoGen Agents para descargar un conjunto de datos de la web e intentar analizarlo utilizando LLM.

Paso 1: Configuración del entorno

#create a conda environment
$ conda create -n autogen python=3.11
# after the creating env
$ conda activate autogen
# install autogen and necessary libraries
pip install numpy pandas matplolib seaborn python-dotenv jupyterlab
pip pyautogen

Ahora, abre tu Vscode y comienza el proyecto creando un cuaderno Jupyter de tu elección.

Paso 2: Cargar bibliotecas

import os
import autogen
from autogen.coding import LocalCommandLineCodeExecutor
from autogen import ConversableAgent
from dotenv import load_dotenv

Ahora, recopile las claves API del modelo generativo del sitio correspondiente y colóquelas en el archivo .env en la raíz del proyecto. El código a continuación cargará todas las claves API en el sistema.

load_dotenv()

google_api_key = os.getenv("GOOGLE_API_KEY")
open_api_key = os.getenv("OPENAI_API_KEY")

os.environ("GOOGLE_API_KEY") = google_api_key.strip('"')
os.environ("OPENAI_API_KEY") = open_api_key.strip('"')
seed = 42

Para GEMINIS, Abierto ai

Utilizo la versión gratuita de GeminiAI para probar el código. Establezco la seguridad de Gemini en NINGUNA.

safety_settings = (
    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
)

Paso 3: Configuración de LLM para Gemini-1.5-flash

llm_config = {
    "config_list": (
        {
            "model": "gemini-1.5-flash",
            "api_key": os.environ("GOOGLE_API_KEY"),
            "api_type": "google",
            "safety_settings": safety_settings,
        }
    )
}()

Paso 4: Configuración de LLM para OpenAI

llm_config = {
      "config_list" = ({"model": "gpt-4", "api_key": os.getenv("OPENAI_API_KEY")}

}

Paso 5: Definición de la tarea de codificación

coding_task = (
    """download data from https://raw.githubusercontent.com/vega/vega-datasets/main/data/penguins.json""",
    """ find desccriptive statistics of the dataset, plot a chart of their relation between spices and beak length and save the plot to beak_length_depth.png """,
    """Develope a short report using the data from the dataset, save it to a file named penguin_report.md.""",
)

Paso 5: Diseño de los agentes asistentes

Usaré cuatro asistentes

• Proxy de usuario
• Descifrador
• Escritor
• Crítico

Agente proxy de usuario

Es un proxy de usuario AutoGen, es una subclase de ConversableAgent. Su human_input_mode es SIEMPRE, lo que significa que funcionará como un agente humano. Y su configuración LLM es Falso. De forma predeterminada, solicitará información a los humanos, pero aquí estableceremos human_input_mode en NUNCA, por lo que funcionará de forma autónoma.

  user_proxy = autogen.UserProxyAgent(
    name="User_proxy",
    system_message="A human admin.",
    code_execution_config={
        "last_n_messages": 3,
        "work_dir": "groupchat",
        "use_docker": False,
    },  # Please set use_docker=True if docker is available to 
        #run the generated code. Using docker is safer than running the generated code directly.
    human_input_mode="NEVER",
)

Agentes de código y escritor

Para crear agentes de Code and Writer, aprovecharemos el agente asistente AutoGen, que es una subclase de Conversable Agent. Está diseñado para resolver tareas con LLM. human_input_mode es NUNCA. Podemos usar un mensaje de sistema con un agente asistente.

coder = autogen.AssistantAgent(
    name="Coder",  # the default assistant agent is capable of solving problems with code
    llm_config=llm_config,
)
writer = autogen.AssistantAgent(
    name="writer",
    llm_config=llm_config,
    system_message="""
        You are a professional report writer, known for
        your insightful and engaging report for clients.
        You transform complex concepts into compelling narratives.
        Reply "TERMINATE" in the end when everything is done.
        """,
)

Agente crítico

Es un agente asistente que se encargará de la calidad del código creado por el agente codificador y sugerirá cualquier mejora necesaria.

system_message="""Critic. You are a helpful assistant highly skilled in 
evaluating the quality of a given visualization code by providing a score 
from 1 (bad) - 10 (good) while providing clear rationale. YOU MUST CONSIDER 
VISUALIZATION BEST PRACTICES for each evaluation. Specifically, you can 
carefully evaluate the code across the following dimensions
- bugs (bugs):  are there bugs, logic errors, syntax error or typos? Are 
there any reasons why the code may fail to compile? How should it be fixed? 
If ANY bug exists, the bug score MUST be less than 5.
- Data transformation (transformation): Is the data transformed 
appropriately for the visualization type? E.g., is the dataset appropriated 
filtered, aggregated, or grouped  if needed? If a date field is used, is the
 date field first converted to a date object etc?
- Goal compliance (compliance): how well the code meets the specified 
visualization goals?
- Visualization type (type): CONSIDERING BEST PRACTICES, is the 
visualization type appropriate for the data and intent? Is there a 
visualization type that would be more effective in conveying insights? 
If a different visualization type is more appropriate, the score MUST 
BE LESS THAN 5.
- Data encoding (encoding): Is the data encoded appropriately for the 
visualization type?
- aesthetics (aesthetics): Are the aesthetics of the visualization 
appropriate for the visualization type and the data?

YOU MUST PROVIDE A SCORE for each of the above dimensions.
{bugs: 0, transformation: 0, compliance: 0, type: 0, encoding: 0, 
aesthetics: 0}
Do not suggest code.
Finally, based on the critique above, suggest a concrete list of actions
 that the coder should take to improve the code.
""",

critic = autogen.AssistantAgent(
    name="Critic",
    system_message = system_message,
    llm_config=llm_config,
    )

Chat grupal y creación de administrador

En AutoGen, utilizaremos las funciones de GroupChat para agrupar varios agentes para realizar tareas específicas y luego usaremos GroupChatManager para controlar el comportamiento de GroupChat.

groupchat_coder = autogen.GroupChat(
    agents=(user_proxy, coder, critic), messages=(), max_round=10
)

groupchat_writer = autogen.GroupChat(
    agents=(user_proxy, writer, critic), messages=(), max_round=10
)
manager_1 = autogen.GroupChatManager(
    groupchat=groupchat_coder,
    llm_config=llm_config,
    is_termination_msg=lambda x: x.get("content", "").find("TERMINATE") >= 0,
    code_execution_config={
        "last_n_messages": 1,
        "work_dir": "groupchat",
        "use_docker": False,
    },
)

manager_2 = autogen.GroupChatManager(
    groupchat=groupchat_writer,
    name="Writing_manager",
    llm_config=llm_config,
    is_termination_msg=lambda x: x.get("content", "").find("TERMINATE") >= 0,
    code_execution_config={
        "last_n_messages": 1,
        "work_dir": "groupchat",
        "use_docker": False,
    },
)

Ahora, crearemos un agente de usuario para iniciar el proceso de chat y detectar el comando de finalización. Es un agente UserProxy simple que actúa como un humano.

user = autogen.UserProxyAgent(
    name="User",
    human_input_mode="NEVER",
    is_termination_msg=lambda x: x.get("content", "").find("TERMINATE") >= 0,
    code_execution_config={
        "last_n_messages": 1,
        "work_dir": "tasks",
        "use_docker": False,
    },  # Please set use_docker=True if docker is available to run the 
      #generated code. Using docker is safer than running the generated 
      #code directly.
)

user.initiate_chats(
    (
        {"recipient": coder, "message": coding_task(0), "summary_method": "last_msg"},
        {
            "recipient": manager_1,
            "message": coding_task(1),
            "summary_method": "last_msg",
        },
        {"recipient": manager_2, "message": coding_task(2)},
    )
)

Producción

El resultado de este proceso será muy largo. Para ser breve, publicaré parte del resultado inicial.

Aquí, puede ver que el agente trabajará en pasos: primero descargue el conjunto de datos de pingüino, luego comience a crear código usando el agente codificador, el agente crítico verificará el código y sugerirá mejoras y luego volverá a ejecutar el agente codificador para mejorar según lo sugerido por el crítico.

Es un flujo de trabajo de agente AutoGen simple, puedes experimentar con el código y usar diferentes LLM.

Puedes obtener todo el código utilizado en este artículo aquí

Conclusión

El futuro de la IA no se trata solo de LLM individuales, sino de crear ecosistemas de entidades de IA que puedan trabajar juntas sin problemas. AutoGen está a la vanguardia de este cambio de paradigma y allana el camino para una nueva era de inteligencia artificial colaborativa. A medida que explora las capacidades de AutoGen, recuerde que no solo está trabajando con una herramienta, sino que se está asociando con un ecosistema en evolución de agentes de IA. Aproveche las posibilidades y experimente con diferentes configuraciones de agentes y LLM.

Puntos clave

• Colaboración entre múltiples agentes: AutoGen simplifica la creación de un sistema de IA entre múltiples agentes donde diferentes agentes pueden trabajar juntos para realizar una tarea compleja.
• Flexibilidad y personalización: el marco ofrece amplias opciones de personalización, lo que permite a los desarrolladores crear agentes adaptados a tareas o dominios específicos.
• Generación y ejecución de código: los agentes de AutoGen pueden escribir, depurar y ejecutar código, lo que lo convierte en una herramienta poderosa para el desarrollo de software y el análisis de datos.
• Inteligencia conversacional: al aprovechar los LLM, los agentes pueden participar en conversaciones en lenguaje natural, lo que lo hace adecuado para una amplia gama de aplicaciones, desde servicio al cliente hasta tutoría personalizada.

Preguntas frecuentes

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.