Crie agentes de IA com dados brilhantes no Agno

Neste artigo, você verá o seguinte:

• O que é o Agno e o que o torna especial como uma estrutura de agente de IA.
• Por que a integração com ferramentas de recuperação de dados torna seus agentes de IA significativamente mais avançados.
• Como combinar a Agno com as ferramentas da Bright Data para criar agentes capazes de recuperar dados em tempo real.

Vamos mergulhar de cabeça!

O que é Agno?

O Agno é uma estrutura Python de código aberto para a criação de agentes de IA leves e sistemas multiagentes. Ele vem com suporte incorporado para memória, integração de conhecimento, raciocínio avançado e muito mais.

O que torna a Agno única são os seguintes aspectos:

• Agnóstico em relação ao modelo: Oferece uma interface unificada para mais de 23 provedores de LLM.
• Alto desempenho: Os agentes são instanciados em aproximadamente 3 microssegundos, usando apenas ~6,5 KiB de memória em média.
• O raciocínio como um cidadão de primeira classe: Enfatiza o raciocínio para aumentar a confiabilidade do agente e lidar com tarefas difíceis. Ele oferece suporte a três abordagens de raciocínio: modelos de raciocínio, ferramentas de raciocínio e pipelines de cadeia de raciocínio personalizados.
• Multimodalidade nativa: Os agentes podem processar e gerar texto, imagens, áudio e vídeo imediatamente.
• Suporte para cenários com vários agentes: Crie equipes colaborativas de agentes com memória compartilhada, contexto e raciocínio coordenado.
• Pesquisa agêntica integrada: Os agentes podem pesquisar mais de 20 bancos de dados vetoriais em tempo de execução para fluxos de trabalho RAG autênticos de última geração.
• Memória integrada e armazenamento de sessão: Os agentes incluem drivers integrados de armazenamento e memória, fornecendo memória de longo prazo e rastreamento de sessão persistente.
• Saídas estruturadas: Retorna respostas totalmente tipificadas.

Além disso, a Agno vem com suporte integrado para mais de 50 fornecedores de ferramentas de IA de terceiros. Isso significa que os agentes de IA criados com a Agno podem se integrar facilmente com algumas das melhores soluções de IA do mercado.

Os agentes de IA precisam ter acesso a dados da Web para serem precisos e eficazes

Toda estrutura de agente de IA herda as principais limitações dos LLMs em que se baseia. Como a maioria dos LLMs é pré-treinada em conjuntos de dados estáticos, eles não têm consciência em tempo real e não podem acessar de forma confiável o conteúdo da Web ao vivo.

Isso geralmente leva a respostas desatualizadas ou até mesmo a alucinações. Para superar essas limitações, os agentes (e, para extensões, os LLMs dos quais dependem) precisam acessar dados confiáveis da Web. Por que dados da Web especificamente? Porque a Web é a fonte mais abrangente de informações disponíveis.

Portanto, uma maneira eficaz de conseguir isso é dar aos agentes da Agno a capacidade de realizar consultas de pesquisa ao vivo e extrair conteúdo de qualquer página da Web. Isso é possível por meio das ferramentas Bright Data da Agno!

Essas ferramentas são integradas nativamente ao Agno e fornecem aos agentes acesso a um grande conjunto de ferramentas de dados da Web prontas para IA. Os recursos incluem raspagem da Web, recuperação de dados SERP, recursos de captura de tela e acesso a feeds de dados no formato JSON de mais de 40 sites conhecidos.

Como integrar ferramentas de raspagem de dados brilhantes em um agente Agno

Nesta seção, você aprenderá a usar o Agno para criar um agente de IA Python que possa se conectar às ferramentas da Bright Data. Elas equiparão seu agente com a capacidade de extrair dados de qualquer página e recuperar resultados atualizados de mecanismos de pesquisa.

Siga as etapas abaixo para criar seu agente de IA com base em dados da Bright Data na Agno!

Pré-requisitos

Para acompanhar este tutorial, verifique se você tem o seguinte:

• Python 3.7 ou superior instalado localmente (recomenda-se a versão mais recente).
• Uma chave de API da Bright Data.
• Uma chave de API para um provedor de LLM compatível (aqui, usaremos o OpenAI, mas qualquer provedor compatível funcionará).

Não se preocupe se você ainda não tiver uma chave de API da Bright Data, pois vamos orientá-lo na criação de uma nas próximas etapas.

Etapa 1: Configuração do projeto

Abra um terminal e crie uma nova pasta para o seu agente Agno AI com recuperação de dados com a tecnologia Bright Data:

mkdir agno-bright-data-agent

A pasta agno-bright-data-agent conterá todo o código Python para seu agente de IA.

Em seguida, navegue até a pasta do projeto e crie um ambiente virtual dentro dela:

cd agno-bright-data-agent
python -m venv venv

Agora, abra a pasta do projeto em seu IDE Python preferido. Recomendamos o Visual Studio Code (com a extensão Python) ou o PyCharm Community Edition.

Crie um novo arquivo chamado agent.py dentro da pasta do projeto. A estrutura de seu projeto agora deve ser semelhante a esta:

agno-bright-data-agent/
├── venv/
└── agent.py

Ative o ambiente virtual em seu terminal. No Linux ou macOS, execute este comando:

source venv/bin/activate

De forma equivalente, no Windows, inicie:

venv/Scripts/activate

Nas próximas etapas, você será orientado a instalar as dependências necessárias. Se você preferir instalar tudo agora, execute o seguinte comando no ambiente virtual ativado:

pip install agno python-dotenv openai requests 

Observação: estamos instalando o openai porque este tutorial usa o OpenAI como provedor de LLM. Se você planeja usar um LLM diferente, instale a biblioteca apropriada para esse provedor.

Está tudo pronto! Agora você tem um ambiente de desenvolvimento Python pronto para criar um agente de IA usando as ferramentas Agno e Bright Data.

Etapa 2: Configurar a leitura das variáveis de ambiente

Seu agente Agno interagirá com serviços de terceiros, como OpenAI e Bright Data, por meio da integração da API. Para fazer isso com segurança, você não deve codificar chaves de API diretamente no código Python. Em vez disso, armazene-as como variáveis de ambiente.

Para simplificar o carregamento de variáveis de ambiente, aproveite a biblioteca python-dotenv. Com seu ambiente virtual ativado, instale-o executando:

pip install python-dotenv

Em seguida, em seu arquivo agent.py, importe a biblioteca e carregue as variáveis de ambiente usando load_dotenv():

from dotenv import load_dotenv

load_dotenv()

Essa função permite que seu script leia variáveis de um arquivo .env local. Vá em frente e crie um arquivo .env na raiz da pasta do projeto:

agno-bright-data-agent/
├── venv/
├── .env # <-------------
└── agent.py

Excelente! Agora você está pronto para gerenciar com segurança os segredos de integração de terceiros usando variáveis de ambiente.

Etapa nº 3: comece a usar a Bright Data

No momento em que este texto foi escrito, as ferramentas da Bright Data integradas à Agno forneciam acesso a essas soluções:

• API SERP: Uma API que fornece resultados de pesquisa em tempo real de todos os principais mecanismos de pesquisa.
• API do Web Unlocker: Uma API de raspagem avançada que ignora proteções sofisticadas de bots, dando-lhe acesso a qualquer página da Web (no formato Markdown, que é otimizado para uso de IA).
• APIs do Web Scraper: Pontos de extremidade de raspagem dedicados para extrair eticamente dados novos e estruturados da Web de vários domínios populares.

Para integrar as ferramentas acima, você precisa:

1. Configure as soluções SERP API e Web Unlocker em sua conta da Bright Data.
2. Recupere seu token da API da Bright Data para acessar esses serviços.

Siga as instruções abaixo para fazer as duas coisas!

Primeiro, se você ainda não tiver uma conta da Bright Data, comece criando uma. Se já tiver, faça o login e abra o painel de controle:

Clique no botão “Get proxy products”, que o levará à página “Proxies & Scraping Infrastructure”:

Nesse caso, você pode ver que tanto a API SERP quanto a API Web Unlocker já estão ativadas e prontas para uso. Seus nomes de zona são serp e unblocker, respectivamente.

Se esse não for o seu caso, você precisará configurá-las. Demonstraremos como criar uma zona de API do Web Unlocker, mas o processo é semelhante para criar uma zona de API SERP.

Role a tela para baixo e clique em “Create zone” (Criar zona) no cartão “Web Unlocker API”:

Dê um nome à sua zona (como unlocker), ative os recursos avançados para obter o máximo de eficácia e pressione “Add” (Adicionar):

Em seguida, você será redirecionado para a página da zona, que terá a seguinte aparência:

Certifique-se de que o botão de ativação esteja definido como “Active” (Ativo), pois isso significa que sua zona está configurada corretamente e pronta para uso.

Em seguida, siga o guia oficial da Bright Data para gerar sua chave de API. Depois de obtê-la, adicione-a ao seu arquivo .env desta forma:

BRIGHT_DATA_API_KEY="<YOUR_BRIGHT_DATA_API_KEY>"

Substitua o pelo valor real da chave da API.

Maravilhoso! É hora de integrar as ferramentas da Bright Data em seu script de agente Agno.

Etapa 4: Instalar e configurar as ferramentas de dados do Agno Bright

Na pasta de seu projeto, com o ambiente virtual ativado, instale o Agno executando:

pip install agno

Observação: o pacote agno já inclui suporte integrado para as ferramentas do Bright Data, portanto, não são necessários pacotes específicos de integração para essa configuração.

Agora, como as ferramentas da Bright Data dependem da biblioteca de solicitações do Python, certifique-se de instalá-la também:

pip install requests

Em seu arquivo agent.py, importe as ferramentas Bright Data da Agno:

from agno.tools.brightdata import BrightDataTools

Em seguida, inicialize as ferramentas dessa forma:

bright_data_tools = BrightDataTools(
    serp_zone="YOUR_SERP_ZONE_NAME",
    web_unlocker_zone="YOUR_UNLOCKER_ZONE_NAME"
)

Substitua "YOUR_SERP_ZONE_NAME" e "YOUR_UNLOCKER_ZONE_NAME" pelos nomes das zonas da Bright Data que você configurou anteriormente. Por exemplo, se suas zonas forem denominadas serp e unlocker, o código terá a seguinte aparência:

bright_data_tools = BrightDataTools(
    serp_zone="serp",
    web_unlocker_zone="unlocker"
)

Observe que você também pode ignorar a passagem dos nomes das zonas diretamente no código. Em vez disso, use as seguintes variáveis de ambiente em seu arquivo .env:

BRIGHT_DATA_WEB_UNLOCKER_ZONE="<YOUR_BRIGHT_DATA_WEB_UNLOCKER_ZONE>"
BRIGHT_DATA_SERP_ZONE="<YOUR_BRIGHT_DATA_SERP_ZONE>"

Substitua os espaços reservados pelos nomes reais de suas zonas Bright Data. Em seguida, remova os argumentos serp_zone e web_unlocker_zone no BrightDataTools,

Observação: Para se conectar às soluções da Bright Data, a BrightDataTools depende da variável de ambiente BRIGHT_DATA_API_KEY. Especificamente, ele espera que o ambiente BRIGHT_DATA_API_KEY contenha sua chave da API da Bright Data. É por isso que a adicionamos ao arquivo .env na etapa anterior.

Incrível! A próxima integração é com o LLM.

Etapa nº 5: Configurar o modelo LLM

Para conectar-se ao OpenAI – o provedor LLM usado neste tutorial -, comece instalando a dependência openai necessária:

pip install openai

Em seguida, importe a classe de integração do OpenAI da Agno:

from agno.models.openai import OpenAIChat

Agora, inicialize seu modelo LLM conforme abaixo:

llm_model = OpenAIChat(id="gpt-4o-mini")

Acima, "gpt-4o-mini" é o nome do modelo OpenAI usado neste guia. Você pode alterá-lo para qualquer outro modelo OpenAI compatível, se necessário.

Nos bastidores, o OpenAIChat espera que sua chave de API OpenAI seja definida em uma variável de ambiente chamada OPENAI_API_KEY. Para configurá-la, adicione a seguinte linha ao seu arquivo .env:

OPENAI_API_KEY="<YOUR_OPENAI_API_KEY>"

Substitua o por sua chave de API OpenAI real.

Observação: se você preferir se conectar a um LLM diferente suportado pela Agno, consulte a documentação oficial para obter instruções.

Muito bem! Agora você tem todos os componentes básicos para criar um agente Agno com recursos de recuperação de dados da Web.

Etapa nº 6: criar o agente

Em seu arquivo agent.py, defina seu agente:

agent = Agent(
    tools=[bright_data_tools],
    show_tool_calls=True,
    model=llm_model,
)

Isso cria um agente Agno que usa o modelo LLM configurado para processar a entrada do usuário e tem acesso às ferramentas Bright Data para recuperação de dados. A opção show_tool_calls=True é útil para entender o que está acontecendo, pois exibe quais ferramentas o agente está usando para tratar a solicitação.

Não se esqueça de importar a classe Agent da Agno:

from agno.agent import Agent

Fantástico! A integração Agno + Bright Data está concluída. Tudo o que resta é enviar uma consulta ao seu agente e vê-la em ação.

Etapa 7: Consultar o agente com a ajuda de ferramentas de dados brilhantes

Agora você pode interagir com seu agente Agno AI usando as duas linhas de código a seguir:

prompt = "Search for AAPL news"
agent.print_response(prompt, markdown=True)

A primeira linha define o prompt, que descreve a tarefa ou a pergunta que você deseja que o agente resolva. A segunda linha o executa e imprime sua saída.

A opção markdown=True garante que a resposta seja formatada em Markdown, o que é ideal para uma saída legível e amigável para IA.

Observação: você pode tentar qualquer prompt que desejar, mas “Search for AAPL news” é um ótimo ponto de partida para testar a funcionalidade de recuperação de dados SERP.

Etapa #8: Juntar tudo

Esse deve ser o código final do seu arquivo agent.py:

from dotenv import load_dotenv
from agno.tools.brightdata import BrightDataTools
from agno.models.openai import OpenAIChat
from agno.agent import Agent

# Load the environment variables from the .env file
load_dotenv()

# Configure the Bright Data tools for Agno integration
bright_data_tools = BrightDataTools(
    serp_zone="serp", # Replace with your SERP API zone name
    web_unlocker_zone="unlocker" # Replace with your Web Unlocker API zone name
)

# The LLM that will be used by the AI agent
llm_model = OpenAIChat(id="gpt-4o-mini")

# The definition of your Agno agent, with Bright Data tools
agent = Agent(
    tools=[bright_data_tools],
    show_tool_calls=True, # Useful for understanding what happens behind the scenes
    model=llm_model,
)

# Run a task in the AI agent
prompt = "Search for AAPL news"
agent.print_response(prompt, markdown=True)

Em menos de 30 linhas de código, você acabou de criar um agente de IA que pode extrair dados de qualquer página da Web e realizar pesquisas em tempo real nos principais mecanismos de pesquisa. Esse é o poder do Agno como uma estrutura de pilha completa para a criação de agentes de IA!

Etapa 9: Execute seu agente Agno

É hora de colocar seu agente Agno AI em ação. Em seu terminal, inicie-o com:

python agent.py

Você verá uma saída animada no terminal, mostrando que o agente está processando o prompt “Search for AAPL news”. Depois de concluído, o agente produzirá um resultado como este:

O resultado inclui:

1. O prompt que você enviou.
2. A ferramenta que o agente usou para concluir a tarefa. Nesse caso, ele usou a função search_engine() das ferramentas da Bright Data para acessar o Google por meio da API SERP e recuperar notícias em tempo real sobre as ações da AAPL.
3. Uma resposta formatada em Markdown gerada pelo modelo OpenAI com base nos dados recuperados.

Observação: O resultado contém conteúdo de notícias ao vivo com links clicáveis, graças à formatação Markdown. Além disso, algumas das notícias são muito recentes e foram publicadas apenas algumas horas antes da execução do prompt.

Agora, vamos dar um passo adiante. Suponha que você queira um resumo de um dos artigos de notícias recuperados. Você pode simplesmente atualizar o prompt:

prompt = """
Give me a summary of the following news in around 150 words.

NEWS URL:
https://www.msn.com/en-us/money/other/apple-inc-aapl-to-introduce-new-parental-controls-to-protect-kids-and-teens-online/ar-AA1HdVd6
"""
agent.print_response(prompt, markdown=True)

Dessa vez, o resultado será parecido com o seguinte:

Nesse caso, o agente usou uma ferramenta diferente: scrape_as_markdown(), que se conecta à API do Web Unlocker. Essa ferramenta obtém o conteúdo da página da Web no formato Markdown e o passa para o LLM para resumo.

E pronto! Você acabou de experimentar a recuperação e o processamento contínuos de dados em seu agente de IA, com a tecnologia das ferramentas Bright Data e Agno.

Próximas etapas

O agente de IA que você criou com o Agno neste tutorial é apenas um ponto de partida. Em detalhes, apenas arranhamos a superfície do que é possível. Para levar seu projeto adiante, considere as próximas etapas a seguir:

• Adicione um armazenamento de conhecimento: Aprimore seu agente recuperando dados da Web usando as ferramentas Bright Data e armazenando-os no banco de dados vetorial integrado do Agno. Isso permite a memória de longo prazo e dá suporte ao RAG autêntico.
• Habilite a memória e o raciocínio do agente: Equipe seu agente com memória e raciocínio em várias etapas para que ele possa aprender, refletir e tomar decisões informadas. Isso permite implementar padrões avançados, como a popular arquitetura de agente ReAct (Reasoning + Acting).
• Crie uma interface de usuário para simplificar a interação: Adicione uma interface de usuário para oferecer uma experiência semelhante à do ChatGPT, abrindo a porta para conversas mais naturais com seu agente de IA.

Para obter mais ideias e integrações avançadas, dê uma olhada na documentação oficial do Agno.

Conclusão

Neste artigo, você aprendeu a usar o Agno para criar um agente de IA com recursos de recuperação de dados em tempo real usando as ferramentas do Bright Data. Essa integração permite que seu agente acesse o conteúdo público da Web a partir de sites e mecanismos de pesquisa.

Não se esqueça de que o que você viu aqui é apenas um exemplo simples. Se estiver procurando criar agentes mais avançados, precisará de soluções para recuperar, validar e transformar dados da Web em tempo real. É exatamente isso que você pode encontrar na infraestrutura de IA da Bright Data.

Crie uma conta gratuita na Bright Data e comece a fazer experiências com nossas ferramentas de dados prontas para IA!