Web Scraping com LLaMA 3: Transforme qualquer site em JSON estruturado (Guia de 2025)

Introdução: A Evolução da Extração de Dados com IA

A extração de dados da web, a extração automática de dados de websites, tem sido há muito tempo um pilar para empresas e pesquisadores que buscam reunir informações, monitorar mercados e construir conjuntos de dados. No entanto, o cenário da extração de dados está em constante evolução, principalmente devido a medidas anti-bot cada vez mais sofisticadas implementadas pelos sites. Métodos tradicionais de extração são notavelmente frágeis, dependendo de seletores estáticos como XPath ou CSS. Mudanças menores no layout de um site ou atualizações nas defesas anti-bot podem tornar toda uma infraestrutura de extração obsoleta, levando a um custo significativo de manutenção e perda de dados.

O advento de grandes modelos de linguagem (LLMs), como o LLaMA 3 da Meta, marca uma mudança crucial nesse paradigma. O LLaMA 3, com sua notável capacidade de entender e processar linguagem natural, oferece uma abordagem mais resiliente e inteligente para a extração de dados. Ao contrário dos extratores convencionais que operam com regras rígidas, o LLaMA 3 pode interpretar o significado contextual do conteúdo da web, muito parecido com um humano. Essa capacidade permite que ele se adapte a variações na estrutura do site e extraia informações relevantes, mesmo quando os layouts mudam, tornando-se uma ferramenta inestimável para os desafios modernos da extração de dados.

Este guia abrangente de 2025 se aprofunda em como usar o LLaMA 3 para extração avançada de dados da web, transformando HTML bruto em JSON limpo e estruturado. Vamos explorar os princípios fundamentais, passos práticos de implementação e, crucialmente, como superar os desafios mais formidáveis anti-bot integrando soluções de ponta como o Scrapeless Scraping Browser. Ao final deste guia, você terá conhecimento para construir extratores de dados da web robustos e movidos por IA que são eficientes e resilientes contra defesas web contemporâneas.

Por que o LLaMA 3 é um divisor de águas para a extração de dados da web

LLaMA 3, lançado em abril de 2024, é o poderoso modelo de linguagem de peso aberto da Meta, disponível em vários tamanhos, de 8B a 405B parâmetros. Suas iterações subsequentes (LLaMA 3.1, 3.2 e 3.3) trouxeram melhorias significativas em desempenho, compreensão contextual e capacidades de raciocínio. Esses avanços tornam o LLaMA 3 particularmente adequado para a extração de dados da web por várias razões convincentes:

1. Compreensão Contextual e Extração Semântica

Os extratores de dados da web tradicionais são inerentemente frágeis porque dependem de elementos estruturais precisos de uma página da web. Se um nome de classe div mudar ou a posição de um elemento se deslocar, o extrator falha. No entanto, o LLaMA 3 opera em um nível mais alto de abstração. Ele pode entender o significado do conteúdo, independentemente de sua estrutura HTML subjacente. Por exemplo, ele pode identificar um título de produto, preço ou descrição com base em pistas semânticas, mesmo que as tags HTML ao redor variem entre diferentes páginas ou após uma redesign do site. Essa compreensão contextual reduz dramaticamente a fragilidade dos extratores e a necessidade de manutenção constante.

2. Maior Resiliência a Mudanças no Site

Os sites são entidades dinâmicas, com atualizações frequentes em seu design, conteúdo e código subjacente. Para extratores tradicionais, cada atualização pode ser uma mudança disruptiva. A capacidade do LLaMA 3 de interpretar semântica do conteúdo significa que ele é muito mais resiliente a essas mudanças. Ele pode continuar a extrair dados com precisão, mesmo que os elementos sejam rearranjados, novas seções sejam adicionadas ou pequenos ajustes estilísticos sejam feitos. Essa resiliência se traduz diretamente em custos operacionais reduzidos e fluxos de dados mais consistentes.

3. Lidar com Conteúdo Dinâmico e Páginas Renderizadas em JavaScript

Sites modernos dependem fortemente do JavaScript para renderizar conteúdo dinamicamente. Isso representa um desafio significativo para extratores baseados em solicitações HTTP simples. Embora navegadores sem cabeça como o Selenium possam executar JavaScript, extrair dados específicos do DOM renderizado ainda exige seletores precisos. O LLaMA 3, quando combinado com um navegador sem cabeça, pode processar o conteúdo HTML totalmente renderizado e extrair inteligentemente as informações desejadas, contornando as complexidades da renderização de conteúdo dinâmico e das interações complexas do JavaScript.

4. Eficiência através da Conversão para Markdown

HTML bruto pode ser extremamente verboso e conter uma grande quantidade de informações irrelevantes (por exemplo, scripts, estilização, elementos ocultos). Processar tais grandes entradas com um LLM pode ser computacionalmente caro e levar a um maior uso de tokens, aumentando os custos e os tempos de processamento. Uma técnica de otimização chave envolve converter o HTML em um formato mais limpo e conciso como Markdown. O Markdown reduz significativamente a contagem de tokens enquanto preserva o conteúdo e a estrutura essenciais, tornando o processamento do LLM mais eficiente, rápido e econômico. Essa redução no tamanho da entrada também melhora a precisão do LLM ao fornecer uma entrada mais limpa e menos ruidosa.

5. Processamento de Dados em Ambiente e Segurança

Uma das vantagens críticas de usar um LLM local como o LLaMA 3 (via Ollama) é que o processamento de dados ocorre dentro do seu próprio ambiente. Isso é particularmente crucial para lidar com informações sensíveis, pois minimiza o risco de exposição de dados que pode ocorrer ao enviar dados para APIs externas ou serviços em nuvem para processamento. Manter os dados capturados e o LLM dentro da sua infraestrutura proporciona maior controle e aumenta a segurança e a privacidade dos dados.

Pré-requisitos para Extração com LLaMA 3

Antes de embarcar na sua jornada de web scraping com LLaMA 3, garanta que você tenha os seguintes componentes e conhecimentos básicos em vigor:

• Python 3: A principal linguagem de programação para este guia. Embora um conhecimento básico de Python seja suficiente, familiaridade com conceitos de web scraping será benéfica.
• Sistema Operacional Compatível: O LLaMA 3 via Ollama suporta macOS (macOS 11 Big Sur ou posterior), Linux e Windows (Windows 10 ou posterior).
• Recursos de Hardware Adequados: Os requisitos de recursos dependem do tamanho do modelo LLaMA 3 que você escolher. Modelos menores (por exemplo, llama3.1:8b) são leves e podem rodar na maioria dos laptops modernos (aproximadamente 4,9 GB de espaço em disco e 6-8 GB de RAM). Modelos maiores (por exemplo, 70B ou 405B) exigem significativamente mais memória e poder computacional, adequados para máquinas mais robustas ou servidores dedicados.

Configurando Seu Ambiente LLaMA 3 com Ollama

Ollama é uma ferramenta indispensável que simplifica o processo de download, configuração e execução de grandes modelos de linguagem localmente. Ela abstrai grande parte da complexidade associada à implantação de LLM, permitindo que você se concentre na extração de dados.

1. Instalando o Ollama

Para começar com o Ollama:

1. Visite o site oficial do Ollama.
2. Baixe e instale o aplicativo adequado para seu sistema operacional.
3. Passo Crucial: Durante o processo de instalação, o Ollama pode solicitar que você execute um comando no terminal. Não execute este comando ainda. Primeiro selecionaremos a versão do modelo LLaMA apropriada que se alinha com suas capacidades de hardware e seu caso de uso específico.

2. Escolhendo Seu Modelo LLaMA

Selecionar o modelo LLaMA certo é vital para equilibrar desempenho e eficiência. Navegue pela biblioteca de modelos do Ollama para identificar a versão que melhor se adapta às especificações do seu sistema e às necessidades do seu projeto.

Para a maioria dos usuários, llama3.1:8b oferece um equilíbrio ótimo. É leve, altamente capaz e requer aproximadamente 4,9 GB de espaço em disco e 6-8 GB de RAM, tornando-o adequado para execução na maioria dos laptops contemporâneos. Se sua máquina possui um poder de processamento mais substancial e você requer capacidades de raciocínio aprimoradas ou uma janela de contexto maior, considere aumentar para modelos mais extensos como 70B ou até mesmo 405B. Tenha em mente que esses modelos maiores exigem recursos de memória e computação significativamente maiores.

3. Baixando e Executando o Modelo

Depois de escolher seu modelo, você pode baixá-lo e inicializá-lo. Por exemplo, para baixar e executar o modelo llama3.1:8b, execute o seguinte comando no seu terminal:

ollama run llama3.1:8b

Ollama fará o download do modelo. Após o download bem-sucedido, você verá um prompt interativo simples:

>>> Envie uma mensagem (/? para ajuda)

Para verificar se o modelo está instalado e responsivo corretamente, você pode enviar uma consulta rápida:

>>> quem é você?
Eu sou LLaMA, *um assistente de IA desenvolvido pela Meta AI...*

Uma resposta similar à acima confirma que seu modelo LLaMA está configurado corretamente. Para sair do prompt interativo, digite /bye.

4. Iniciando o Servidor Ollama

Para que seu script de web scraping interaja com LLaMA 3, o servidor Ollama deve estar rodando em segundo plano. Abra uma nova janela de terminal e execute:

ollama serve

Este comando inicia uma instância local do Ollama, geralmente acessível em http://127.0.0.1:11434/. É imperativo manter esta janela de terminal aberta, pois o servidor deve permanecer ativo para suas operações de scraping. Você pode confirmar o status do servidor acessando a URL no seu navegador; você deve ver a mensagem "Ollama está rodando."

Construindo um Web Scraper Potencializado por LLM: Um Fluxo de Trabalho em Múltiplas Fases

Construir um web scraper robusto, especialmente para sites complexos com conteúdo dinâmico e rigorosas proteções contra bots, requer uma abordagem sofisticada. Nosso scraper potencializado por LLaMA emprega um fluxo de trabalho inteligente e em múltiplas fases projetado para superar as limitações dos métodos tradicionais e maximizar a eficiência da extração de dados. Este fluxo de trabalho é particularmente eficaz para alvos desafiadores, como sites de e-commerce, que frequentemente implementam defesas avançadas.

Aqui está uma divisão do fluxo de trabalho em múltiplas fases alimentado por IA:

1. Automação de Navegador: Utilize um navegador sem interface (por exemplo, Selenium) para carregar a página da web alvo, renderizar todo o conteúdo dinâmico (JavaScript, chamadas AJAX) e simular interações semelhantes às humanas.
2. Extração de HTML: Após a página ser completamente renderizada, identifique e extraia o contêiner HTML específico que contém os detalhes do produto desejado ou informações relevantes. Esta etapa foca em isolar a seção mais pertinente da página.
3. Conversão para Markdown: Converta o HTML extraído em um formato Markdown limpo e conciso. Essa otimização crucial reduz significativamente a contagem de tokens, tornando a entrada mais eficiente para o LLM e melhorando a velocidade e a precisão do processamento.
4. Processamento do LLM: Empregue um prompt cuidadosamente elaborado e estruturado com LLaMA 3 para extrair dados JSON limpos e estruturados do conteúdo Markdown. A compreensão contextual do LLM é fundamental aqui.
5. Manipulação da Saída: Armazene os dados JSON extraídos em um formato persistente (por exemplo, um arquivo JSON ou um banco de dados) para uso, análise ou integração subsequente em outros sistemas.

Essa abordagem modular garante que cada etapa seja otimizada para sua tarefa específica, contribuindo para uma solução de raspagem altamente eficaz e resiliente. Embora esses exemplos usem principalmente Python pela sua simplicidade e ampla adoção em ciência de dados, resultados semelhantes podem ser alcançados com outras linguagens de programação, como JavaScript.

Passo 1 – Instalar Bibliotecas Necessárias

Comece instalando as bibliotecas Python necessárias. Abra seu terminal ou prompt de comando e execute o seguinte comando:

pip install requests selenium webdriver-manager markdownify

Vamos entender brevemente o papel de cada biblioteca:

• requests: Uma biblioteca Python fundamental para fazer requisições HTTP. Será usada para enviar chamadas de API para sua instância local do Ollama para o processamento LLM.
• selenium: Uma ferramenta poderosa para automação de navegadores da web. É essencial para interagir com sites pesados em JavaScript, renderizando conteúdo dinâmico e simulando o comportamento do usuário.
• webdriver-manager: Simplifica a configuração do Selenium, baixando e gerenciando automaticamente a versão correta do ChromeDriver (ou de outro driver de navegador), eliminando a configuração manual.
• markdownify: Uma utilidade para converter conteúdo HTML em Markdown, um passo crítico para otimizar a entrada do LLM.

Passo 2 – Inicializar o Navegador Sem Cabeça

Configurar um navegador sem cabeça com Selenium é o primeiro passo programático. Um navegador sem cabeça opera sem uma interface gráfica do usuário, tornando-o eficiente para tarefas automatizadas. O seguinte código Python inicializa um navegador Chrome em modo sem cabeça:

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from webdriver_manager.chrome import ChromeDriverManager

options = Options()
options.add_argument("--headless=new")
options.add_argument("--no-sandbox")  # Necessário para alguns ambientes
options.add_argument("--disable-dev-shm-usage")  # Supera problemas de recursos limitados
options.add_argument("--disable-gpu") # Aplicável somente ao sistema operacional Windows
options.add_argument("--window-size=1920,1080") # Define um tamanho de janela consistente
options.add_argument("--ignore-certificate-errors") # Ignora erros de certificado
options.add_argument("--disable-extensions") # Desativa extensões
options.add_argument("--disable-infobars") # Desativa infobars
options.add_argument("--disable-browser-side-navigation") # Desativa a navegação lateral do navegador
options.add_argument("--disable-features=VizDisplayCompositor") # Desativa VizDisplayCompositor
options.add_argument("--blink-settings=imagesEnabled=false") # Desativa imagens para carregamento mais rápido

driver = webdriver.Chrome(
    service=Service(ChromeDriverManager().install()),
    options=options
)

Essas linhas options.add_argument são cruciais para configurar o navegador sem cabeça para um desempenho de raspagem otimizado e minimizar os riscos de detecção. Elas desativam várias funcionalidades que muitas vezes são desnecessárias para raspagem e podem consumir recursos ou revelar automação.

Passo 3 – Extrair o HTML do Produto

Assim que o navegador sem cabeça estiver inicializado, o próximo passo é navegar até a URL de destino e extrair o conteúdo HTML relevante. Para sites complexos como a Amazon, os detalhes do produto são frequentemente renderizados dinamicamente e contidos em elementos HTML específicos. Usaremos o WebDriverWait do Selenium para garantir que o elemento alvo esteja totalmente carregado antes de tentar extrair seu conteúdo.

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

wait = WebDriverWait(driver, 15)
product_container = wait.until(
    EC.presence_of_element_located((By.ID, "ppd"))
)

# Extrair o HTML completo do contêiner do produto
page_html = product_container.get_attribute("outerHTML")

Essa abordagem oferece duas vantagens significativas:

• Tratamento de Conteúdo Dinâmico: Aguarda explicitamente o conteúdo renderizado por JavaScript (como preços, avaliações e disponibilidade) aparecer na página, garantindo que você capture as informações completas e atualizadas.
• Extração Direcionada: Focando em um contêiner específico (por exemplo, <div id="ppd"> para páginas de produtos da Amazon), você extrai apenas a seção relevante do HTML, ignorando efetivamente elementos extrâneos como cabeçalhos, rodapés, barras laterais e anúncios. Isso reduz a quantidade de dados processados pelo LLM, resultando em melhor eficiência e precisão.

Passo 4 – Converter HTML para Markdown

Como discutido anteriormente, converter o HTML extraído em Markdown é uma etapa crítica de otimização. HTML bruto, especialmente de páginas da web profundamente aninhadas e complexas, é altamente ineficiente para os LLMs processarem devido à sua verbosidade e alto número de tokens. Markdown, sendo um formato de texto muito mais limpo e plano, reduz dramaticamente o número de tokens enquanto retém o conteúdo e a estrutura essenciais.

Para ilustrar o impacto, considere que o HTML típico de uma página de produto da Amazon pode conter cerca de 270.000 tokens. A versão equivalente em Markdown, no entanto, pode ser tão concisa quanto ~11.000 tokens. Essa notável redução de 96% oferece benefícios substanciais:

• Eficiência de Custos: Menos tokens se traduzem diretamente em menores custos de API ou computacionais, especialmente ao usar serviços de LLM pagos ou ao executar modelos em hardware com recursos limitados.
• Processamento Mais Rápido: Um tamanho de entrada menor significa que o LLM pode processar os dados muito mais rapidamente, levando a tempos de resposta mais rápidos para suas operações de raspagem.
• Melhoria na Precisão: Entradas mais limpas e menos ruidosas ajudam o LLM a se concentrar nas informações relevantes, levando a uma extração de dados mais precisa e exata. O modelo é menos propenso a ser distraído por tags ou atributos HTML irrelevantes.

Aqui está como realizar a conversão de HTML para Markdown em Python usando a biblioteca markdownify:

from markdownify import markdownify as md

clean_text = md(page_html, heading_style="ATX")

O argumento heading_style="ATX" garante que os cabeçalhos do Markdown sejam gerados usando o estilo ATX (por exemplo, # Cabeçalho 1), que é geralmente bem compreendido pelos LLMs.

Passo 5 – Criar o Prompt de Extração de Dados

O prompt que você fornece ao LLM é fundamental para obter uma saída JSON estruturada e consistente. Um prompt bem projetado orienta o LLM a entender seu papel, a tarefa em questão e o exato formato exigido para a saída. O seguinte prompt instrui o LLaMA 3 a agir como um expert em extração de dados de produtos da Amazon e a retornar apenas JSON válido com um esquema predefinido:

PRODUCT_DATA_EXTRACTION_PROMPT: Final[str] = (
    "Você é um expert em extração de dados de produtos da Amazon. Sua "
    "tarefa é extrair dados de produtos do conteúdo fornecido. "
    "\n\nRetorne APENAS JSON válido com EXATAMENTE os seguintes "
    "campos e formatos:\n\n"\
    "{\n"
    "    'title': "string" - o título do produto,\n"
    "    'price': number - o preço atual (valor numérico "
    "apenas),\n"
    "    'original_price': number ou null - o preço "
    "original se disponível,\n"
    "    'discount': number ou null - a porcentagem de desconto "
    "se disponível,\n"
    "    'rating': number ou null - a classificação média (escala de 0-5),\n"
    "    'review_count': number ou null - total de "
    "avaliações,\n"
    "    'description': "string" - descrição principal do "
    "produto,\n"
    "    'features': ["string"] - lista de características em "
    "pontos,\n"
    "    'availability': "string" - status de estoque,\n"
    "    'asin': "string" - ID da Amazon de 10 caracteres"\n"
    "}\n\nRetorne APENAS o JSON sem qualquer texto adicional."
)

Este prompt é altamente específico, deixando pouca margem para ambiguidade. Ele define:

• Papel: "expert em extração de dados de produtos da Amazon."
• Tarefa: "extrair dados de produtos do conteúdo fornecido."
• Formato de Saída: Declara explicitamente para retornar "APENAS JSON válido" e fornece a estrutura exata e os tipos de dados para cada campo (por exemplo, title como string, price como number, features como uma lista de strings).
• Restrição: "Retorne APENAS o JSON sem qualquer texto adicional." Isso é crucial para evitar que o LLM gere preenchimentos conversacionais ou explicações, garantindo uma saída JSON limpa que pode ser analisada diretamente.

Passo 6 – Chamar a API do LLM

Com seu servidor Ollama em execução localmente, você pode agora enviar o texto Markdown preparado e o prompt de extração para sua instância do LLaMA 3 via sua API HTTP. A biblioteca requests em Python é ideal para esse propósito.

import requests
import json

response = requests.post(
    "http://localhost:11434/api/generate",
    json={
        "model": "llama3.1:8b",
        "prompt": f"{PRODUCT_DATA_EXTRACTION_PROMPT}\n{clean_text}",
        "stream": False,
        "format": "json",
        "options": {
            "temperature": 0.1,
            "num_ctx": 12000,
        },
        "timeout": 250,
    }
)

raw_output = response.json()["response"].strip()
product_data = json.loads(raw_output)

Vamos detalhar os principais parâmetros na chamada da API:

• model: Especifica a versão do modelo LLaMA a ser utilizada (por exemplo, llama3.1:8b).
• prompt: Este é o prompt combinado, concatenando seu PRODUCT_DATA_EXTRACTION_PROMPT com o clean_text (conteúdo em Markdown) que o LLM precisa processar.
• stream: Defina como False para receber a resposta completa após o processamento, em vez de um fluxo contínuo de tokens. Isso é apropriado para o processamento em lote da extração de dados.
• format: Definido crucialmente como "json". Isso instrui o Ollama a formatar sua saída como um objeto JSON, alinhando-se com nossa saída de dados estruturada desejada.
• options:
  • temperature: Definido como 0.1. Uma temperatura mais baixa (mais próxima de 0) torna a saída do LLM mais determinística e menos criativa, o que é ideal para a extração de dados estruturados onde a consistência é fundamental.
  • num_ctx: Define o comprimento máximo do contexto em tokens. O artigo original sugere que 12.000 tokens são suficientes para a maioria das páginas de produtos da Amazon. É importante definir esse valor de forma apropriada com base na extensão esperada do seu conteúdo em Markdown. Embora aumentar esse valor permita lidar com entradas mais longas, também aumenta o uso de RAM e desacelera o processamento. Aumente o limite de contexto apenas se suas páginas de produtos forem excepcionalmente longas ou se você tiver recursos computacionais para suportá-lo.
• timeout: Define o tempo máximo em segundos para esperar pela resposta do LLM.

Após receber a resposta, response.json()["response"].strip() extrai a string JSON bruta da saída do LLM, e json.loads(raw_output) analisa essa string em um dicionário Python, tornando os dados extraídos facilmente acessíveis.

Passo 7 – Salvar os Resultados

O passo final no processo de extração de dados é salvar os dados estruturados do produto em um arquivo persistente. O formato JSON é altamente adequado para isso, pois é legível por humanos e facilmente analisável por outras aplicações.

with open("product_data.json", "w", encoding="utf-8") as f:
    json.dump(product_data, f, indent=4, ensure_ascii=False)

Esse fragmento de código abre um arquivo chamado product_data.json em modo de escrita ("w") com codificação UTF-8 para lidar com vários caracteres. json.dump() então escreve o dicionário product_data neste arquivo. O argumento indent=4 garante que a saída JSON seja bem formatada com uma indentação de 4 espaços, tornando-a mais legível, e ensure_ascii=False assegura que caracteres não ASCII (como símbolos especiais ou caracteres internacionais) sejam escritos diretamente em vez de serem escapados.

Passo 8: Executar o Script

Para executar seu web scraper completo alimentado por LLaMA, você normalmente terá um bloco de execução principal que define a URL de destino e chama sua função de scraping. Aqui está um exemplo simplificado:

if __name__ == "__main__":
    url = "<https://www.amazon.com/Black-Office-Chair-Computer-Adjustable/dp/B00FS3VJO>"
    # Chame sua função para raspar e extrair dados do produto
    scrape_amazon_product(url)

Em um cenário do mundo real, você encapsularia os passos da captura de HTML à salvamento em JSON dentro de uma função (por exemplo, scrape_amazon_product) e então chamaria essa função com a URL do produto desejado.

Passo 9 – Exemplo Completo de Código

Para uma implementação completa de ponta a ponta, aqui está o script Python completo combinando todos os passos discutidos:

import json
import logging
import time
from typing import Final, Optional, Dict, Any

import requests
from markdownify import markdownify as html_to_md
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
from webdriver_manager.chrome import ChromeDriverManager

# Configure o logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.StreamHandler()]
)

def initialize_web_driver(headless: bool = True) -> webdriver.Chrome:
    """Inicializa e retorna uma instância configurada do Chrome WebDriver."""
    options = Options()
    options.add_argument("--headless=new")
    options.add_argument("--no-sandbox")  # Necessário para alguns ambientes
    options.add_argument("--disable-dev-shm-usage")  # Supera problemas de recursos limitados
    options.add_argument("--disable-gpu") # Aplicável apenas ao Windows
    options.add_argument("--window-size=1920,1080") # Define um tamanho de janela consistente
    options.add_argument("--ignore-certificate-errors") # Ignora erros de certificado
    options.add_argument("--disable-extensions") # Desativa extensões
    options.add_argument("--disable-infobars") # Desativa informações úteis
    options.add_argument("--disable-browser-side-navigation") # Desativa navegação lateral do navegador
    options.add_argument("--disable-features=VizDisplayCompositor") # Desativa o VizDisplayCompositor

options.add_argument("--blink-settings=imagesEnabled=false") # Desativar imagens para carregamento mais rápido

    service = Service(ChromeDriverManager().install())
    return webdriver.Chrome(service=service, options=options)


def fetch_product_container_html(product_url: str) -> Optional[str]:
    """Recuperar o conteúdo HTML do container de detalhes do produto da Amazon."""
    driver = initialize_web_driver()
    try:
        logging.info(f"Acessando a página do produto: {product_url}")
        driver.set_page_load_timeout(15)
        driver.get(product_url)

        # Aguarde o container do produto aparecer
        wait = WebDriverWait(driver, 5)
        product_container = wait.until(
            EC.presence_of_element_located((By.ID, "ppd"))
        )
        return product_container.get_attribute("outerHTML")
    except Exception as e:
        logging.error(f"Erro ao recuperar detalhes do produto: {str(e)}")
        return None
    finally:
        driver.quit()


def extract_product_data_via_llm(markdown_content: str) -> Optional[Dict[str, Any]]:
    """Extrair dados estruturados do produto a partir do texto em markdown usando a API LLM."""
    try:
        response = requests.post(
            LLM_API_CONFIG["endpoint"],
            json={
                "model": LLM_API_CONFIG["model"],
                "prompt": f"{PRODUCT_DATA_EXTRACTION_PROMPT}\n{markdown_content}",
                "stream": LLM_API_CONFIG["stream"],
                "format": LLM_API_CONFIG["format"],
                "options": LLM_API_CONFIG["options"],
                "timeout": LLM_API_CONFIG["timeout_seconds"],
            }
        )
        response.raise_for_status()  # Levantar HTTPError para respostas ruins (4xx ou 5xx)
        raw_output = response.json()["response"].strip()
        return json.loads(raw_output)
    except requests.exceptions.RequestException as e:
        logging.error(f"Falha na solicitação da API LLM: {e}")
        return None
    except json.JSONDecodeError as e:
        logging.error(f"Falha ao decodificar JSON da resposta LLM: {e}")
        return None


def scrape_amazon_product(url: str) -> None:
    """Orquestra o processo de raspagem e extração de dados para uma página de produto da Amazon."""
    logging.info(f"Iniciando o processo de raspagem para: {url}")

    # Etapa 1: Buscar conteúdo HTML
    html_content = fetch_product_container_html(url)
    if not html_content:
        logging.error("Falha ao buscar conteúdo HTML. Saindo.")
        return

    # Etapa 2: Converter HTML para Markdown
    markdown_content = html_to_md(html_content, heading_style="ATX")
    logging.info("HTML convertido para Markdown.")

    # Etapa 3: Extrair dados via LLM
    product_data = extract_product_data_via_llm(markdown_content)
    if not product_data:
        logging.error("Falha ao extrair dados do produto via LLM. Saindo.")
        return

    # Etapa 4: Salvar resultados
    output_filename = "product_data.json"
    try:
        with open(output_filename, "w", encoding="utf-8") as f:
            json.dump(product_data, f, indent=4, ensure_ascii=False)
        logging.info(f"Dados do produto salvos com sucesso em {output_filename}")
    except IOError as e:
        logging.error(f"Falha ao salvar dados do produto em arquivo: {e}")


# Constantes de configuração
LLM_API_CONFIG: Final[Dict[str, Any]] = {
    "endpoint": "http://localhost:11434/api/generate",
    "model": "llama3.1:8b",
    "temperature": 0.1,
    "num_ctx": 12000,
    "stream": False,
    "format": "json",
    "timeout_seconds": 220,
}

DEFAULT_PRODUCT_DATA: Final[Dict[str, Any]] = {
    "title": "",
    "price": 0.0,
    "original_price": None,
    "discount": None,
    "rating": None,
    "review_count": None,
    "description": "",
    "features": [],
    "availability": "",
    "asin": "",
}

PRODUCT_DATA_EXTRACTION_PROMPT: Final[str] = (
    "Você é um especialista em extração de dados de produtos da Amazon. Sua "
    "tarefa é extrair dados de produtos do conteúdo fornecido. "
    "\n\nRetorne APENAS JSON válido com EXATAMENTE os seguintes "
    "campos e formatos:\n\n"\
    "{\n"
    "    'title': \"string\" - o título do produto,\n"
    "    'price': número - o preço atual (valor numérico "
    "apenas),\n"
    "    'original_price': número ou nulo - o preço original "
    "se disponível,\n"
    "    'discount': número ou nulo - a porcentagem de desconto "
    "se disponível,\n"
    "    'rating': número ou nulo - a avaliação média (escala de 0-5),\n"
    "    'review_count': número ou nulo - total de "
    "avaliações,\n"
    "    'description': \"string\" - descrição principal do produto,\n"
    "    'features': [\"string\"] - lista de características em formato de tópicos,\n"
    "    'availability': \"string\" - status de estoque,\n"
    "    'asin': \"string\" - ID da Amazon com 10 caracteres\n"
    "}\n\nRetorne SOMENTE o JSON sem nenhum texto adicional."
)

if __name__ == "__main__":
    url = "<https://www.amazon.com/Black-Office-Chair-Computer-Adjustable/dp/B00FS3VJO>"
    scrape_amazon_product(url)

A extração de dados da web, especialmente em grande escala, é uma batalha constante contra sofisticados sistemas anti-bot. Os sites empregam diversas técnicas para detectar e bloquear solicitações automatizadas, visando proteger seus dados e infraestrutura. Essas medidas incluem:

• Bloqueio de IP: Identificação e inclusão em lista negra de endereços IP que exibem comportamento suspeito (por exemplo, muitas solicitações de um único IP em um curto período).
• CAPTCHAs: Apresentação de desafios (por exemplo, reCAPTCHA, hCaptcha) que são fáceis para humanos resolverem, mas difíceis para bots automatizados.
• Análise de User-Agent: Detecção de User-Agents não associados a navegadores ou desatualizados, o que pode indicar um cliente automatizado.
• Impressão Digital do Navegador: Análise de características únicas de um navegador (por exemplo, plugins instalados, resolução de tela, fontes) para identificar e bloquear ferramentas automatizadas como a configuração padrão do Selenium.
• Limitação de Taxa: Restrição do número de solicitações de uma única fonte em um determinado período de tempo.
• Armadilhas: Links ou elementos ocultos projetados para capturar bots que seguem cegamente todos os links em uma página.
• Análise Comportamental: Monitoramento de movimentos do mouse, padrões de rolagem e velocidades de digitação para diferenciar interações humanas e automatizadas.

Embora a abordagem LLaMA 3 melhore a resiliência ao compreender o contexto do conteúdo, ela não contorna intrinsecamente essas defesas anti-bot de baixo nível. É aqui que uma ferramenta especializada como o Scrapeless Scraping Browser se torna indispensável. Ao contrário de navegadores sem cabeça de uso geral, o Scrapeless Scraping Browser é projetado especificamente para imitar o comportamento de navegação humano e contornar uma ampla gama de proteções anti-bot, tornando-o uma escolha superior para a extração de dados robusta da web.

Por que escolher o Scrapeless Scraping Browser em vez da oferta da Bright Data?

Embora a Bright Data ofereça um

Scraping Browser, o Scrapeless fornece uma solução mais centrada no desenvolvedor e flexível, que é particularmente adequada para fluxos de trabalho de extração de dados potenciada por IA. Aqui está o porquê de o Scrapeless Scraping Browser ser a escolha recomendada:

• Personalização Avançada de Impressões Digitais: O Scrapeless oferece personalização profunda de impressões digitais do navegador, incluindo User-Agent, características do dispositivo e outros parâmetros. Isso permite que você crie perfis de navegador altamente realistas que são virtualmente indistinguíveis dos de usuários reais, reduzindo significativamente o risco de detecção.
• Rede de Proxy Globalmente Distribuída: Possui uma rede de proxy globalmente distribuída que permite que você roteie suas solicitações através de um vasto conjunto de IPs residenciais e móveis. Isso contorna efetivamente o bloqueio baseado em IP e a limitação de taxa, permitindo que você extraia dados em grande escala sem ser detectado.
• Evasão e Stealth Poderadas por IA: O Scrapeless Scraping Browser é construído pensando em desenvolvedores de IA. Ele incorpora suporte para modo stealth dinâmico e outras técnicas de evasão impulsionadas por IA que se adaptam às medidas anti-bot do site alvo em tempo real. Essa abordagem proativa garante uma taxa de sucesso mais alta para suas operações de extração de dados.
• Integração Sem Costura com Fluxos de Trabalho de IA: O Scrapeless é projetado para fácil integração com fluxos de trabalho baseados em IA e LLM. Sua API é intuitiva e bem documentada, tornando simples sua incorporação em seus scripts Python e outras ferramentas de automação. Essa integração sem costura é crucial para construir soluções eficientes e escaláveis de extração de dados potenciada por IA.
• Custo-Efetividade e Flexibilidade: O Scrapeless oferece um modelo de preços mais flexível e, frequentemente, mais econômico em comparação com soluções voltadas para empresas, como a Bright Data. Isso o torna uma opção acessível, mas poderosa, para desenvolvedores individuais, pesquisadores e pequenas a médias empresas.

Ao combinar a compreensão contextual do LLaMA 3 com as avançadas capacidades de evasão de bots do Scrapeless Scraping Browser, você pode construir uma solução de extração de dados da web verdadeiramente formidável que é tanto inteligente quanto resiliente.

Próximos Passos e Soluções Avançadas

Uma vez que você tenha dominado os fundamentos da extração de dados da web potenciada por LLaMA 3, pode estender as capacidades do seu extractor e explorar implementações mais avançadas. Aqui estão algumas melhorias e soluções alternativas a considerar:

• Tornar o Script Reutilizável: Melhore seu script para aceitar a URL-alvo e o prompt de extração de dados como argumentos de linha de comando. Isso tornará seu extractor mais flexível e reutilizável para diferentes sites e tarefas de extração de dados.
• Proteja suas Credenciais: Se você está usando um serviço comercial como o Scrapeless Scraping Browser, é crucial lidar com suas chaves de API e credenciais de forma segura. Armazene-as em um arquivo .env e use uma biblioteca como python-dotenv para carregá-las em seu script, evitando a codificação em hard de informações sensíveis em seu código-fonte.
• Implementar Suporte a Múltiplas Páginas: Para websites com conteúdo paginado (por exemplo, resultados de busca em e-commerce, arquivos de notícias), implemente lógica para navegar por várias páginas. Isso geralmente envolve identificar o botão ou padrão de URL "próxima página" e iterar pelas páginas até que todos os dados desejados sejam coletados.
• Raspar uma Maior Variedade de Websites: Aproveite os poderosos recursos de anti-detecção do Scrapeless Scraping Browser para raspar outras plataformas complexas de e-commerce, sites de redes sociais e aplicações web ricas em dados.
• Extrair Dados de Serviços do Google: Construa raspadores dedicados para serviços do Google como Google Flights, Google Search e Google Trends. Alternativamente, para resultados de mecanismos de busca, considere usar uma API SERP especializada, que pode fornecer dados estruturados prontos para uso de todos os principais mecanismos de busca, economizando o esforço de construir e manter seu próprio raspador.

Se você prefere soluções gerenciadas ou deseja explorar outros métodos impulsionados por LLM, as seguintes opções também podem ser adequadas:

• Raspagem com Gemini: Explore os modelos Gemini do Google para capacidades de extração de dados semelhantes impulsionadas por IA.
• Raspagem com Perplexity: A Perplexity AI também oferece poderosos modelos de linguagem que podem ser adaptados para tarefas de raspagem web.
• Construa um Raspador de IA com Crawl4AI e DeepSeek: Investigue outras ferramentas e modelos de raspagem com IA especializadas, como Crawl4AI e DeepSeek, que são projetadas para extração inteligente de dados.

Conclusão: O Futuro da Raspagem Web é Inteligente

Este guia forneceu um roteiro abrangente para construir raspadores web resilientes e inteligentes usando LLaMA 3. Ao combinar as capacidades de raciocínio contextual de grandes modelos de linguagem com ferramentas e técnicas avançadas de raspagem, você pode superar as limitações dos métodos tradicionais e extrair dados estruturados até mesmo dos websites mais complexos e bem defendidos com esforço mínimo.

A principal conclusão é que o futuro da raspagem web não se trata apenas de automação, mas de automação inteligente. A capacidade do LLaMA 3 de entender o conteúdo semanticamente, combinada com a sofisticada evasão de bots de ferramentas como Scrapeless Scraping Browser, representa uma mudança de paradigma na forma como abordamos a extração de dados. Esta poderosa combinação capacita desenvolvedores e pesquisadores a construir raspadores que são não apenas mais eficazes, mas também mais adaptáveis e resilientes diante de um cenário web em constante evolução.

Ao iniciar sua jornada de raspagem web impulsionada por IA, lembre-se de que as considerações éticas são primordiais. Sempre respeite os termos de serviço dos websites que você raspa, evite sobrecarregar seus servidores com solicitações excessivas e esteja atento às regulamentações de privacidade de dados. Ao adotar uma abordagem responsável e inteligente, você pode desbloquear o vasto potencial dos dados web para impulsionar a inovação, informar decisões e criar valor em um mundo orientado a dados.