Tutorial do AutoGen: Crie aplicativos de IA multiagente

A IA moderna começou com os modelos de linguagem grande (LLMs), seguidos pela chamada de função para saída estruturada e, em seguida, pelo desenvolvimento de agentes e ferramentas, o que levou à criação de servidores MCP. Atualmente, o foco está nos sistemas multiagentes. As empresas estão buscando soluções parapara criar sistemas automatizados inteligentes usando várias ferramentas, sendo o AutoGen a mais popular entre elas.

Neste tutorial, exploraremos o AutoGen, seu ecossistema, seus vários casos de uso e como usar cada componente dentro desse ecossistema. É importante observar que o AutoGen não é apenas uma ferramenta típica de orquestração de modelos de linguagem como o LangChain; ele oferece muito mais do que isso.

Se você é novo em IA, faça o curso Fundamentos de IA antes de prosseguir com este tutorial. Você também pode aprender sobre IA agêntica em um artigo separado.

O que é AutoGen?

AutoGen é uma estrutura de código aberto projetada para criar aplicativos de IA com vários agentes que podem operar de forma semiautônoma e totalmente autônoma. Ele fornece aos desenvolvedores ferramentas para criar sistemas nos quais vários agentes de IA podem se comunicar, cooperar e executar tarefas em conjunto.

O AutoGen oferece suporte a uma ampla variedade de casos de uso, incluindo fluxos de trabalho automatizados, colaboração com vários agentes e solução dinâmica de tarefas. Ele permite que os desenvolvedores criem sistemas em que os agentes possam interagir por meio de linguagem natural, executar códigos, recuperar informações e se adaptar a fluxos de trabalho complexos.

O ecossistema do AutoGen é dividido em quatro componentes principais:

1. AutoGen Studio: Uma interface gráfica sem código para criar e testar fluxos de trabalho com vários agentes.
2. AutoGent AgentChat: Uma API simplificada para a criação de aplicativos de conversação com um único agente e vários agentes.
3. Núcleo AutoGen: A API fundamental para a criação de sistemas de IA multiagente dimensionáveis. 
4. Extensão AutoGen: Uma biblioteca de extensões próprias e de terceiros que expandem os recursos da estrutura.

Fonte: microsoft/AutoGen

O AutoGen se destaca por sua capacidade de:

• Simplifique a orquestração e a otimização de fluxos de trabalho LLM complexos.
• Aprimorar o desempenho dos LLMs e, ao mesmo tempo, abordar suas limitações.
• Permitir a criação contínua de sistemas multiagentes que integrem LLMs, ferramentas e informações humanas.

Sua extensibilidade e modularidade fazem dele uma ferramenta poderosa para desenvolvedores de vários setores, desde finanças e saúde até educação e robótica.

Leia Entendendo os agentes de IA: The Future of Autonomous Systems para saber como aproveitar os agentes de IA para inovação e eficiência em seus projetos.

Primeiros passos com o ecossistema AutoGen

Nesta seção, exploraremos os quatro principais componentes do ecossistema do AutoGen instalando-os e executando-os localmente.

1. AutoGen Studio

O AutoGen Studio é uma interface de baixo código projetada para ajudar você a criar rapidamente protótipos de agentes de IA. Ele oferece uma interface amigável, do tipo arrastar e soltar, para criar sistemas multiagentes e testá-los em tempo real.

1. Para instalar o Studio, use o comando pip.

pip install -U AutoGenstudio

2. Depois de instalado, você pode iniciar a interface do usuário do AutoGen Studio especificando a porta e o diretório do aplicativo onde todos os agentes e modelos serão armazenados. 

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

Depois de executar o comando, você deverá ver a seguinte saída no 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. Navegue até http://127.0.0.1:8080 em seu navegador para acessar o painel do AutoGen Studio.

Quando o aplicativo estiver em execução, você será recebido com uma interface de usuário limpa e intuitiva.

O AutoGen Studio oferece vários recursos importantes para ajudar você a criar e gerenciar fluxos de trabalho com vários agentes:

1. Criador de equipes: Uma interface de arrastar e soltar para criar equipes de agentes.
2. Playground: Um ambiente interativo para testar e executar fluxos de trabalho de agentes.
3. Galeria: Um hub central para você descobrir e importar componentes criados pela comunidade.
4. Laboratórios: É um recurso experimental do AutoGen Studio que permite aos usuários explorar fluxos de trabalho avançados e criar protótipos de ideias de ponta.
5. Implantar: Exporte e execute fluxos de trabalho do agente como código Python.

O AutoGen Studio é um aplicativo com pouco código, o que significa que ele permite que você crie fluxos de trabalho com o mínimo de codificação. No entanto, ele também oferece a flexibilidade para que você personalize agentes e fluxos de trabalho usando código Python.

2. AutoGen AgentChat

O AgentChat é uma estrutura de alto nível para criar fluxos de trabalho de conversação com vários agentes. Ele simplifica o processo de criação de aplicativos em que vários agentes (IA, ferramentas ou humanos) colaboram para resolver tarefas. 

Primeiro, instale os pacotes necessários:

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

Em seguida, configuraremos três agentes - um usuário, um codificador e um executor de código - que colaboram em um bate-papo em grupo round-robin para gerar, executar e narrar o código Python. O sistema foi projetado para facilitar a geração e a execução de códigos dinâmicos e, ao mesmo tempo, permitir a interação humana e as condições de encerramento.

Para este exemplo, estamos usando o modelo gpt-4.1-mini para geração de código, CodeExecutorAgent para execução de código de linha de comando e UserProxyAgent para manter os humanos no loop .

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())

Salve o código acima em um arquivo chat_app.py e execute-o usando:

python chat_app.py 

Solicitamos que o aplicativo Agent gerasse o código para imprimir as estrelas em forma de triângulo e, em seguida, executasse o código. 

Ele gerou o código e o executou com êxito, além de oferecer opções adicionais. O usuário pode digitar "exit" para sair ou fazer perguntas de acompanhamento para uma experiência de conversação.

Saída: 

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 do AutoGen

O AutoGen Core é uma estrutura de baixo nível que oferece uma maneira eficiente de criar e gerenciar sistemas multiagentes. 

Neste exemplo, criaremos dois agentes: um Echo Agent que reverte o conteúdo de uma mensagem e um Printer Agent que imprime o conteúdo da mensagem no console.

pip install "autogen-core"

Componentes usados neste aplicativo:

1. Estrutura da mensagem: A classe Text é uma estrutura de dados simples que contém o conteúdo de uma mensagem.

2. Agente Echo: O agente Echo reverte o conteúdo de qualquer mensagem que recebe e publica a mensagem revertida no tópico padrão usando publish_message.

3. Agente da impressora: O agente Printer escuta as mensagens e imprime seu conteúdo no console.

4. Tempo de execução: O site SingleThreadedAgentRuntime é usado para gerenciar o ciclo de vida dos agentes e lidar com o roteamento de mensagens.

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())

Salve o código em um arquivo core_app.py e execute-o usando:

python core_app.py            

Fluxo de mensagens:

• Uma mensagem com o conteúdo "DataCamp" é enviada para o agente Echo.
• O agente Echo reverte a mensagem para "pmaCataD" e a publica.
• O agente Printer recebe a mensagem invertida e a imprime no console.

Saída: 

pmaCataD

4. Extensões AutoGen

A estrutura AutoGen Extensions fornece extensões próprias e de terceiros que expandem os recursos da estrutura. 

Neste exemplo, demonstraremos como usar o agente MultimodalWebSurfer, que pode interagir com páginas da Web, realizar pesquisas e extrair informações .

Antes de executar o exemplo, verifique se você tem o site Playwright instalado:

playwright install 

Como o código funciona: 

1. Inicialização do agente: É criado um agente MultimodalWebSurfer, que usa o modelo gpt-4.1-mini da OpenAI para a tomada de decisões e um navegador (via Playwright) para interações na Web.
2. Configuração da equipe: O agente é adicionado a uma equipe RoundRobinGroupChat, que gerencia o fluxo de trabalho do agente e limita a tarefa a 3 turnos.
3. Execução de tarefas: A equipe é instruída a realizar a tarefa: "Navegue até o Google e pesquise sobre Abid Ali Awan." O agente abre um navegador, navega até o Google, realiza a pesquisa e extrai informações relevantes.
4. Saída de streaming: As ações do agente (por exemplo, navegar para uma página, clicar em links, extrair metadados) são transmitidas para o console em tempo real.
5. Cleanup: Depois que a tarefa é concluída, o navegador é fechado 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())

Salve o código em um arquivo, web_ext_app.py, e execute-o usando:

python web_ext_app.py          

Quando você executar o aplicativo, ocorrerá a seguinte interação:

                                                           
---------- 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.

Semelhante ao AutoGen, o CrewAI é outra estrutura favorita dos fãs de IA para criar fluxos de trabalho agênticos. Siga o site CrewAI: A Guide With Examples of Multi AI Agent Systems tutorial para que você saiba mais sobre ele.

Casos de uso do AutoGen

O AutoGen abre inúmeras possibilidades para a criação de sistemas inteligentes e multiagentes. Aqui estão alguns dos casos de uso mais proeminentes do ecossistema AutoGen:

1. Geração, execução e depuração de código: Automatiza as tarefas de codificação, reduzindo erros e aumentando a eficiência.
2. Colaboração com vários agentes: Permite o trabalho em equipe entre agentes para resolver tarefas complexas.
3. Bate-papos sequenciais com vários agentes: Gerencia sequências de tarefas estruturadas para uma conclusão eficiente.
4. Chats aninhados: Lida com tarefas complexas por meio de conversas detalhadas e em camadas.
5. Uso da ferramenta: Expande a funcionalidade do agente ao integrar ferramentas como pesquisa na Web e consultas SQL.
6. Envolvimento humano: Incorpora feedback humano para melhorar os fluxos de trabalho.
7. Ensino e aprendizado de agentes: Aprimora as habilidades e o conhecimento dos agentes.
8. Bate-papo com vários agentes com assistentes da OpenAI: Combina os recursos do OpenAI com o AutoGen para tarefas avançadas.
9. Agente multimodal: Lida com texto, imagens e outras mídias para interações mais ricas.
10. Manuseio de contexto longo: Mantém a coerência em conversas longas.

Conclusão

Há um motivo pelo qual o AutoGen ganhou tanta atenção e reconhecimento, conquistando seu lugar como uma das estruturas Agentic mais estreladas no GitHub. 

É uma estrutura abrangente que atende a todos, de desenvolvedores profissionais a programadores casuais e até mesmo a pessoas sem experiência prévia em codificação. 

Com o AutoGen, você pode criar rapidamente protótipos de fluxos de trabalho usando o AutoGen Studio, criar aplicativos robustos com a estrutura Core e as Extensões e implantá-los perfeitamente na nuvem. Ele é realmente uma solução completa para criar e gerenciar sistemas multiagentes inteligentes.

Pegue o Crie agentes dinâmicos LangChain e aprenda a criar seu primeiro aplicativo de agente de IA usando a popular estrutura LLM.