Tutorial AutoGen: Construye aplicaciones de IA multiagente

La IA moderna comenzó con los Grandes Modelos de Lenguaje (LLM), seguidos de la llamada a funciones para obtener resultados estructurados, luego el desarrollo de agentes y herramientas, que condujo a la creación de servidores MCP. Actualmente, la atención se centra en los sistemas multiagente. Las empresas buscan soluciones para construir sistemas automatizados inteligentes utilizando diversas herramientas, entre las que AutoGen es la más popular.

En este tutorial, exploraremos AutoGen, su ecosistema, sus diversos casos de uso y cómo utilizar cada componente dentro de ese ecosistema. Es importante señalar que AutoGen no es sólo una herramienta típica de orquestación de modelos lingüísticos como LangChain; ofrece mucho más que eso.

Si eres nuevo en la IA, haz el curso Fundamentos de la IA antes de seguir con este tutorial. También puedes aprender sobre IA Agenética en otro artículo.

¿Qué es AutoGen?

AutoGen es un marco de trabajo de código abierto diseñado para crear aplicaciones de IA multiagente que pueden funcionar de forma semiautónoma y totalmente autónoma. Proporciona a los programadores herramientas para construir sistemas en los que varios agentes de IA puedan comunicarse, cooperar y realizar tareas juntos.

AutoGen admite una amplia gama de casos de uso, incluidos los flujos de trabajo automatizados, la colaboración multiagente y la resolución dinámica de tareas. Permite a los programadores crear sistemas en los que los agentes pueden interactuar mediante lenguaje natural, ejecutar código, recuperar información y adaptarse a flujos de trabajo complejos.

El ecosistema AutoGen se divide en cuatro componentes principales:

1. AutoGen Studio: Una interfaz gráfica sin código para construir y probar flujos de trabajo multiagente.
2. AutoGent AgentChat: Una API simplificada para construir aplicaciones conversacionales mono y multiagente.
3. Núcleo AutoGen: La API fundamental para construir sistemas de IA multiagente escalables. 
4. Extensión AutoGen: Una biblioteca de extensiones propias y de terceros que amplían las capacidades del marco.

Fuente: microsoft/AutoGen

AutoGen destaca por su capacidad para:

• Simplifica la orquestación y optimización de flujos de trabajo LLM complejos.
• Mejorar el rendimiento de los LLM, abordando al mismo tiempo sus limitaciones.
• Permitir la creación sin fisuras de sistemas multiagente que integren LLM, herramientas y aportaciones humanas.

Su extensibilidad y modularidad la convierten en una potente herramienta para programadores de todos los sectores, desde las finanzas y la sanidad hasta la educación y la robótica.

Lee Comprender a los agentes de IA: El Futuro de los Sistemas Autónomos para aprender a aprovechar los agentes de IA para la innovación y la eficacia en tus proyectos.

Primeros pasos con el ecosistema AutoGen

En esta sección, exploraremos los cuatro componentes principales del ecosistema AutoGen instalándolos y ejecutándolos localmente.

1. AutoGen Studio

AutoGen Studio es una interfaz de bajo código diseñada para ayudarte a crear rápidamente prototipos de agentes de IA. Proporciona una interfaz de arrastrar y soltar fácil de usar para crear sistemas multiagente y probarlos en tiempo real.

1. Para instalar el Estudio, utiliza el comando pip.

pip install -U AutoGenstudio

2. Una vez instalado, puedes iniciar la interfaz de usuario de AutoGen Studio especificando el puerto y el directorio de la aplicación donde se almacenarán todos los agentes y plantillas. 

AutoGenstudio ui --port 8080 --appdir ./app

Después de ejecutar el comando, deberías ver la siguiente salida en tu terminal:

INFO  [alembic.runtime.migration] Context impl SQLiteImpl.
INFO  [alembic.runtime.migration] Will assume non-transactional DDL.
2025-05-09 15:15:22.825 | INFO     | AutoGenstudio.web.app:lifespan:39 - Application startup complete. Navigate to http://127.0.0.1:8080

3. Navega a http://127.0.0.1:8080 en tu navegador para acceder al panel de AutoGen Studio.

Una vez que la aplicación esté en marcha, serás recibido con una interfaz de usuario limpia e intuitiva.

AutoGen Studio proporciona varias funciones clave para ayudarte a construir y gestionar flujos de trabajo multiagente:

1. Creador de equipos: Una interfaz de arrastrar y soltar para crear equipos de agentes.
2. Parque infantil: Un entorno interactivo para probar y ejecutar flujos de trabajo de agentes.
3. Galería: Un eje central para descubrir e importar componentes creados por la comunidad.
4. Laboratorios: Es una función experimental de AutoGen Studio que permite a los usuarios explorar flujos de trabajo avanzados y crear prototipos de ideas vanguardistas.
5. Despliega: Exporta y ejecuta flujos de trabajo de agentes como código Python.

AutoGen Studio es una aplicación de bajo código, lo que significa que te permite crear flujos de trabajo con una codificación mínima. Sin embargo, también proporciona flexibilidad para personalizar los agentes y los flujos de trabajo utilizando código Python.

2. AutoGen AgentChat

AgentChat es un marco de alto nivel para crear flujos de trabajo conversacionales multiagente. Simplifica el proceso de construcción de aplicaciones en las que múltiples agentes (IA, herramientas o humanos) colaboran para resolver tareas. 

Primero, instala los paquetes necesarios:

pip install -U "AutoGen-agentchat" "AutoGen-ext[openai]"

A continuación, crearemos tres agentes -un usuario, un programador y un ejecutor de código- que colaborarán en un chat de grupo rotatorio para generar, ejecutar y narrar código Python. El sistema está diseñado para facilitar la generación y ejecución dinámica de código, permitiendo al mismo tiempo la interacción humana y las condiciones de terminación.

Para este ejemplo, estamos utilizando el modelo gpt-4.1-mini para la generación de código, CodeExecutorAgent para la ejecución de código de línea de comandos y UserProxyAgent para mantener a los humanos en el bucle.

import asyncio
from pathlib import Path

from AutoGen_agentchat.agents import AssistantAgent, CodeExecutorAgent, UserProxyAgent
from AutoGen_agentchat.conditions import TextMentionTermination
from AutoGen_agentchat.teams import RoundRobinGroupChat
from AutoGen_agentchat.ui import Console
from AutoGen_ext.code_executors.local import LocalCommandLineCodeExecutor
from AutoGen_ext.models.openai import OpenAIChatCompletionClient

async def main() -> None:
    model_client = OpenAIChatCompletionClient(model="gpt-4.1-mini")

    coder = AssistantAgent(
        "coder",
        model_client=model_client,
        system_message=(
            "You are a senior engineer. Think step-by-step, then output ONLY runnable "
            "Python inside ```pythonthon``` blocks—no commentary."
        ),
    )

    executor = CodeExecutorAgent(
        "executor",
        model_client=model_client,  # lets it narrate results
        code_executor=LocalCommandLineCodeExecutor(work_dir=Path.cwd() / "runs"),
    )

    user = UserProxyAgent("user")  # human in the loop

    termination = TextMentionTermination("exit", sources=["user"])
    team = RoundRobinGroupChat(
        [user, coder, executor], termination_condition=termination
    )

    try:
        await Console(
            team.run_stream()
        )
    finally:
        await model_client.close()

if __name__ == "__main__":
    asyncio.run(main())

Guarda el código anterior en un archivo chat_app.py, y ejecútalo utilizando:

python chat_app.py 

Hemos pedido a la aplicación Agente que genere código para imprimir las estrellas en forma de triángulo, y que luego ejecute el código. 

Generó correctamente el código y lo ejecutó, ofreciendo además opciones adicionales. El usuario puede teclear "salir" para abandonar o hacer preguntas de seguimiento para una experiencia conversacional.

Salida: 

Enter your response: Write a Python script that prints stars and run it.
---------- TextMessage (user) ----------
Write a Python script that prints stars and run it.

---------- TextMessage (coder) ----------
# Print a simple star pattern
for i in range(1, 6):
    print('*' * i)

---------- CodeGenerationEvent (executor) ----------
# Print a simple star pattern
for i in range(1, 6):
    print('*' * i)

---------- CodeExecutionEvent (executor) ----------

*

**

***

****

*****

---------- TextMessage (executor) ----------

The star pattern has been printed successfully. If you'd like a different pattern or further modifications, just let me know!

Enter your response:

3. Núcleo AutoGen

El Núcleo AutoGen es un marco de trabajo de bajo nivel que proporciona una forma potente de crear y gestionar sistemas multiagente. 

En este ejemplo, crearemos dos agentes: un Agente Eco que invierte el contenido de un mensaje y un Agente Impresor que imprime el contenido del mensaje en la consola.

pip install "autogen-core"

Componentes utilizados en esta aplicación:

1. Estructura del mensaje: La clase Text es una sencilla estructura de datos que contiene el contenido de un mensaje.

2. Agente Eco: El agente Echo invierte el contenido de cualquier mensaje que reciba y publica el mensaje invertido en el tema por defecto utilizando publish_message.

3. Agente de impresión: El agente Printer escucha los mensajes e imprime su contenido en la consola.

4. Tiempo de ejecución: El SingleThreadedAgentRuntime se utiliza para gestionar el ciclo de vida de los agentes y manejar el enrutamiento de mensajes.

import asyncio
from dataclasses import dataclass

from AutoGen_core import (
    AgentId,
    DefaultTopicId,
    MessageContext,
    RoutedAgent,
    SingleThreadedAgentRuntime,
    default_subscription,
    message_handler,
)

@dataclass
class Text:
    content: str

@default_subscription
class Echo(RoutedAgent):
    def __init__(self) -> None:
        super().__init__("echo")

    @message_handler
    async def handle(self, message: Text, ctx: MessageContext) -> None:  # param must be named 'message'
        await self.publish_message(Text(message.content[::-1]), DefaultTopicId())

@default_subscription
class Printer(RoutedAgent):
    def __init__(self) -> None:
        super().__init__("printer")

    @message_handler
    async def handle(self, message: Text, ctx: MessageContext) -> None:  # param must be named 'message'
        print(message.content)

async def main() -> None:
    rt = SingleThreadedAgentRuntime()
    await Echo.register(rt, "echo", lambda: Echo())
    await Printer.register(rt, "printer", lambda: Printer())
    rt.start()
    await rt.send_message(Text("DataCamp"), AgentId("echo", "default"))
    await rt.stop_when_idle()

if __name__ == "__main__":
    asyncio.run(main())

Guarda el código en un archivo core_app.py, y ejecútalo utilizando:

python core_app.py            

Flujo de mensajes:

• Se envía un mensaje con el contenido "DataCamp" al agente Eco.
• El agente Eco invierte el mensaje a "pmaCataD" y lo publica.
• El agente Impresora recibe el mensaje anulado y lo imprime en la consola.

Salida: 

pmaCataD

4. Extensiones AutoGen

El marco de Extensiones AutoGen proporciona extensiones propias y de terceros que amplían las capacidades del marco. 

En este ejemplo, demostraremos cómo utilizar el agente MultimodalWebSurfer, que puede interactuar con páginas web, realizar búsquedas y extraer información .

Antes de ejecutar el ejemplo, asegúrate de que tienes instalado Playwright:

playwright install 

Cómo funciona el código: 

1. Inicialización del agente: Se crea un agente MultimodalWebSurfer, que utiliza el modelo gpt-4.1-mini de OpenAI para la toma de decisiones y un navegador (mediante Playwright) para las interacciones web.
2. Configuración del equipo: El agente se añade a un equipo de RoundRobinGroupChat, que gestiona el flujo de trabajo del agente y limita la tarea a 3 turnos.
3. Ejecución de la tarea: Se ordena al equipo que realice la tarea: "Navega hasta Google y busca sobre Abid Ali Awan". El agente abre un navegador, navega hasta Google, realiza la búsqueda y extrae la información relevante.
4. Salida de streaming: Las acciones del agente (por ejemplo, navegar a una página, hacer clic en enlaces, extraer metadatos) se transmiten a la consola en tiempo real.
5. Limpieza: Una vez finalizada la tarea, se cierra el navegador para liberar recursos.

import asyncio
from AutoGen_agentchat.ui import Console
from AutoGen_agentchat.teams import RoundRobinGroupChat
from AutoGen_ext.models.openai import OpenAIChatCompletionClient
from AutoGen_ext.agents.web_surfer import MultimodalWebSurfer

async def main() -> None:
    # Define an agent
    web_surfer_agent = MultimodalWebSurfer(
        name="MultimodalWebSurfer",
        model_client=OpenAIChatCompletionClient(model="gpt-4.1-mini"),
    )

    # Define a team
    agent_team = RoundRobinGroupChat([web_surfer_agent], max_turns=3)

    # Run the team and stream messages to the console
    stream = agent_team.run_stream(task="Navigate to Google and search about Abid Ali Awan.")
    await Console(stream)
    # Close the browser controlled by the agent
    await web_surfer_agent.close()

asyncio.run(main())

Guarda el código en un archivo, web_ext_app.py, y ejecútalo utilizando:

python web_ext_app.py          

Cuando ejecutes la aplicación, se producirá la siguiente interacción:

                                                           
---------- TextMessage (user) ----------
Navigate to Google and search about Abid Ali Awan.
---------- MultiModalMessage (MultimodalWebSurfer) ----------
I typed 'https://www.google.com' into the browser address bar.

The web browser is open to the page [Google](https://www.google.com/).
The viewport shows 100% of the webpage, and is positioned at the top of the page
The following text is visible in the viewport:

Gmail
Images
Sign in
Google offered in:
اردو
پښتو
سنڌيPakistan
About
Advertising
Business
 How Search works
Privacy
Terms
Settings
Google recommends using Chrome
Try a fast, secure browser with updates built in
Don't switch
Yes

The following metadata was extracted from the webpage:

{
    "microdata": [
        {
            "itemType": "http://schema.org/WebPage",
            "image": "/images/branding/googleg/1x/googleg_standard_color_128dp.png"
        }
    ],
    "meta_tags": {
        "referrer": "origin"
    }
}

Here is a screenshot of the page.
<image>
---------- MultiModalMessage (MultimodalWebSurfer) ----------
I clicked 'Sign in'.

The web browser is open to the page [Sign in - Google Accounts](https://accounts.google.com/v3/signin/identifier?continue=https%3A%2F%2Fwww.google.com%2F&ec=futura_exp_og_so_72776762_e&hl=en&ifkv=ASKV5MhAzFZnwDH-Aw10tuqQN1ppsY8OZ2-OJ3YavFHXMDlX9iTddg1d_k78ZZ0SogFUivcY7Td0Hg&passive=true&flowName=GlifWebSignIn&flowEntry=ServiceLogin&dsh=S1980923188%3A1746809726624486).
The viewport shows 100% of the webpage, and is positioned at the top of the page
The following text is visible in the viewport:

Sign inUse your Google AccountEmail or phone
Forgot email?
Not your computer? Use a private browsing window to sign in.
Learn more about using Guest modeNext
Create account
English (United States)
Help
Privacy
Terms
Sign in Use your Google Account

The following metadata was extracted from the webpage:

{
    "meta_tags": {
        "referrer": "origin",
        "chrome": "nointentdetection",
        "viewport": "width=device-width, initial-scale=1",
        "description": ""
    }
}

Here is a screenshot of the page.
<image>
---------- TextMessage (MultimodalWebSurfer) ----------
Please provide the email or phone number you want to use to sign in, or let me know if you want to create a new account or need help with something else on this page.

Similar a AutoGen, CrewAI es otro marco favorito de los fans de la IA para construir flujos de trabajo agénticos. Sigue la CrewAI: A Guide With Examples of Multi AI Agent Systems tutorial to learn more about it.

Casos de uso de AutoGen

AutoGen abre numerosas posibilidades para crear sistemas inteligentes multiagente. He aquí algunos de los casos de uso más destacados del ecosistema AutoGen:

1. Generación, ejecución y depuración de código: Automatiza las tareas de codificación, reduciendo los errores y mejorando la eficacia.
2. Colaboración multiagente: Permite el trabajo en equipo de los agentes para resolver tareas complejas.
3. Charlas multiagente secuenciales: Gestiona secuencias de tareas estructuradas para completarlas con eficacia.
4. Chats anidados: Maneja tareas intrincadas mediante conversaciones detalladas y estratificadas.
5. Uso de herramientas: Amplía la funcionalidad del agente integrando herramientas como la búsqueda web y las consultas SQL.
6. Implicación humana: Incorpora los comentarios humanos para mejorar los flujos de trabajo.
7. Agente de enseñanza y aprendizaje: Mejora las habilidades y conocimientos de los agentes.
8. Chat multiagente con Asistentes OpenAI: Combina las capacidades de OpenAI con AutoGen para tareas avanzadas.
9. Agente Multimodal: Maneja texto, imágenes y otros medios para interacciones más ricas.
10. Manipulación de contextos largos: Mantiene la coherencia en conversaciones extensas.

Conclusión

Hay una razón por la que AutoGen ha ganado tanta atención y reconocimiento, ganándose su lugar como uno de los frameworks Agentic con más estrellas en GitHub. 

Es un marco de trabajo muy completo que se adapta a todo el mundo, desde programadores profesionales a programadores ocasionales, e incluso a personas sin experiencia previa en programación. 

Con AutoGen, puedes crear rápidamente prototipos de flujos de trabajo mediante AutoGen Studio, crear aplicaciones sólidas con el marco de trabajo principal y las extensiones, e implantarlas sin problemas en la nube. Es realmente una solución todo en uno para crear y gestionar sistemas inteligentes multiagente.

Toma la Construye Agentes Dinámicos LangChain y aprende a crear tu primera aplicación de agente de IA utilizando el popular marco LLM.