Integrando o Bright Data ao BabyAGI por meio de funções personalizadas

Neste tutorial, você aprenderá:

• O que é o BabyAGI e o que o torna uma estrutura de construção de agentes de IA verdadeiramente única.
• Por que estender o BabyAGI com os serviços da Bright Data abre as portas para uma ampla gama de cenários interessantes.
• Como integrar a Bright Data ao BabyAGI por meio de funções personalizadas.

Vamos começar!

O que é BabyAGI?

BabyAGI é uma estrutura Python experimental projetada para criar agentes de IA autônomos e auto-construídos, capazes de gerar, priorizar e executar tarefas para atingir objetivos definidos pelo usuário.

Ele funciona como um gerenciador de tarefas minimalista e com autoaperfeiçoamento, aproveitando LLMs, como os modelos da OpenAI para raciocínio e bancos de dados vetoriais para memória. Em geral, ele opera em um loop inteligente para automatizar fluxos de trabalho complexos.

Em sua essência, o BabyAGI introduz uma estrutura baseada em funções chamada functionz para armazenar, gerenciar e executar funções de um banco de dados. Essas funções também oferecem suporte à geração de código, permitindo que o agente de IA registre novas funções, as chame e evolua de forma autônoma.

Em seguida, um painel integrado permite gerenciar funções, monitorar a execução e registrar segredos. Ele apresenta uma estrutura baseada em gráficos para rastrear importações, funções dependentes e segredos de autenticação, com carregamento automático e registro detalhado.

O que torna o BabyAGI particularmente interessante é sua simplicidade, capacidade de autoconstrução e painel da web fácil de usar. A ideia central é que os agentes autônomos mais eficazes são aqueles que podem se expandir com uma estrutura mínima.

O BabyAGI é de código aberto e mantido ativamente, com mais de 22 mil estrelas no GitHub.

Capacite melhores agentes de IA de auto-construção por meio do acesso a dados da web

Os LLMs são inerentemente limitados pelos dados estáticos com os quais foram treinados, o que muitas vezes leva a alucinações e outros problemas comuns dos LLMs.

O BabyAGI supera essas restrições por meio de sua estrutura de funções de autoconstrução. Ele emprega um LLM para escrever funções personalizadas, que são então repassadas ao agente como ferramentas para ampliar suas capacidades.

No entanto, a lógica para gerar essas funções ainda é limitada pelo conhecimento desatualizado do LLM. Para resolver essa grande limitação, o BabyAGI precisa da capacidade de pesquisar na web e recuperar informações precisas e atualizadas, permitindo-lhe produzir funções mais confiáveis.

Isso é possível através da conexão com os serviços da Bright Data, tais como:

• API SERP: colete resultados de mecanismos de pesquisa do Google, Bing e outros em grande escala sem ser bloqueado.
• API Web Unlocker: acesse qualquer site em uma única solicitação e receba HTML ou Markdown limpo, com tratamento automático de Proxies, cabeçalhos e CAPTCHAs.
• Scraping de dados: recupere dados estruturados e analisados de plataformas populares como Amazon, LinkedIn, Instagram, Yahoo Finance e outras.
• E outras soluções…

Com essas integrações, combinadas com a arquitetura de auto-construção do BabyAGI, a IA pode evoluir autonomamente, adicionar novas funções e lidar com fluxos de trabalho complexos muito além do que um LLM padrão poderia alcançar sozinho.

Como estender o BabyAGI com o Bright Data para recursos de recuperação de dados da Web

Nesta seção passo a passo, você será guiado pela integração do Bright Data ao BabyAGI por meio de funções personalizadas. Elas se conectam a dois produtos do Bright Data: a API SERP e a API Web Unlocker.

Siga as instruções abaixo para começar!

Pré-requisitos

Para acompanhar este tutorial, você precisa de:

• Python 3.10+ instalado localmente.
• Uma chave API OpenAI.
• Uma conta Bright Data configurada com uma zona API SERP, uma zona Web Unlocker API e uma chave API ativa.

Não se preocupe se sua conta Bright Data ainda não estiver configurada, pois você será orientado durante esse processo em uma etapa dedicada.

Etapa nº 1: Configure um projeto BabyAGI

Abra o terminal e crie uma nova pasta para o seu projeto BabyAGI. Por exemplo, chame-a de babyagi-bright-data-app:

mkdir babyagi-bright-data-app

babyagi-bright-data-app/ conterá o código Python para iniciar o painel BabyAGI e definir as funções de integração do Bright Data.

Em seguida, entre no diretório do projeto e inicialize um ambiente virtual dentro dele:

cd babyagi-bright-data-app
python -m venv .venv

Adicione um novo arquivo chamado main.py na raiz do projeto, que agora deve conter:

babyagi-bright-data-app/
├── .venv/
└── main.py

main.py conterá a lógica de inicialização e extensão do BabyAGI.

Carregue a pasta do projeto em seu IDE Python favorito, como o Visual Studio Code com a extensão Python ou o PyCharm Community Edition.

Agora, ative o ambiente virtual que você criou anteriormente. No Linux ou macOS, execute:

source .venv/bin/activate

De forma equivalente, no Windows, execute:

.venv/Scripts/activate

Com o ambiente virtual ativado, instale as bibliotecas PyPI necessárias:

pip install babyagi requests

As dependências para este aplicativo são:

• babyagi: instale o BabyAGI e todos os seus requisitos para que você possa iniciar o painel.
• requests: ajuda você a fazer solicitações HTTP para se conectar aos serviços da Bright Data.

Pronto! Agora você tem um ambiente Python para desenvolvimento de autoagentes no BabyAGI.

Etapa 2: Inicie o painel do BabyAGI

No seu arquivo main.py, adicione o seguinte código para inicializar e iniciar o painel do BabyAGI:

import babyagi

if __name__ == "__main__":
    app = babyagi.create_app("/dashboard")
    app.run(host="0.0.0.0", port=8080)

Isso instrui o BabyAGI a expor o aplicativo do painel em:

http://localhost:8080/dashboard

Verifique se o aplicativo funciona executando:

python main.py

No terminal, você deverá ver logs indicando que o painel está escutando em http://localhost:8080/dashboard:

Acesse essa URL no seu navegador para acessar o painel:

A página inicial do painel BabyAGI lista todas as funções disponíveis. Por padrão, a biblioteca vem com dois pacotes de funções pré-carregados:

1. Funções padrão:
   • Execução de funções: execute, adicione, atualize e recupere funções e suas versões.
   • Gerenciamento de chaves: adicione e recupere chaves secretas.
   • Gatilhos: configure gatilhos para executar funções com base em outras funções.
   • Logs: recupere logs de execução com filtros opcionais.
2. Funções de IA:
   • Descrições e incorporações de IA: gere automaticamente descrições e incorporações de funções.
   • Seleção de funções: Encontre ou recomende funções semelhantes com base em um prompt.

O painel BabyAGI oferece uma interface amigável para gerenciar funções, monitorar execuções, lidar com segredos, configurar gatilhos e visualizar dependências. Explore as páginas disponíveis para se familiarizar com seus recursos e opções!

Etapa 3: Configurar o gerenciamento de segredos

Seu agente BabyAGI se conectará a serviços de terceiros, como OpenAI e Bright Data. Essas conexões são autenticadas usando chaves API externas. Codificar chaves API diretamente em seu arquivo main.py não é uma prática recomendada, pois pode levar a problemas de segurança. Em vez disso, você deve carregá-las a partir de variáveis de ambiente.

O BabyAGI inclui um mecanismo integrado para ler segredos de variáveis de ambiente ou de um arquivo .env local, sem exigir dependências adicionais. Para usar esse recurso, adicione um arquivo .env ao diretório do seu projeto:

babyagi-bright-data-app/
├── .venv/
├── .env # <----
└── main.py

Depois de adicionar suas variáveis ao arquivo .env, você pode acessá-las em seu código desta forma:

import os

ENV_VALUE = os.getenv("ENV_NAME")

É isso! Agora, seu script carrega com segurança segredos de integração de terceiros a partir de variáveis de ambiente, em vez de valores codificados.

Como alternativa, você pode definir esses segredos diretamente no painel. Primeiro, você precisa configurar uma chave API OpenAI (isso será abordado na próxima etapa). Depois de fazer isso, acesse a página “Chat” no painel. No seletor de funções, escolha a função add_key_wrapper e solicite que ela defina seu segredo usando uma mensagem como:

Defina um segredo ENV_NAME cujo valor seja ENV_VALUE.

Após enviar o prompt, você deverá ver um resultado semelhante ao seguinte:

Conforme mostrado, o segredo foi criado com sucesso. Verifique se o segredo existe adicionando a função get_all_secrets_keys e chamando-a.

Etapa 4: conecte o BabyAGI a um modelo OpenAI

A página “Chat” no painel do BabyAGI permite que você selecione funções e as invoque por meio de uma interface conversacional:

Nos bastidores, essa interface é suportada pelo LiteLLM por meio de uma integração com o OpenAI. Por esse motivo, você deve configurar uma chave API do OpenAI em seus segredos.

Se o segredo OPENAI_API_KEY estiver faltando, qualquer mensagem enviada pela página Chat falhará com um erro semelhante ao seguinte:

{"error":"litellm.AuthenticationError: AuthenticationError: OpenAIException - A opção api_key do cliente deve ser definida passando api_key para o cliente ou definindo a variável de ambiente OPENAI_API_KEY"}

Para resolver isso, adicione a variável de ambiente OPENAI_API_KEY ao seu arquivo .env:

OPENAI_API_KEY="<SUA_OPENAI_API_KEY>"

Após salvar o arquivo, reinicie o BabyAGI. Para confirmar se a integração está funcionando, abra a página “Chat” no painel novamente. Selecione a função get_call — que invoca diretamente o modelo OpenAI configurado — e envie uma mensagem simples, como “Olá!”.

Você deve receber uma resposta semelhante à abaixo:

Nesse ponto, a camada LiteLLM subjacente pode se conectar com sucesso ao modelo OpenAI padrão. Isso funciona porque o LiteLLM lê automaticamente a chave da API OpenAI da variável de ambiente OPENAI_API_KEY.

Incrível! Seu aplicativo BabyAGI agora está conectado corretamente a um modelo OpenAI.

Como alternativa, obtenha o mesmo resultado definindo a chave diretamente no código:

babyagi.add_key_wrapper("openai_api_key", "<SUA_CHAVE_API_OPENAI>")

Isso chama a função add_key_wrapper, que é equivalente a definir a chave por meio dela no painel. No entanto, observe que você não pode usar a abordagem do painel antes que a integração OpenAI seja configurada, pois o próprio painel depende da conexão OpenAI para funcionar.

Etapa 5: Comece a usar o Bright Data

Para utilizar os serviços API SERP e Web Unlocker no BabyAGI, primeiro você precisa de uma conta Bright Data com uma zona API SERP e uma zona Web Unlocker API configuradas, juntamente com uma chave API. Vamos configurar tudo!

Se você não tiver uma conta Bright Data, crie uma. Caso contrário, faça login e acesse seu painel. Em seguida, navegue até a página “Proxies & Scraping” e revise a tabela “My Zones”:

Se a tabela já contiver uma zona Web Unlocker API (neste exemplo, unlocker) e uma zona API SERP (neste exemplo, serp), você está pronto para começar. Esses dois serviços serão usados para chamar os serviços Web Unlocker e API SERP por meio de funções personalizadas do BabyAGI.

Se uma ou ambas as zonas estiverem faltando, você precisará criá-las. Role para baixo até os cartões “Unblocker API” e “API SERP” e clique nos botões “Create zone” (Criar zona). Siga o assistente para adicionar ambas as zonas:

Para obter orientações passo a passo, consulte as seguintes páginas da documentação:

• Como começar a usar a API SERP
• Guia de início rápido para a API Web Unlocker da Bright Data

Em seguida, adicione os nomes das zonas Web Unlocker API e API SERP ao seu arquivo .env da seguinte maneira:

SERP_API_ZONE="serp"
WEB_UNLOCKER_ZONE="unlocker"

Importante: neste exemplo, presumimos que a zona da API SERP se chama “serp” e a zona da API Web Unlocker se chama “unlocker”. Substitua esses valores pelos nomes reais das suas zonas (se forem diferentes).

Por fim, você precisa gerar sua chave API Bright Data e armazená-la como uma variável de ambiente em .env:

BRIGHT_DATA_API_KEY="<SUA_CHAVE_API_BRIGHT_DATA>"

Essas três variáveis de ambiente serão lidas pelas funções personalizadas do BabyAGI e usadas para se conectar aos serviços API SERP e Web Unlocker na sua conta Bright Data. Agora você está pronto para defini-las e usá-las no BabyAGI!

Etapa 6: Defina a função API SERP

Comece definindo uma função BabyAGI para realizar pesquisas na web usando a API SERP da Bright Data:

@babyagi.register_function(
    imports=["os", "urllib", "requests"],
    key_dependencies=["bright_data_api_key", "serp_api_zone"],
    metadata={"description": "Pesquise na web por uma determinada consulta usando a API SERP da Bright Data."}
)
def bright_data_serp_api(query: str) -> str:
    import requests
    import os
    import urllib

    # Leia a chave da API Bright Data do ambiente
    BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key")

    # Faça uma solicitação à API SERP da Bright Data
    url = "https://api.brightdata.com/request"
    data = {
        "zone": os.getenv("serp_api_zone"),
        "url": f"https://www.google.com/search?q={urllib.parse.quote_plus(query)}&brd_json=1",
        "format": "raw"
    }
    headers = {
        "Authorization": f"Bearer {BRIGHT_DATA_API_TOKEN}",
        "Content-Type": "application/json"
    }
    response = requests.post(url, json=data, headers=headers)
    response.raise_for_status()

    return response.text

Essa função depende do cliente HTTP Requests para fazer uma solicitação HTTP POST à sua zona API SERP. Em particular, ela envia uma consulta ao Google e recupera os resultados SERP analisados através do Bright Data. Para mais detalhes, consulte a documentação da API SERP do Bright Data.

Observe que uma função BabyAGI deve ser registrada usando o decorador @babyagi.register_function. Ele aceita os seguintes campos:

• importações: uma lista de bibliotecas externas das quais a função depende. Elas são necessárias porque as funções BabyAGI são executadas em um ambiente isolado.
• dependencies: uma lista de outras funções BabyAGI das quais esta função depende.
• key_dependencies: uma lista de chaves secretas necessárias para o funcionamento da função. Neste caso, os segredos necessários são “bright_data_api_key” e “serp_api_zone”, que correspondem às variáveis de ambiente BRIGHT_DATA_API_KEY e SERP_API_ZONE definidas anteriormente no seu arquivo .env.
• metadata["description"]: Uma descrição legível sobre o que a função faz. Isso ajuda o modelo OpenAI a entender sua finalidade.

Fantástico! Seu aplicativo BabyAGI agora inclui a função bright_data_serp_api, através da qual ele pode pesquisar na web por meio da API SERP da Bright Data.

Etapa 7: Defina a função da API Web Unlocker

Da mesma forma, defina uma função personalizada para chamar a API Web Unlocker:

@babyagi.register_function(
    imports=["os", "requests"],
    key_dependencies=["bright_data_api_key", "web_unlocker_zone"],
    metadata={"description": "Buscar conteúdo da página da web através da API Bright Data Web Unlocker."}
)
def bright_data_web_unlocker(page_url: str, data_format: str = "markdown") -> str:
    import requests
    import os

    # Leia a chave da API Bright Data do ambiente
    BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key")

    # Faça uma solicitação à API Bright Data Web Unlocker
    url = "https://api.brightdata.com/request"
    data = {
        "zone": os.getenv("web_unlocker_zone"),
        "url": page_url,
        "format": "raw",
        "data_format": data_format
    }
    headers = {
        "Authorization": f"Bearer {BRIGHT_DATA_API_TOKEN}",
        "Content-Type": "application/json"
    }
    response = requests.post(url, json=data, headers=headers)
    response.raise_for_status()

    return response.text

Isso funciona exatamente como a função bright_data_serp_api, com a principal diferença sendo que ela chama a API Web Unlocker. Para obter mais orientações sobre os parâmetros e opções disponíveis para essa API, consulte a documentação da Bright Data.

Observe que essa função depende do segredo web_unlocker_zone, que corresponde à variável de ambiente WEB_UNLOCKER_ZONE definida na Etapa 5. Além disso, o argumento data_format é definido automaticamente como markdown. Isso permite que o recurso especial“Scrape as Markdown”retorne o conteúdo extraído de uma determinada página da web em um formato Markdown otimizado, ideal para ingestão de LLM.

Dica: por meio de uma configuração semelhante, você pode estender o BabyAGI para integrar outras soluções Bright Data baseadas em API, como APIs de Scraping de dados.

Missão cumprida! As funções desejadas com tecnologia Bright Data foram adicionadas ao BabyAGI.

Etapa 8: Código completo

O código final do seu arquivo main.py será:

import babyagi

@babyagi.register_function(
    imports=["os", "urllib", "requests"],
    key_dependencies=["bright_data_api_key", "serp_api_zone"],
    metadata={"description": "Pesquise na web por uma determinada consulta usando a API SERP da Bright Data."}
)
def bright_data_serp_api(query: str) -> str:
    import requests
    import os
    import urllib

    # Leia a chave da API Bright Data do ambiente
    BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key")

    # Faça uma solicitação à API SERP da Bright Data
    url = "https://api.brightdata.com/request"
    data = {
        "zone": os.getenv("serp_api_zone"),
        "url": f"https://www.google.com/search?q={urllib.parse.quote_plus(query)}&brd_json=1",
        "format": "raw"
    }
    headers = {
        "Authorization": f"Bearer {BRIGHT_DATA_API_TOKEN}",
        "Content-Type": "application/json"
    }
    response = requests.post(url, json=data, headers=headers)
    response.raise_for_status()

    return response.text

@babyagi.register_function(
    imports=["os", "requests"],
    key_dependencies=["bright_data_api_key", "web_unlocker_zone"],
    metadata={"description": "Buscar conteúdo da página da web através da API Bright Data Web Unlocker."}
)
def bright_data_web_unlocker(page_url: str, data_format: str = "markdown") -> str:
    import requests
    import os

    # Ler a chave da API Bright Data do ambiente
    BRIGHT_DATA_API_TOKEN = os.getenv("bright_data_api_key")

    # Fazer uma solicitação à API Bright Data Web Unlocker
    url = "https://api.brightdata.com/request"
    data = {
        "zone": os.getenv("web_unlocker_zone"),
        "url": page_url,
        "format": "raw",
        "data_format": data_format
    }
    headers = {
        "Authorization": f"Bearer {BRIGHT_DATA_API_TOKEN}",
        "Content-Type": "application/json"
    }
    response = requests.post(url, json=data, headers=headers)
    response.raise_for_status()

    return response.text

if __name__ == "__main__":
    app = babyagi.create_app("/dashboard")
    app.run(host="0.0.0.0", port=8080)

Em vez disso, o arquivo .env conterá:

OPENAI_API_KEY="<SUA_CHAVE_API_OPENAI>"
SERP_API_ZONE="<SEU_NOME_ZONA_API_SERP>"
WEB_UNLOCKER_ZONE="<SEU_NOME_ZONA_WEB_UNLOCKER>"
BRIGHT_DATA_API_KEY="<SUA_CHAVE_BRIGHT_DATA_API>"

Inicie o painel BabyAGI com:

python main.py

Abra http://localhost:8080/dashboard no navegador, acesse a página “Chat” e pesquise por “bright_data”. Você verá as duas funções definidas no código para a integração com o Bright Data:

Ótimo! As duas funções personalizadas foram registradas corretamente.

Etapa 9: Teste a integração BabyAGI + Bright Data

Verifique se o seu aplicativo BabyAGI funciona testando as funções Bright Data usando a função padrão chat_with_functions. Isso inicia uma interação de chat que se conecta ao LiteLLM e executa as funções selecionadas do seu banco de dados de funções.

Portanto, comece escolhendo as funções bright_data_serp_api e bright_data_web_unlocker. Em seguida, selecione chat_with_functions:

Em seguida, você deve usar um prompt que acione pesquisas na web e extração de dados. Por exemplo, tente com:

Pesquise na web os últimos anúncios da IA do Google (2025), selecione as três principais notícias ou artigos de blog confiáveis, acesse cada um deles e resuma as principais ideias sobre o futuro da IA do Google (mencionando as URLs dos artigos de origem).

Observação: um LLM básico sem ferramentas externas para acesso à web não seria capaz de concluir essa tarefa.

Execute o prompt no chat e você deverá ver um resultado semelhante a este:

Observe como o resultado contém insights fundamentados, recuperados por meio da pesquisa no Google através da API SERP e da extração de informações das páginas de notícias selecionadas através da API Web Unlocker.

Agora que você verificou que o agente pode interagir com o conteúdo atual da web e aprender com ele, isso significa que o agente tem a capacidade de construir funções que podem interagir com outros serviços, acessando sua documentação para aprender detalhes técnicos que ele não conhecia inicialmente. Teste isso através da função self_build para construção de agentes de IA autônomos, conforme explicado na documentação do BabyAGI.

Sinta-se à vontade para experimentar diferentes prompts de entrada e outras funções do BabyAGI. Graças às funções do Bright Data, seus agentes de autoconstrução BabyAGI podem lidar com uma variedade de casos de uso do mundo real.

Et voilà! Você acaba de experimentar o poder da combinação da Bright Data com a BabyAGI.

Conclusão

Nesta postagem do blog, você viu como habilitar os recursos da Bright Data no BabyAGI por meio de funções personalizadas que chamam a API SERP e a API Web Unlocker.

Essa configuração permite a recuperação de conteúdo de qualquer página da web e pesquisas na web em tempo real. Para ampliar ainda mais a funcionalidade, como acessar feeds da web ao vivo e automatizar interações na web, integre o BabyAGI com o conjunto completo de serviços Bright Data para IA.

Desbloqueie todo o potencial dos agentes de IA auto-construídos!

Cadastre-se gratuitamente hoje mesmo para obter uma conta Bright Data e comece a experimentar nossas soluções de dados da web prontas para IA!