Python e LangChain: Web scraping com IA

Salve salve Pythonista

No mundo digital de hoje, o Web Scraping é uma técnica essencial para extrair informações de sites.

Com a evolução da inteligência artificial, surge a possibilidade de incorporar agentes inteligentes através de Frameworks LLM, como o Langchain, e automação de navegadores, como o Playwright, para enriquecer esse processo.

Neste artigo, exploraremos como combinar essas ferramentas para realizar web scraping de maneira eficiente e inteligente.

Vamos entender o que são o Langchain e o Playwright, como configurá-los e implementá-los em um projeto de web scraping.

Além disso, utilizaremos outras bibliotecas úteis e o ChatGPT para analisar os dados extraídos.

Vamos lá!

Vá Direto ao Assunto…

• O que é Langchain?
• O que é Playwright?
• Bibliotecas Necessárias
• Implementação do Web Scraping com IA
• Resultado da Extração de Dados
• Código Completo do Web Scraping com IA

O que é Langchain?

O Langchain é uma biblioteca que simplifica a criação de pipelines de processamento de linguagem natural sofisticados.

Ela permite que desenvolvedores combinem diferentes modelos e técnicas de forma modular.

Utilizando o Langchain, podemos facilmente misturar e combinar modelos de IA para obter uma análise aprimorada do texto extraído durante o web scraping.

Se quiser saber mais sobre o LangChain, clique aqui para ler um artigo completo com mais detalhes sobre essa formidável ferramenta.

O que é Playwright?

Playwright é uma biblioteca para automação de navegadores, semelhante ao Selenium, mas com desempenho melhorado e suporte a multiplataforma.

Ele permite controlar navegadores para extrair dados dinâmicos de sites de forma eficiente, essencial quando lidamos com páginas que carregam dados via JavaScript.

O langchain utiliza o Playwright para carregar páginas dinâmicas e extrair o conteúdo HTML para análise.

Bibliotecas Necessárias

Para implementar nosso projeto de Web Scraping com IA, precisamos instalar as seguintes bibliotecas:

1
2
3
4
5
6

pip install playwright \
  beautifulsoup4 \
  python-decouple \
  langchain \
  langchain-community \
  langchain-openai

Explicação das Bibliotecas

• playwright: Automação de navegador para carregamento de páginas dinâmicas.
• beautifulsoup4: Extração de dados do HTML.
• python-decouple: Carregar variáveis de ambiente de arquivos .env.
• langchain: Construção de pipelines de linguagem natural.
• langchain-community: Funcionalidades adicionais para o Langchain.
• langchain-openai: Integração com a API da OpenAI.

Implementação do Web Scraping com IA

Vamos implementar o processo de web scraping com as etapas detalhadas a seguir.

Configuração Inicial

Primeiro, vamos configurar nossa chave de API e o modelo de linguagem natural que usaremos:

Crie um arquivo .env na raiz do projeto com a chave da API da OpenAI:

1
2
3
4
5

from decouple import config
import os

# Carrega a chave da API da OpenAI do arquivo .env usando decouple
os.environ['OPENAI_API_KEY'] = config('OPENAI_API_KEY')

Definição do Modelo

Definimos o modelo para estruturar os dados do artigo, utilizando o Pydantic.

Estruturamos o modelo do artigo com campos como título, descrição, data, autor e link:

1
2
3
4
5
6
7
8
9
10
11

from pydantic import Field, BaseModel

class Article(BaseModel):
    """
    Representa um artigo com informações estruturadas.
    """
    headline: str = Field(description="O título do artigo")
    description: str = Field(description="Uma breve descrição do artigo")
    date: str = Field(description="A data em que o artigo foi publicado")
    author: str = Field(description="O autor do artigo")
    link: str = Field(description="O link para o artigo")

Carregamento de Dados

Usamos o AsyncChromiumLoader do Langchain para carregar o conteúdo HTML das URLs. Ele carrega o conteúdo HTML das URLs especificadas:

1
2
3
4
5
6
7

from langchain_community.document_loaders import AsyncChromiumLoader

# Lista de URLs que serão carregadas
urls = ["https://pythonacademy.com.br/blog/"]

loader = AsyncChromiumLoader(urls)
docs = loader.load()

Extração com BeautifulSoup

Com o BeautifulSoupTransformer, extraímos as tags desejadas:

Dentro da função transform_documents, passamos a lista de documentos carregados e as tags que queremos extrair (como “article”) para obter as tags você precisa inspecionar o HTML da página e identificar as tags que contêm o conteúdo desejado.:

1
2
3
4
5
6
7
8

from langchain_community.document_transformers import BeautifulSoupTransformer

# Utiliza BeautifulSoupTransformer para extrair apenas as tags desejadas ("article")
bs_transformed = BeautifulSoupTransformer()
docs_transformed = bs_transformed.transform_documents(
  documents=docs, 
  tags_to_extract=["article"]
)

Tokenização de Texto

Usamos o RecursiveCharacterTextSplitter para tokenizar o texto entregue para análise:

1
2
3
4
5
6
7
8

from langchain_text_splitters import RecursiveCharacterTextSplitter

# Divide o conteúdo extraído em pedaços usando tokenização
splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
  chunk_size=2000, 
  chunk_overlap=0
)
splits = splitter.split_documents(documents=docs_transformed)

Análise de Conteúdo

Finalmente, invocamos o modelo estruturado de linguagem natural para estruturar os dados:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from langchain_openai import ChatOpenAI

# Cria uma instância do modelo ChatOpenAI configurado com GPT-4o-mini
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# Configura o modelo para retornar respostas estruturadas no formato da classe Article
structured_llm = llm.with_structured_output(Article)

# Extrai e estrutura as informações usando o modelo configurado para cada pedaço
extracted_content = [structured_llm.invoke(split.page_content) for split in splits]

# Converte o conteúdo estruturado em uma lista de dicionários
extracted_content_dict = [article.model_dump() for article in extracted_content]

# Exibe o resultado
print(extracted_content_dict)

Resultado da Extração de Dados

O código acima extrai e estrutura dados das páginas especificadas retornando uma lista de artigos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[
  {'headline': 'Padrões de Projeto em Python (Design Patterns)', 
  'description': 'Neste artigo, você aprenderá sobre Padrões de Projeto 
  em Python (Design Patterns) e sua importância.', 
  'date': '26/02/2025', 
  'author': 'Vinícius Ramos', 
  'link': 'https://pythonacademy.com.br/blog/padroes-de-projeto-em-python'},
  
  {'headline': 'O que é o Django Rest Framework (DRF)?', 
  'description': 'Entenda o que é o Django Rest Framework (DRF) e como ele 
  pode facilitar o desenvolvimento de APIs REST em Django.', 
  'date': '27/08/2024', 
  'author': 'Vinícius Ramos', 
  'link': 'https://pythonacademy.com.br/blog/o-que-e-o-django-rest-framework'}
]

Este resultado revela como o uso de IA pode facilitar e estruturar processos de extração de dados.

Antes de continuar… Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Código Completo do Web Scraping com IA

Aqui está o código completo para referência:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

from decouple import config
from langchain_community.document_loaders import AsyncChromiumLoader
from langchain_community.document_transformers import BeautifulSoupTransformer
from langchain_openai import ChatOpenAI
from langchain_text_splitters import RecursiveCharacterTextSplitter
from pydantic import Field, BaseModel
import os

os.environ['OPENAI_API_KEY'] = config('OPENAI_API_KEY')

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

class Article(BaseModel):
    headline: str = Field(description="O título do artigo")
    description: str = Field(description="Uma breve descrição do artigo")
    date: str = Field(description="A data em que o artigo foi publicado")
    author: str = Field(description="O autor do artigo")
    link: str = Field(description="O link para o artigo")

structured_llm = llm.with_structured_output(Article)

urls = ["https://pythonacademy.com.br/blog/"]
tags_to_extract = ["article"]

loader = AsyncChromiumLoader(urls)
docs = loader.load()

bs_transformed = BeautifulSoupTransformer()
docs_transformed = bs_transformed.transform_documents(
  documents=docs, 
  tags_to_extract=tags_to_extract
)

splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
  chunk_size=2000, 
  chunk_overlap=0
)

splits = splitter.split_documents(documents=docs_transformed)

extracted_content = [structured_llm.invoke(split.page_content) for split in splits]

extracted_content_dict = [article.model_dump() for article in extracted_content]

print(extracted_content_dict)

Antes de concluir…

Parece que você está gostando! Que tal fazer parte da nossa Jornada Python?

Conclusão

Neste artigo, mergulhamos na combinação poderosa do Langchain e do Playwright para realizar web scraping avançado com IA.

Estudamos como configurar e implementar estas ferramentas, além de outras bibliotecas essenciais, para extrair dados de sites de forma eficiente.

Com a capacidade de estruturar informações de maneira precisa, esse método transforma a maneira como abordamos a extração de dados na web.

Experimente estas técnicas no seu próximo projeto e veja os benefícios dessa abordagem inovadora.

Por Erickson Lopes em 03/03/2025

Bora se conectar no LinkedIn!

Minhas redes: