Você pode criar fluxos de trabalho agênticos sem precisar de [grandes modelos de linguagem (LLMs)] extremamente grandes e caros (https://www.ibm.com/br-pt/think/topics/large-language-models)? A resposta é sim. Neste tutorial, demonstraremos como construir um sistema de RAG multiagentes localmente com o AutoGen usando o IBM® Granite.
A geração aumentada de recuperação (RAG) é uma maneira eficaz de fornecer a um LLM conjuntos de dados adicionais de várias fontes de dados sem a necessidade de um ajuste fino dispendioso. Da mesma forma, a RAG agêntica aproveita a capacidade de um agente de IA de planejar e executar subtarefas junto com a recuperação de informações relevantes para complementar a base de conhecimento de um LLM. Essa capacidade permite a otimização e maior escalabilidade das aplicações de RAG em comparação com os chatbots tradicionais. Não precisamos mais escrever SQL queries complexas para extrair dados relevantes de uma base de conhecimento.
O futuro da RAG agêntica é a RAG multiagentes, em que vários agentes especializados colaboram para alcançar a latência e a eficiência ideais. Demonstraremos essa colaboração usando um modelo pequeno e eficiente, como o Granite 3.2, e combinando-o com uma arquitetura de agentes modulares. Usaremos vários "mini agentes" especializados, que colaboram para realizar tarefas por meio de planejamento adaptativo e chamadas de ferramentas ou funções. Assim como os humanos, uma equipe de agentes, ou um sistema multiagentes, muitas vezes supera os esforços heroicos de um indivíduo, especialmente quando têm funções claramente definidas e comunicação eficaz.
Para a orquestração dessa colaboração, podemos usar o AutoGen (AG2) como framework central para gerenciar fluxos de trabalho e a tomada de decisão, juntamente com outras ferramentas como o Ollama para serviço de LLMs locais e o Open WebUI para interação. O AutoGen é um framework para criar aplicações de IA multiagentes desenvolvidas pela Microsoft.1 Notavelmente, todos os componentes utilizados neste tutorial são de código aberto. Juntas, essas ferramentas permitem que você crie um sistema de IA poderoso e consciente da privacidade, sem sair de seu notebook.
Nosso agente de recuperação do Granite depende de uma arquitetura modular na qual cada agente tem uma função especializada. Assim como os seres humanos, os agentes têm melhor desempenho quando têm instruções direcionadas e contexto suficiente para tomar uma decisão informada. Muitas informações estranhas, como um histórico de chat não filtrado, podem criar um problema de "agulha no palheiro", onde é cada vez mais difícil distinguir o sinal do ruído.
Nessa arquitetura de IA agêntica, os agentes trabalham juntos sequencialmente para atingir o objetivo. Veja como o sistema de IA generativa é organizado:
Agente de planejamento: cria o plano inicial de alto nível, após estar no início do fluxo de trabalho. Por exemplo, se um usuário perguntar: "Quais são projetos de código aberto comparáveis aos que minha equipe está usando?" Em seguida, o agente elaborará um plano passo a passo, que pode ser mais ou menos assim: “1. Pesquise documentos da equipe em busca de tecnologias de código aberto. 2. Pesquise na web em busca projetos de código aberto semelhantes aos encontrados na etapa 1.” Se qualquer uma dessas etapas falhar ou fornecer resultados insuficientes, as etapas poderão ser adaptadas posteriormente pelo agente de reflexão.
Assistente de pesquisa: o assistente de pesquisa é o carro-chefe do sistema. Ele recebe e executa instruções como "Pesquise documentos da equipe em busca de tecnologias de código aberto". Para a etapa 1 do plano, ele usa a instrução inicial do agente planejador. Para as etapas subsequentes, ele também recebe o contexto selecionado dos resultados das etapas anteriores.
Por exemplo, se for solicitado "Pesquise na web em busca de projetos de código aberto semelhantes", ele também receberá a produção da etapa anterior de pesquisa de documentos. Dependendo da instrução, o assistente de pesquisa pode usar ferramentas como pesquisa na web, pesquisa em documentos, ou ambas, para cumprir sua tarefa.
Crítico de etapas: o crítico de etapas é responsável por decidir se a saída da etapa anterior cumpriu satisfatoriamente a instrução recebida. Ele recebe duas informações: a instrução de etapa única que acabou de ser executada e a saída dessa instrução. Ter um crítico de etapas avaliando a conversa traz clareza sobre se o objetivo foi alcançado, o que é necessário para o planejamento das próximas etapas.
Juiz de objetivos: o juiz de objetivos determina se o objetivo final foi alcançado, com base em todos os requisitos do objetivo fornecido, os planos elaborados para alcançá-lo e as informações coletadas até o momento. A saída do juiz é "YES" ou "NOT YET", seguida de uma breve explicação que não tem mais do que uma ou duas frases.
Agente de reflexão: o agente de reflexão é nosso tomador de decisão executivo. Ele decide qual passo dar a seguir, quer seja avançando para o próximo passo planejado, mudando o curso para compensar percalços ou confirmando que o objetivo foi concluído. Como um CEO da vida real, ele toma suas melhores decisões quando tem um objetivo claro em mente e é apresentado a descobertas concisas sobre o progresso feito ou não para alcançar esse objetivo. A saída do agente de reflexão são as próximas etapas a serem executadas ou as instruções para encerrar se o objetivo tiver sido atingido. Apresentamos ao agente de reflexão os seguintes itens:
- O objetivo
- O plano original
- A última etapa executada
- O resultado da última etapa indicando sucesso ou falha
- Uma sequência concisa de instruções executadas anteriormente (apenas as instruções, não a saída delas)
Apresentar esses itens em um formato estruturado deixa claro para o nosso tomador de decisão o que foi feito para que ele possa decidir o que precisa acontecer a seguir.
Gerador de relatórios: depois que o objetivo é alcançado, o gerador de relatórios sintetiza todas as descobertas em uma produção coesa que responde diretamente à consulta original. Embora cada etapa do processo gere resultados direcionados, o gerador de relatórios une tudo em um relatório final.
Para os iniciantes, pode ser difícil criar uma aplicação de IA agêntica a partir do zero. Portanto, usaremos um conjunto de ferramentas de código aberto. O Granite Retrieval Agent integra várias ferramentas para RAG agêntica.
Open WebUI: o usuário interage com o sistema por meio de uma interface de chat intuitiva hospedada no Open WebUI. Essa interface atua como o ponto principal para o envio de consultas (como "Traga-me os últimos artigos de notícias relacionados às notas do meu projeto") e para a visualização das saídas.
Agente baseado em Python (framework AG2): no núcleo do sistema está um agente baseado em Python criado usando o AutoGen (AG2). Esse agente coordena o fluxo de trabalho dividindo tarefas e chamando dinamicamente ferramentas para executar etapas.
O agente tem acesso a duas ferramentas principais:
Ferramenta de pesquisa de documentos: obtém informações relevantes de um banco de dados de vetores contendo notas de projeto carregadas ou documentos armazenados como embeddings. Essa pesquisa vetorial aproveita as APIs de recuperação de documentos integradas no Open WebUI, em vez de configurar um armazenamento de dados totalmente separado.
Ferramenta de pesquisa na web: realiza pesquisas na web para reunir conhecimento externo e informações em tempo real. Neste caso, estamos usando o SearXNG como nosso mecanismo de metabusca.
Ollama: o IBM Granite 3.2 LLM serve como modelo de linguagem que alimenta o sistema. Ele é hospedado localmente usando o Ollama, garantindo inferência rápida, eficiência de custos e privacidade de dados. Se você estiver interessado em executar este projeto com modelos maiores, o acesso à API por meio do IBM® watsonx.ai ou OpenAI, por exemplo, é preferível. No entanto, essa abordagem exige uma chave de API do watsonx.ai ou da OpenAI. Em vez disso, usamos o Ollama hospedado localmente neste tutorial.
Outros frameworks comuns de agentes de código aberto não abordados neste tutorial incluem LangChain, LangGraph e crewAI.
Instruções detalhadas de configuração, bem como todo o projeto, podem ser visualizadas no GitHub da Comunidade IBM Granite. A versão Jupyter Notebook deste tutorial também pode ser encontrada no GitHub.
As etapas a seguir apresentam uma configuração rápida do agente de recuperação do Granite.
Etapa 1: Instale o Ollama
Instalar o Ollama é tão simples quanto baixar o cliente do site oficial do Ollana. Depois de instalar o Ollama, execute o seguinte comando para extrair o LLM Granite 3.2.
Agora você está operando com o Ollama e Granite.
Etapa 2. Crie um agente simples (opcional) Uma solução de pouco código para criar fluxos de trabalho de agentes é o AutoGen Studio. No entanto, criar um agente simples por conta própria pode nos ajudar a entender melhor a configuração desse projeto de RAG multiagentes completo. Para continuar, configure um Jupyter Notebook em seu ambiente de desenvolvimento integrado (IDE) preferido e ative um ambiente virtual executando os seguintes comandos em seu terminal.
python3.11 -m venv venv
source venv/bin/activate
Precisamos de algumas bibliotecas e módulos para esse agente simples. Certifique-se de instalar e importar os seguintes.
!pip install -qU langchain chromadb tf-keras pyautogen "ag2[ollama]" sentence_transformers
import getpass
from autogen.agentchat.contrib.retrieve_assistant_agent import AssistantAgent
from autogen.agentchat.contrib.retrieve_user_proxy_agent import RetrieveUserProxyAgent
Há vários parâmetros de configuração a definir localmente para invocar o LLM correto que extraímos usando o Ollama.
ollama_llm_config = {
"config_list": [
{
"model": "granite3.2:8b",
"api_type": "ollama",
}
],
}
Podemos passar esses parâmetros de configuração no parâmetro "llm_config" da classe "AssistantAgent" para instanciar nosso primeiro agente de IA.
assistant = AssistantAgent(
name="assistant",
system_message="You are a helpful assistant.",
llm_config=ollama_llm_config,
)
Esse agente usa o Granite 3.2 para sintetizar as informações retornadas pelo agente "ragproxyagent". O documento que fornecemos ao agente de RAG como contexto adicional é o arquivo README Markdown bruto encontrado no repositório AutoGen no GitHub. Além disso, podemos passar um novo dicionário de configurações específicas para o agente de recuperação. Algumas chaves adicionais que você pode achar úteis são "vector_db", "chunk_token_size" e "embedding_model".
Para obter uma lista completa de chaves de configuração, consulte a documentação oficial.
ragproxyagent = RetrieveUserProxyAgent(
name="ragproxyagent",
max_consecutive_auto_reply=3,
is_termination_msg=lambda msg: msg.get("content") is not None or "TERMINATE" in msg["content"],
system_message = "Context retrieval assistant.",
retrieve_config={
"task": "qa",
"docs_path": "https://raw.githubusercontent.com/microsoft/autogen/main/README.md",
"get_or_create": True,
"collection_name": "autogen_docs",
"overwrite": True
},
code_execution_config=False,
human_input_mode="NEVER",
)
Agora, podemos iniciar um chat com nosso agente de RAG para fazer uma pergunta relacionada ao documento apresentado como contexto.
qs = "What languages does AutoGen support?"
result = ragproxyagent.initiate_chat(
assistant, message=ragproxyagent.message_generator, problem=qs
)
print(result)
Observe que o conteúdo do Markdown do arquivo README foi omitido da saída por uma questão de brevidade.
Output:
Tentando criar coleção.
2025-07-21 12:20:36,125 - autogen.agentchat.contrib.retrieve_user_proxy_agent - INFO - Found 1 chunks.
2025-07-21 12:20:36,129 - autogen.agentchat.contrib.vectordb.chromadb - INFO - Nenhuma embedding é fornecida. Utilizará a função de embedding do VectorDB para gerar o embedding de conteúdo.
VectorDB returns doc_ids: [['8e9131c7']]
Adicionando conteúdo do doc 8e9131c7 ao contexto.
ragproxyagent (para o assistente):
você é um chatbot aprimorado de recuperação. Você responde às perguntas dos usuários com base em seu próprio conhecimento e no contexto fornecido pelo usuário.
Se você não puder responder à pergunta com ou sem o contexto atual, deverá responder exatamente "ATUALIZAR CONTEXTO".
Você deve dar uma resposta o mais curta possível.
A pergunta do usuário é: com quais idiomas o AutoGen é compatível?
O contexto é:
[REDACTED]
assistant (to ragproxyagent):
O texto fornecido parece ser um arquivo README para o projeto AutoGen, uma iniciativa de código aberto da Microsoft. Veja um resumo de seu conteúdo:
- Visão geral do projeto: o AutoGen é um sistema para criar e gerenciar aplicações distribuídas complexas. Ele é compatível com várias linguagens (C#, Python) e oferece um ambiente de tempo de execução para a implementação e a escalabilidade dessas aplicações.
- Componentes principais:
- AutoGen Core: a biblioteca central que contém as classes e interfaces fundamentais para a criação de aplicações do AutoGen.
- AutoGen Agent: componente de tempo de execução responsável por gerenciar o ciclo de vida das aplicações do AutoGen.
- AutoGen Runtime Gateway: um serviço que facilita a comunicação entre agentes e permite balanceamento de carga, escalabilidade e tolerância a falhas.
- AutoGen Core: a biblioteca central que contém as classes e interfaces fundamentais para a criação de aplicações do AutoGen.
- Linguagens compatíveis: C# e Python são compatíveis atualmente.
- Introdução: o README fornece instruções sobre como instalar os pacotes necessários, criar um novo projeto e compilar/executar uma aplicação do AutoGen.
- Documentação: links para documentação detalhada para referência, incluindo referências de APIs, guias e tutoriais.
- Comunidade e contribuição: diretrizes para contribuir com o projeto, incluindo informações sobre rastreamento de problemas, solicitações pull e padrões de programação.
- Avisos legais: informações de licenciamento e avisos de marca comercial.
- Suporte e perguntas frequentes: informações sobre como fazer perguntas, relatar problemas e encontrar respostas para consultas comuns.
O README também inclui uma tabela resumindo os pacotes disponíveis para cada linguagem compatível (C# e Python) e seus respectivos gerenciadores de pacotes (NuGet e PyPI). Isso facilita para os desenvolvedores a identificação rápida dos componentes necessários para começar a usar o AutoGen em sua linguagem preferida.
>>>>>>>> TERMINATING RUN (601a53dc-8a5d-4e19-8503-1517fe3c7634): Termination message condition on agent 'ragproxyagent' met
Ótimo! Nosso agente assistente e agente de RAG sintetizou com sucesso o contexto adicional para responder corretamente à consulta do usuário com as linguagens de programação atualmente compatíveis com o AutoGen. Você pode pensar nisso como um chat em grupo entre agentes trocando informações. Este exemplo é uma demonstração simples da implementação da RAG agêntica localmente com o AutoGen.
Etapa 3. Instale o Open WebUI
Agora, vamos migrar para a criação de um sistema de RAG agêntica mais avançado. Em seu terminal, instale e execute o Open WebUI.
pip install open-webui
open-webui serve
Etapa 4. Configure a pesquisa na web
Para a pesquisa na web, aproveitaremos os recursos integrados de pesquisa na web no Open WebUI.
O Open WebUI é compatível com vários provedores de pesquisa. Em termos gerais, você pode usar um serviço de interface de programação de aplicativos (API) de terceiros, para o qual precisará obter uma chave de API, ou pode configurar localmente um contêiner SearXNG Docker . Em ambos os casos, você precisará configurar seu provedor de pesquisa no console do Open WebUI.
Essa configuração, que é um ponteiro para o SearXNG ou entrada da sua chave de API, está em Painel de administração > Configurações > Pesquisa na web no console do Open WebUI.
Consulte as instruções na documentação do Open WebUI para obter instruções mais detalhadas.
Etapa 5. Importe o agente para o Open WebUI
1. Em seu navegador, acesse http://localhost:8080/ para acessar o Open Web IU. Se for a primeira vez que você abre a interface do Open WebUI, registre um nome de usuário e senha. Essas informações são mantidas integralmente no local de sua máquina.
2. Após o registro, clique no ícone no lado inferior esquerdo, onde está seu nome de usuário. No menu, clique em Painel do administrador.
3. Na guia Funções, clique em + para adicionar uma nova função.
4. Dê um nome à função, como "Agente de RAG Granite", e uma descrição, tanto de
5. Cole o script Python granite_autogen_rag.py na caixa de texto fornecida, substituindo qualquer conteúdo existente.
6. Clique em Salvar na parte inferior da tela.
7. De volta na página Funções, certifique-se de que o agente esteja alternado para Ativado.
8. Clique no ícone de engrenagem ao lado do botão de ativação para personalizar as configurações, como o endpoint de inferência, o endpoint do SearXNG ou a ID do modelo.
Agora, seu novo agente do AutoGen aparece como um modelo na interface do Open WebUI. Você pode selecioná-lo e fornecer consultas de usuário.
Etapa 6. Carregue documentos no Open WebUI
- No Open WebUI, navegue até Workspace > Knowledge.
- Clique em + para criar uma nova coleção.
- Carregue documentos para o agente de recuperação do Granite consultar.
Etapa 7. Configure a pesquisa na web no Open WebUI
Para configurar um provedor de pesquisa (por exemplo, SearXNG), siga este guia.
Os parâmetros de configuração são os seguintes:
| Parâmetro | Descrição | Valor padrão |
|---|---|---|
| task_model_id | Modelo primário para execução de tarefas | granite3.2:8b |
| vision_model_id | Modelo de visão para análise de imagens | granite-vision3.2:2b |
| openai_api_url | Endpoint de API para chamadas de modelo no estilo do OpenAI | http://localhost:11434 |
| openai_api_key | Chave de API para autenticação | ollama |
| vision_api_url | Endpoint para tarefas relacionadas à visão | http://localhost:11434 |
| model_temperature | Controla a aleatoriedade das respostas | 0 |
| max_plan_steps | Máximo de etapas no planejamento dos agentes | 6 |
Observação: esses parâmetros podem ser configurados por meio do ícone de engrenagem na seção "Funções" do painel de administração do Open WebUI após adicionar a função.
Etapa 8. Consulte o sistema agêntico
O agente de recuperação do Granite executa a RAG baseada em AG2, consultando documentos locais e fontes da web, realizando planejamento de tarefas multiagentes e impondo a execução adaptativa. Inicie um chat e apresente ao seu sistema agêntico uma consulta relacionada aos documentos entregues para ver a cadeia da RAG em ação.
Uma configuração multiagentes permite a criação de ferramentas práticas e utilizáveis, aproveitando ao máximo modelos de código aberto e de tamanho moderado, como o Granite 3.2. Essa arquitetura de RAG agêntica, construída com ferramentas de código aberto, pode servir como um ponto de lançamento para projetar e personalizar seus agentes de resposta a perguntas e algoritmos de IA. Ela também pode ser usada de forma criativa para uma ampla variedade de casos de uso. Neste tutorial, você teve a oportunidade de se aprofundar em sistemas agênticos simples e complexos, aproveitando os recursos do AutoGen. O LLM Granite foi invocado usando o Ollama, permitindo uma exploração totalmente local desses sistemas. Como próximo passo, considere a integração de mais ferramentas personalizadas a seu sistema agêntico.
Recursos
Use a IA a serviço de sua empresa com a experiência e o portfólio de soluções líder do setor da IBM à sua disposição.
Reinvente os fluxos de trabalho e operações críticos adicionando IA para maximizar experiências, tomadas de decisão em tempo real e valor de negócios.
Notas de rodapé
[1] Wu, Qingyun, et al. “AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation Framework.” GitHub, 2023, github.com/microsoft/autogen.