Uso de Navegador e Extração: Alcançando Máxima Eficácia do Agente de IA

Scraping Browser se tornou a ferramenta principal para extração de dados diários e tarefas de automação. Ao integrar o Browser-Use com o Scrapeless Scraping Browser, você pode superar as limitações da automação de navegador e evitar bloqueios.

Neste artigo, construiremos uma ferramenta de agente de IA automatizado usando o Browser-Use e o Scrapeless Scraping Browser para realizar extração de dados automatizada. Você verá como isso economiza tempo e esforço, tornando as tarefas de automação muito mais fáceis!

Você vai aprender:

• O que é Browser-Use, e como ele ajuda a construir agentes de IA?
• Por que o Scraping Browser consegue superar efetivamente as limitações do Browser-Use?
• Como construir um agente de IA sem bloqueios usando Browser-Use e Scraping Browser?

O Que É o Browser-Use?

Browser-Use é uma biblioteca de automação de navegador em Python projetada para capacitar agentes de IA com capacidades avançadas de automação de navegador. Ele pode reconhecer todos os elementos interativos em uma página da web e permite que os agentes interajam com a página programaticamente—executando tarefas comuns como pesquisa, cliques, preenchimento de formulários e extração de dados. Em sua essência, o Browser-Use converte sites em texto estruturado e suporta frameworks de navegador como Playwright, simplificando muito as interações na web.

Ao contrário das ferramentas de automação tradicionais, o Browser-Use combina compreensão visual com análise de estrutura HTML, permitindo que agentes de IA controlem o navegador usando instruções em linguagem natural. Isso torna a IA mais inteligente em perceber o conteúdo da página e executar tarefas de forma eficiente. Além disso, ele suporta gerenciamento de múltabas, rastreamento de interação com elementos, manipulação de ações personalizadas e mecanismos de recuperação de erro integrados para garantir a estabilidade e consistência dos fluxos de trabalho de automação.

Mais importante, o Browser-Use é compatível com todos os principais modelos de linguagem grande (como GPT-4, Claude 3, Llama 2). Com integração ao LangChain, os usuários podem simplesmente descrever tarefas em linguagem natural, e o agente de IA completará operações web complexas. Para usuários que buscam automação de interação web impulsionada por IA, esta é uma ferramenta poderosa e promissora.

Limitações do Browser-Use no Desenvolvimento de Agentes de IA

Como mencionado acima, o Browser-Use não funciona como uma varinha mágica de Harry Potter. Em vez disso, ele combina entrada visual com controle de IA para automatizar navegadores usando Playwright.

O Browser-Use inevitavelmente vem com algumas desvantagens, mas essas limitações não derivam da estrutura de automação em si. Em vez disso, elas surgem dos navegadores que ele controla. Ferramentas como Playwright lançam navegadores com configurações e ferramentas específicas para automação, que também podem ser expostas a sistemas de detecção anti-bot.

Como resultado, seu agente de IA pode frequentemente encontrar desafios de CAPTCHA ou páginas bloqueadas, como “Desculpe, algo deu errado do nosso lado.” Para desbloquear todo o potencial do Browser-Use, ajustes cuidadosos são necessários. O objetivo final é evitar acionar sistemas anti-bot para garantir que sua automação de IA funcione sem problemas.

Após extensos testes, podemos afirmar com confiança: o Scraping Browser é a solução mais eficaz.

O Que É o Scrapeless Scraping Browser?

Scraping Browser é uma ferramenta de automação de navegador baseada em nuvem e sem servidor projetada para resolver três problemas centrais na extração dinâmica de dados da web: gargalos de alta concorrência, evasão de anti-bots e controle de custos.

1. Oferece consistentemente um ambiente de navegador headless de alta concorrência e anti-bloqueio para ajudar os desenvolvedores a extrair facilmente conteúdo dinâmico.

2. Vem com um pool global de IPs proxy e tecnologia de impressão digital, capaz de resolver automaticamente CAPTCHA e contornar mecanismos de bloqueio.

Construído especificamente para desenvolvedores de IA, o Scrapeless Scraping Browser possui um núcleo Chromium profundamente personalizado e uma rede de proxies distribuída globalmente. Os usuários podem executar e gerenciar várias instâncias de navegador headless para construir aplicações e agentes de IA que interagem com a web. Isso elimina as limitações da infraestrutura local e gargalos de desempenho, permitindo que você se concentre totalmente na construção de suas soluções.

Como Browser-Use e Scraping Browser Trabalham Juntos?

Quando combinados, os desenvolvedores podem usar o Browser-Use para orquestrar operações de navegador enquanto confiam no serviço em nuvem estável do Scrapeless e nas poderosas capacidades anti-bloqueio para adquirir dados da web de forma confiável.

O Browser-Use oferece APIs simples que permitem que agentes de IA “entendam” e interajam com o conteúdo web. Por exemplo, ele pode usar LLMs como OpenAI ou Anthropic para interpretar instruções de tarefas e completar ações como pesquisas ou cliques em links no navegador via Playwright.
O navegador de extração do Scrapeless complementa essa configuração abordando suas fraquezas. Ao lidar com grandes sites com medidas rigorosas anti-bot, seu suporte de proxy de alta concorrência, resolução de CAPTCHA e mecanismos de emulação de navegador garantem uma extração estável.

Em resumo, o Browser-Use lida com a inteligência e orquestração de tarefas, enquanto o Scrapeless fornece uma fundação robusta para extração, tornando as tarefas de navegador automatizadas mais eficientes e confiáveis.

Como integrar um navegador de extração com o Browser-Use?

Passo 1. Obtenha a chave da API do Scrapeless

• Registre-se e faça login no Painel do Scrapeless.
• Navegue para "Configurações".
• Clique em "Gerenciamento da Chave da API".

Em seguida, copie e defina a variável de ambiente SCRAPELESS_API_KEY em seu arquivo .env.

Para ativar os recursos de IA no Browser-Use, você precisa de uma chave de API válida de um provedor de IA externo. Neste exemplo, usaremos o OpenAI. Se você ainda não gerou uma chave de API, siga o guia oficial do OpenAI para criar uma.

As variáveis de ambiente OPENAI_API_KEY em seu arquivo .env também são necessárias.

Aviso: Os passos seguintes focam em como integrar o OpenAI, mas você pode adaptar o que vem a seguir às suas necessidades, apenas certifique-se de usar qualquer outra ferramenta de IA suportada pelo Browser-Use.

OPENAI_API_KEY= sua-chave-de-api-openai
SCRAPELESS_API_KEY= sua-chave-de-api-scrapeless

💡 Lembre-se de substituir a chave de API de exemplo pela sua chave de API real.

Em seguida, importe ChatOpenAI em seu programa: langchain_openaiagent.py

from langchain_openai import ChatOpenAI

Observe que o Browser-Use depende do LangChain para lidar com a integração de IA. Portanto, mesmo que você não tenha instalado explicitamente langchain_openai em seu projeto, ele já está disponível para uso.

gpt-4o configura a integração do OpenAI com o seguinte modelo:

llm = ChatOpenAI(model="gpt-4o")

Nenhuma configuração adicional é necessária. Isso ocorre porque langchain_openai lê automaticamente a chave da API da variável de ambiente OPENAI_API_KEY.

Para integração com outros modelos ou provedores de IA, consulte a documentação oficial do Browser-Use.

Passo 2. Instale o Browser Use

Com pip (Python pelo menos v.3.11):

pip install browser-use

Para funcionalidade de memória (requer Python < 3.13 devido à compatibilidade com PyTorch):

pip install "browser-use[memory]"

Passo 3. Configure o Navegador e a Configuração do Agente

Aqui está como configurar o navegador e criar um agente de automação:

from dotenv import load_dotenv
import os
import asyncio
from urllib.parse import urlencode
from langchain_openai import ChatOpenAI
from browser_use import Agent, Browser, BrowserConfig
from pydantic import SecretStr

task = "Acesse o Google, pesquise por 'Scrapeless', clique no primeiro post e retorne ao título"
SCRAPELESS_API_KEY = os.environ.get("SCRAPELESS_API_KEY")
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")

async def setup_browser() -> Browser:
    scrapeless_base_url = "wss://browser.scrapeless.com/browser"
    query_params = {
        "token": SCRAPELESS_API_KEY,
        "session_ttl": 1800,
        "proxy_country": "ANY"
    }
    browser_ws_endpoint = f"{scrapeless_base_url}?{urlencode(query_params)}"
    config = BrowserConfig(cdp_url=browser_ws_endpoint)
    browser = Browser(config)
    return browser

async def setup_agent(browser: Browser) -> Agent:
    llm = ChatOpenAI(
        model="gpt-4o", # Ou escolha o modelo que deseja usar
        api_key=SecretStr(OPENAI_API_KEY),
    )

    return Agent(
        task=task,
        llm=llm,
        browser=browser,
    )

Passo 4. Crie a Função Principal

Aqui está a função principal que reúne tudo:

async def main():
    load_dotenv()
    browser = await setup_browser()
    agent = await setup_agent(browser)
    result = await agent.run()
    print(result)
    await browser.close()
    
asyncio.run(main())

Passo 5. Execute seu script

Execute seu script:

python run main.py

Você deve ver sua sessão do Scrapeless iniciar no Painel do Scrapeless.

Além disso, o Scrapeless suporta replay de sessão, que habilita a visualização do programa. Antes de executar o programa, certifique-se de ter ativado a função de Gravação na Web. Quando a sessão estiver concluída, você poderá ver a gravação diretamente no Painel para ajudá-lo a resolver rapidamente problemas.

Código Completo

from dotenv import load_dotenv
import os
import asyncio
from urllib.parse import urlencode
from langchain_openai import ChatOpenAI
from browser_use import Agent, Browser, BrowserConfig
from pydantic import SecretStr

task = "Vá ao Google, procure por 'Scrapeless', clique na primeira postagem e retorne ao título"
SCRAPELESS_API_KEY = os.environ.get("SCRAPELESS_API_KEY")
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")

async def setup_browser() -> Browser:
    scrapeless_base_url = "wss://browser.scrapeless.com/browser"
    query_params = {
        "token": SCRAPELESS_API_KEY,
        "session_ttl": 1800,
        "proxy_country": "ANY"
    }
    browser_ws_endpoint = f"{scrapeless_base_url}?{urlencode(query_params)}"
    config = BrowserConfig(cdp_url=browser_ws_endpoint)
    browser = Browser(config)
    return browser

async def setup_agent(browser: Browser) -> Agent:
    llm = ChatOpenAI(
        model="gpt-4o", # Ou escolha o modelo que deseja usar
        api_key=SecretStr(OPENAI_API_KEY),
    )

    return Agent(
        task=task,
        llm=llm,
        browser=browser,
    )

async def main():
    load_dotenv()
    browser = await setup_browser()
    agent = await setup_agent(browser)
    result = await agent.run()
    print(result)
    await browser.close()

asyncio.run(main())

💡O uso do Browser atualmente suporta apenas Python.

💡Você pode copiar a URL na sessão ao vivo para assistir ao progresso da sessão em tempo real, e também pode assistir a uma reprise da sessão na história da sessão.

Etapa 6. Resultados da Execução

{
    "done": {
        "text": "O título do primeiro resultado da busca clicado é: 'Effortless Web Scraping Toolkit - Scrapeless'.",
        "success": True,
    }
}

Então, o Agente do Uso do Navegador abrirá automaticamente a URL e imprimirá o título da página: “Scrapeless: Effortless Web Scraping Toolkit” (este é um exemplo do título na página inicial oficial do Scrapeless).

Todo o processo de execução pode ser visualizado no console do Scrapeless na página "Dashboard" → "Sessão" → "História da Sessão", onde você verá os detalhes da sessão executada recentemente.

Etapa 7. Exportando os Resultados

Para compartilhamento em equipe e fins de arquivamento, podemos salvar as informações coletadas em um arquivo JSON ou CSV. Por exemplo, o seguinte trecho de código mostra como escrever os resultados dos títulos em um arquivo:

import json
from pathlib import Path

def save_to_json(obj, filename):
    path = Path(filename)
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open('w', encoding='utf-8') as f:
        json.dump(obj, f, ensure_ascii=False, indent=4)
        
async def main():
    load_dotenv()
    browser = await setup_browser()
    agent = await setup_agent(browser)
    result = await agent.run()
    print(result)
    save_to_json(result.model_dump(), "relatorio_atualizacao_scrapeless.json")
    await browser.close()
        
asyncio.run(main())

O código acima demonstra como abrir um arquivo e escrever conteúdo em formato JSON, incluindo as palavras-chave da pesquisa, links e títulos de páginas. O arquivo gerado relatorio_atualizacao_scrapeless.json pode ser compartilhado internamente através de uma base de conhecimento da empresa ou plataforma de colaboração, facilitando para os membros da equipe visualizarem os resultados da coleta. Para formato de texto simples, você pode simplesmente mudar a extensão para .txt e usar métodos básicos de saída de texto.

Conclusão

Ao usar o serviço de Navegador de Rastreamento da Scrapeless em combinação com o agente de IA do Uso do Navegador, podemos facilmente construir um sistema automatizado para recuperação de informações e relatórios.

• Scrapeless fornece uma solução de rastreamento baseada em nuvem estável e eficiente que pode lidar com mecanismos complexos de anti-rastreamento.
• O Uso do Navegador permite que o agente de IA controle inteligentemente o navegador para realizar tarefas como pesquisa, clique e extração.

Essa integração permite que os desenvolvedores deleguem tarefas tediosas de coleta de dados da web a agentes automatizados, melhorando significativamente a eficiência da pesquisa enquanto garante precisão e resultados em tempo real.

O Navegador de Rastreamento da Scrapeless ajuda a IA a evitar bloqueios de rede enquanto recupera dados de pesquisa em tempo real e garante estabilidade operacional. Combinado com o motor de estratégia flexível do Uso do Navegador, conseguimos construir uma ferramenta de pesquisa de automação de IA mais poderosa que oferece sólido suporte para a tomada de decisões comerciais inteligentes. Este conjunto de ferramentas permite que os agentes de IA "consultem" o conteúdo da web como se estivessem interagindo com um banco de dados, reduzindo bastante o custo da monitorização manual da concorrência e melhorando a eficiência das equipes de P&D e marketing.