Raspagem da Web com tecnologia de IA com o llm-scraper

Neste guia, você aprenderá:

• O que é o llm-scraper
• Como usá-lo em um passo a passo
• Como usá-lo para geração de código
• Quais são as principais alternativas para a raspagem baseada em LLM
• Suas principais limitações e como superá-las

Vamos mergulhar de cabeça!

O que é o llm-scraper?

O llm-scraper é uma biblioteca TypeScript que usa LLMs para extrair dados estruturados de qualquer página da Web.
Em vez de escrever uma lógica de análise personalizada para cada site, basta definir um esquema, e o pacote emprega um LLM para preenchê-lo de forma inteligente, analisando o conteúdo da página.

A biblioteca foi lançada pela primeira vez em meados de 2024, portanto, ainda é bastante nova. No entanto, ela já ganhou mais de 4.000 estrelas no GitHub, o que mostra a rapidez com que está se tornando popular:

É ideal para sites dinâmicos ou inconsistentes (como comércio eletrônico), nos quais os raspadores tradicionais costumam falhar. Nesses cenários, o LLM scraping se destaca.

Em detalhes, os principais recursos suportados pelo llm-scraper são:

• Integração com vários provedores de LLM: Funciona com modelos locais (como Ollama ou GGUF) e provedores de nuvem (como OpenAI e Vercel AI SDK).
• Extração de dados baseada em esquema: Defina o que você deseja extrair usando os esquemas Zod para uma forte estrutura e validação.
• Segurança total de tipos: Projetado para TypeScript, para que você tenha uma verificação completa de tipos no momento da compilação.
• Criado com base no Playwright: Usa o Playwright como base para controlar o navegador e buscar o conteúdo da página.
• Suporte a streaming: Pode transmitir objetos durante a raspagem em vez de aguardar a conclusão da extração completa.
• Geração de código: Pode gerar código de raspagem dinamicamente com base em seu esquema e destino.
• Várias opções de formatação do conteúdo da página: Você pode escolher como enviar o conteúdo da página para o LLM

Como usar o llm-scraper para raspagem da Web

Nesta seção do tutorial, você aprenderá a usar a biblioteca llm-scraper para criar um raspador alimentado por IA. O site de destino será uma página de produto de comércio eletrônico do site ToScrape:

Esse é um ótimo exemplo, pois a raspagem de sites de comércio eletrônico pode ser complicada. Suas estruturas de página mudam com frequência, e produtos diferentes podem ter layouts e informações diferentes. Por isso, escrever uma lógica de análise estática é difícil e não é muito eficaz. Portanto, a IA pode definitivamente ajudar.

Siga as etapas abaixo para criar um Scraper com LLM!

Pré-requisitos

Para seguir este tutorial, você precisará de:

• Node.js instalado em seu computador
• Uma chave de API da OpenAI (ou uma chave de um provedor semelhante, como o Groq)
• Conhecimento básico de TypeScript e programação assíncrona

Etapa 1: Configuração do projeto

Antes de começar, verifique se você tem a versão LTS mais recente do Node.js instalada localmente. Caso contrário, faça o download no site oficial e instale-a.

Agora, crie um projeto para seu raspador e navegue até ele no terminal:

mkdir llm-scraper-project
cd llm-scraper-project

Em seu projeto, execute o seguinte comando para inicializar um projeto Node.js em branco:

npm init -y

Abra o arquivo package.json criado pelo comando acima e verifique se ele contém:

"type": "module"

Carregue a pasta do projeto llm-scraper-project em seu IDE TypeScript favorito, como o Visual Studio Code.

Em seguida, instale o TypeScript como uma dependência de desenvolvimento:

npm install typescript --save-dev

Com o TypeScript instalado, inicialize seu projeto TypeScript executando:

npx tsc --init

Um arquivo tsconfig.json aparecerá na pasta do seu projeto. Abra-o e substitua-o por:

{
  "compilerOptions": {
    "module": "ESNext",
    "target": "ESNext",
    "moduleResolution": "node",
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "strict": true,
    "skipLibCheck": true
  }
}

Agora, adicione um arquivo scraper.ts ao seu projeto:

Esse arquivo logo conterá sua lógica de extração de dados do llm-scraper. Como o script usará a lógica assíncrona do TypeScript, inicialize uma função assíncrona dentro dele:

async function llmScraping() {
  // your LLM scraping logic...
}

llmScraping()

Maravilhoso! Você está totalmente configurado e pronto para começar a criar seu scraper com IA.

Etapa 2: Instalar as bibliotecas extraídas

Para funcionar, o llm-scraper depende das duas bibliotecas adicionais a seguir:

• Zod: Uma biblioteca de validação e declaração de esquema TypeScript-first.
• Playwright: Uma biblioteca para automatizar os navegadores Chromium, Firefox e WebKit com uma única API.

Instale-os junto com o llm-scraper usando o seguinte comando:

npm install zod playwright llm-scraper

O Playwright requer algumas dependências adicionais (como os binários do navegador). Instale-os com:

npx playwright install

Agora, importe o Zod e o Playwright no scraper.ts:

import { z } from "zod"
import { chromium } from "playwright"
import LLMScraper from "llm-scraper"

Excelente! Agora você tem todas as bibliotecas necessárias para começar a usar o LLM Web scraping no TypeScript.

Etapa 3: Configurar o OpenAI

O llm-scraper oferece suporte a vários provedores de LLM, incluindo OpenAI, Groq, Ollama e GGUF. Neste caso, usaremos o OpenAI. Se ainda não tiver feito isso, certifique-se de obter sua chave de API do OpenAI.

Primeiro, instale o cliente JavaScript da OpenAI:

npm install @ai-sdk/openai

Em seguida, importe-o em seu código e use-o para inicializar o modelo LLM dentro da função llmScraping():

// other imports...
import { openai } from "@ai-sdk/openai"

// ...

const llm = openai.chat("gpt-4o")

Para obter uma integração diferente, consulte a documentação oficial do llm-scraper`.

Para evitar a codificação da chave OpenAI em seu código, instale o dotenv:

npm install dotenv

Importe dotenv em seu arquivo scraper.ts e chame dotenv.config() para carregar as variáveis de ambiente:

// other imports...
import * as dotenv from "dotenv"

// ...

dotenv.config()

Isso permite que você carregue variáveis de ambiente, como a chave da API da OpenAI, a partir de arquivos .env. Portanto, adicione um arquivo .env ao seu projeto:

Abra-o e adicione sua chave de API da OpenAI da seguinte maneira:

OPENAI_API_KEY="<YOUR_OPENAI_KEY>"

Substituir pelo valor de sua chave Open AI

Observe que não é necessário ler manualmente a variável em seu código. Isso ocorre porque o @ai-sdk/openai tenta ler automaticamente a variável de ambiente OPENAI_KEY.

Incrível! Integração do LLM concluída.

Etapa 4: Conecte-se à página de destino

O llm-scraper conta com o Playwright como mecanismo de automação do navegador para extrair o conteúdo HTML das páginas da Web. Para começar, adicione as seguintes linhas de código dentro de llmScraping() para:

1. Inicializar um navegador Chromium
2. Abrir uma nova página
3. Instrua o Playwright a visitar a página de destino

Consiga isso com:

const browser = await chromium.launch()
const page = await browser.newPage()

await page.goto("https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html")

No final, não se esqueça de fechar o navegador e liberar seus recursos:

await page.close()
await browser.close()

Se você não estiver familiarizado com esse processo, leia nosso guia sobre raspagem da Web do Playwright.

Etapa 5: definir o esquema de dados

Agora, o llm-scraper funciona alimentando o modelo LLM subjacente com um prompt – operando no conteúdo extraído da página por meio do Playwright – para extrair dados estruturados conforme definido em um modelo de dados específico.

É aí que entra o Zod, ajudando você a especificar esse modelo de dados no TypeScript. Para entender como deve ser o esquema de seus dados extraídos, abra o site de destino em seu navegador e comece analisando o nível superior da página:

A partir daí, você deve se concentrar na extração dos seguintes dados:

• Título
• Preço
• Status do estoque
• Quantidade
• Descrição

Em seguida, vá para a última seção da página:

Aqui, você terá interesse em:

• UPC (Código Universal de Produto)
• Tipo de produto
• Imposto
• Número de avaliações

Junte tudo isso e você terá o seguinte esquema de produto:

const productSchema = z.object({
  title: z.string().describe("The name of the product"),
  price: z.string().describe("The price of the product, typically formatted as a string like '£19.99'"),
  stock: z.string().describe("The availability status of the product, such as 'In Stock' or 'Out of Stock'"),
  quantity: z.string().describe("The specific quantity of products available in stock"),
  description: z.string().describe("A detailed description of the product, including features and specifications"),
  upc: z.string().describe("The Universal Product Code (UPC) to uniquely identify the product"),
  productType: z.string().describe("The category or type of the product, such as 'Books', 'Clothing', etc."),
  tax: z.string().describe("Information about the applicable tax amount for the product"),
  reviews: z.number().describe("The number of reviews the product has received"),
})

Dica: Não se esqueça de descrever seu esquema, pois isso ajuda o modelo LLM a entender o que ele deve fazer com os dados.

Fantástico! Você está pronto para iniciar a tarefa de raspagem com tecnologia de IA no llm-scraper.

Etapa #6: Executar a tarefa de raspagem

Use a integração LLM que você definiu na Etapa 3 para criar um objeto LLMScraper:

const scraper = new LLMScraper(llm)

Esse é o principal objeto exposto pela biblioteca llm-scraper e é responsável pela execução das tarefas de raspagem com tecnologia de IA.

Em seguida, inicie o raspador da seguinte forma:

const { data } = await scraper.run(page, productSchema, {
  format: "markdown",
})

O parâmetro de formato define como o conteúdo da página é passado para o LLM. Os valores possíveis são:

• "html": O HTML bruto da página.
• "text" (texto): Todo o conteúdo de texto extraído da página.
• "markdown": O conteúdo HTML convertido em Markdown.
• "cleanup" (limpeza): Uma versão limpa do texto extraído da página.
• "image" (imagem): Uma captura de tela da página.

Observação: Você também pode fornecer uma função personalizada para controlar a formatação do conteúdo, se necessário.

Conforme discutido no guia “Why Are the New AI Agents Choosing Markdown Over HTML?” (Por que os novos agentes de IA estão escolhendo Markdown em vez de HTML?), usar o formato Markdown é uma escolha inteligente, pois ajuda a economizar tokens e a acelerar o processo de raspagem.

Por fim, a função scraper.run() retorna um objeto que corresponde ao esquema Zod esperado.

Perfeito! Sua tarefa de raspagem com IA está concluída.

Etapa nº 7: Exportar os dados extraídos

Atualmente, os dados extraídos são armazenados em um objeto JavaScript. Para facilitar o acesso, a análise e o compartilhamento dos dados, exporte-os para um arquivo JSON, conforme abaixo:

const jsonData = JSON.stringify(data, null, 4)
await fs.writeFile("product.json", jsonData, "utf8")

Observe que você não precisa de nenhuma biblioteca externa para isso. Apenas certifique-se de adicionar a seguinte importação na parte superior do arquivo scraper.ts:

import { promises as fs } from "fs"

Etapa #8: Juntar tudo

O arquivo scraper.ts agora deve conter:

import { z } from "zod"
import { chromium } from "playwright"
import LLMScraper from "llm-scraper"
import { openai } from "@ai-sdk/openai"
import * as dotenv from "dotenv"
import { promises as fs } from "fs"

// load the environment variables from the local .env file
dotenv.config()

async function llmScraping() {
  // initialize the LLM engine
  const llm = openai.chat("gpt-4o")

  // launch a browser instance and open a new page
  const browser = await chromium.launch()
  const page = await browser.newPage()

  // navigate to the target e-commerce product page
  await page.goto("https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html")

  // define the product schema
  const productSchema = z.object({
    title: z.string().describe("The name of the product"),
    price: z.string().describe("The price of the product, typically formatted as a string like '£19.99'"),
    stock: z.string().describe("The availability status of the product, such as 'In Stock' or 'Out of Stock'"),
    quantity: z.string().describe("The specific quantity of products available in stock"),
    description: z.string().describe("A detailed description of the product, including features and specifications"),
    upc: z.string().describe("The Universal Product Code (UPC) to uniquely identify the product"),
    productType: z.string().describe("The category or type of the product, such as 'Books', 'Clothing', etc."),
    tax: z.string().describe("Information about the applicable tax amount for the product"),
    reviews: z.number().describe("The number of reviews the product has received"),
  })

  // create a new LLMScraper instance
  const scraper = new LLMScraper(llm)

  // run the LLM scraper
  const { data } = await scraper.run(page, productSchema, {
    format: "markdown", // or "html", "text", etc.
  })

  // conver the scraped data to a JSON string
  const jsonData = JSON.stringify(data, null, 4)
  // populate an output file with the JSON string
  await fs.writeFile("product.json", jsonData, "utf8")

  // close the page and the browser and release their resources
  await page.close()
  await browser.close()
}

llmScraping()

Como você pode ver, o llm-scraper permite que você defina um script de raspagem baseado em JavaScript em poucas linhas de código.

Compile seu script de TypeScript para JavaScript com esse comando:

npx tsc

Um arquivo scraper.js aparecerá na pasta do seu projeto. Execute-o com:

node scraper.js

Quando o script terminar de ser executado, um arquivo chamado product.json aparecerá na pasta do seu projeto.

Abra-o e você verá algo parecido com isto:

{
  "title": "A Light in the Attic",
  "price": "£51.77",
  "stock": "In Stock",
  "quantity": "22",
  "description": "It's hard to imagine a world without A Light in the Attic. This now-classic collection of poetry and drawings from Shel Silverstein celebrates its 20th anniversary with this special edition. Silverstein's humorous and creative verse can amuse the dowdiest of readers. Lemon-faced adults and fidgety kids sit still and read these rhythmic words and laugh and smile and love that Silverstein. Need proof of his genius? Rockabye Rockabye baby, in the treetop Don't you know a treetop Is no safe place to rock? And who put you up there, And your cradle, too? Baby, I think someone down here's Got it in for you. Shel, you never sounded so good.",
  "upc": "a897fe39b1053632",
  "productType": "Books",
  "tax": "£0.00",
  "reviews": 0
}

Esse arquivo contém exatamente as informações exibidas na página do produto que você segmentou. Como você pode ver, os dados foram extraídos sem a necessidade de nenhuma lógica de análise personalizada, graças ao poder dos LLMs. Muito bem!

Extra: Geração de código com o llm-scraper

O llm-scraper também tem a capacidade de gerar a lógica de análise de dados subjacente do Playwright, de acordo com o esquema. Isso é possível graças à função generate().

Veja um exemplo no trecho abaixo:

const { code } = await scraper.generate(page, productSchema)

Como você pode ver, ele usa o objeto de página do Playwright e o esquema Zod e, em seguida, retorna uma string contendo o código do Playwright gerado. Nesse caso, o resultado é:

(function() {
function extractData() {
const title = document.querySelector('h1').innerText;
const price = document.querySelector('.price_color').innerText;
const stockText = document.querySelector('.instock.availability').innerText.trim();
const stock = stockText.includes('In stock') ? 'In Stock' : 'Out of Stock';
const quantityMatch = stockText.match(/\d+/);
const quantity = quantityMatch ? quantityMatch[0] : '0';
const description = document.querySelector('#product_description ~ p').innerText;
const upc = document.querySelector('th:contains("UPC") + td').innerText;
const productType = document.querySelector('th:contains("Product Type") + td').innerText;
const tax = document.querySelector('th:contains("Tax") + td').innerText;
const reviews = parseInt(document.querySelector('th:contains("Number of reviews") + td').innerText, 10);
    return {
        title,
        price,
        stock,
        quantity,
        description,
        upc,
        productType,
        tax,
        reviews
    };
}

const data = extractData();
console.log(data);
})()

Em seguida, você pode executar esse código JavaScript gerado de forma programática e analisar o resultado com:

const result = await page.evaluate(code)
const data = schema.parse(result)

O objeto de dados conterá o mesmo resultado que os dados produzidos na Etapa 6 do capítulo anterior.

llm-scraper Alternativas para raspagem de LLM

O llm-scraper não é a única biblioteca disponível para raspagem com LLM. Algumas outras alternativas dignas de nota incluem:

• Crawl4AI: uma biblioteca Python para criar agentes de rastreamento da Web e pipelines de dados extremamente rápidos e prontos para IA. Ela é altamente flexível e otimizada para que os desenvolvedores implementem com velocidade e precisão. Você pode vê-la em ação em nosso tutorial sobre raspagem do Crawl4AI.
• ScrapeGraphAI: uma biblioteca de raspagem da Web em Python que combina LLMs e lógica de gráfico direta para criar pipelines de raspagem para sites e documentos locais (como XML, HTML, JSON e Markdown). Confira em nosso guia sobre coleta de dados com o ScrapeGraphAI.

Limitações dessa abordagem de raspagem da Web

O ToScrape, o site de destino que usamos neste artigo, é – como o nome sugere – apenas um sandbox de raspagem que aceita scripts de raspagem. Infelizmente, ao usar o llm-scraper em sites do mundo real, é provável que as coisas se tornem muito mais desafiadoras…

Por quê? Porque as empresas de comércio eletrônico e os negócios on-line sabem o quanto seus dados são valiosos e fazem de tudo para protegê-los. Isso é verdade mesmo que esses dados estejam disponíveis publicamente em suas páginas de produtos.

Como resultado, a maioria das plataformas de comércio eletrônico implementa medidas anti-bot e anti-raspagem para bloquear rastreadores automatizados. Essas técnicas podem impedir até mesmo os raspadores baseados em ferramentas de automação do navegador, como o Playwright, assim como o llm-scraper.

Estamos falando de defesas como o infame CAPTCHA da Amazon, que é suficiente para impedir a maioria dos bots:

Agora, mesmo que você consiga contornar os CAPTCHAs com o Playwright, outros desafios, como proibições de IP causadas por muitas solicitações automatizadas, podem encerrar sua operação de raspagem.

Nesse ponto, a solução não é ajustar incessantemente seu script para torná-lo mais complexo. A ideia é usar as ferramentas certas.

Ao integrar o Playwright a um navegador projetado especificamente para raspagem da Web, como o Scraping Browser, tudofica muito mais fácil. Essa solução é um navegador baseado em nuvem otimizado para raspagem. Ele lida com rotação de IP, novas tentativas automáticas, mecanismos avançados de desvio de anti-bot e até mesmo solução de CAPTCHA integrada, tudo isso sem a necessidade de gerenciar a infraestrutura por conta própria.

Integre o navegador de raspagem com o Playwright no llm-scraper como qualquer outro navegador, conforme explicado em nossos documentos.

Conclusão

Nesta postagem do blog, você aprendeu o que o llm-scraper tem a oferecer e como usá-lo para criar um script de raspagem alimentado por IA no TypeScript. Graças à sua integração com LLMs, você pode fazer a raspagem de sites com estruturas de página complexas ou dinâmicas.

Conforme discutimos, a maneira mais eficaz de evitar o bloqueio é utilizá-lo junto com o navegador de raspagem da Bright Data, que vem com um solucionador de CAPTCHA integrado e muitos outros recursos de desvio de antibot.

Se você estiver interessado em criar um agente de IA diretamente com base nessa solução, confira o Agent Browser. Essa solução executa fluxos de trabalho orientados por agentes em navegadores remotos que nunca são bloqueados. Ela é infinitamente dimensionável e é alimentada pela rede de proxy mais confiável do mundo.

Crie uma conta gratuita na Bright Data hoje mesmo e explore nossas soluções de dados e raspagem para impulsionar sua jornada de IA!