LangChain

Use o framework LangChain junto com a Oxylabs Web Scraper API para extrair dados da web e alimentá-los em fluxos de trabalho de LLM — colete, processe e analise em um único pipeline.

A LangChain integração com a Oxylabs Web Scraper API permite coletar e processar dados da web por meio de um LLM (Large Language Model) no mesmo fluxo de trabalho.

Visão geral

LangChain é um framework para criar apps que usam LLMs junto com ferramentas, APIs e dados da web. Ele oferece suporte a Python e JavaScript. Use-o com Oxylabs Web Scraper API para:

• Extrair dados estruturados sem lidar com CAPTCHAs, bloqueios de IP ou renderização de JS

• Processar resultados com um LLM no mesmo pipeline

• Criar fluxos de trabalho de ponta a ponta, da extração à saída com IA

Primeiros passos

Crie suas credenciais de usuário da API: cadastre-se para uma avaliação gratuita ou compre o produto no painel da Oxylabs para criar suas credenciais de usuário da API (USERNAME e PASSWORD).

Se você precisar de mais de um usuário de API para sua conta, entre em contato com nosso suporte ao cliente ou envie uma mensagem para nosso suporte por chat ao vivo 24/7.

Neste guia, usaremos a linguagem de programação Python. Instale as bibliotecas necessárias usando pip:

pip install -qU langchain-oxylabs langchain-openai langgraph requests python-dotenv

Configuração do ambiente

Crie um arquivo .env no diretório do seu projeto com seu usuário da API da Oxylabs e suas credenciais da OpenAI:

OXYLABS_USERNAME=seu-usuario
OXYLABS_PASSWORD=sua-senha
OPENAI_API_KEY=sua-chave-openai

Carregue essas variáveis de ambiente no seu script Python:

import os
from dotenv import load_dotenv

load_dotenv()

Métodos de integração

Há duas formas principais de integrar a Oxylabs Web Scraper API com o LangChain:

Usando o pacote langchain-oxylabs

Para consultas de pesquisa do Google, use o pacote dedicado langchain-oxylabs , que oferece uma integração pronta para uso:

import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langgraph.prebuilt import create_react_agent
from langchain_oxylabs import OxylabsSearchAPIWrapper, OxylabsSearchRun

load_dotenv()

# Inicialize o modelo LLM de sua preferência
llm = init_chat_model(
    "gpt-4o-mini",
    model_provider="openai",
    api_key=os.getenv("OPENAI_API_KEY")
)

# Inicialize a ferramenta de pesquisa do Google
search = OxylabsSearchRun(
    wrapper=OxylabsSearchAPIWrapper(
        oxylabs_username=os.getenv("OXYLABS_USERNAME"),
        oxylabs_password=os.getenv("OXYLABS_PASSWORD")
    )
)

# Crie um agente que usa a ferramenta de pesquisa do Google
agent = create_react_agent(llm, [search])

# Exemplo de uso
user_input = "When and why did the Maya civilization collapse?"
response = agent.invoke({"messages": user_input})
print(response["messages"][-1].content)

Usando a Web Scraper API

Para acessar outros sites além da pesquisa do Google, você pode enviar uma solicitação diretamente para a Web Scraper API:

import os
import requests
from dotenv import load_dotenv
from langchain_openai import OpenAI
from langchain_core.prompts import PromptTemplate

load_dotenv()

def scrape_website(url):
    """Extrair o site usando a Oxylabs Web Scraper API"""
    payload = {
        "source": "universal",
        "url": url,
        "parse": True
    }
    response = requests.post(
        "https://realtime.oxylabs.io/v1/queries",
        auth=(os.getenv("OXYLABS_USERNAME"), os.getenv("OXYLABS_PASSWORD")),
        json=payload
    )
    
    if response.status_code == 200:
        data = response.json()
        content = data["results"][0]["content"]
        return str(content)
    else:
        print(f"Falha ao extrair o site: {response.text}")
        return None

def process_content(content):
    """Processar o conteúdo extraído usando o LangChain"""
    if not content:
        print("Nenhum conteúdo para processar.")
        return None
        
    prompt = PromptTemplate.from_template(
        "Analise o conteúdo do site a seguir e resuma os pontos principais: {content}"
    )
    chain = prompt | OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    result = chain.invoke({"content": content})
    return result

def main(url):
    print("Extraindo o site...")
    scraped_content = scrape_website(url)
    if scraped_content:
        print("Processando o conteúdo extraído com o LangChain...")
        analysis = process_content(scraped_content)
        print("\nAnálise processada:\n", analysis)
    else:
        print("Nenhum conteúdo extraído.")

if __name__ == "__main__":
    url = "https://sandbox.oxylabs.io/products/1"
    main(url)

Scrapers específicos por destino

A Oxylabs fornece scrapers especializados para vários sites populares. Aqui estão alguns exemplos de fontes disponíveis:

Site	Parâmetro de source	Parâmetros necessários
Google	google_search	query
Amazon	amazon_search	query, domain (opcional)
Walmart	walmart_search	query
Target	target_search	query
Kroger	kroger_search	query, store_id
Staples	staples_search	query

Para usar um scraper específico, modifique o payload na função scrape_website :

# Exemplo para pesquisa na Amazon
payload = {
    "source": "amazon_search",
    "query": "smartphone",
    "domain": "com",
    "parse": True
}

Configuração avançada

Tratamento de conteúdo dinâmico

A Web Scraper API pode lidar com renderização de JavaScript adicionando o parâmetro render :

payload = {
    "source": "universal",
    "url": url,
    "parse": True,
    "render": "html"
}

Definindo o tipo de user agent

Você pode especificar diferentes user agents para simular diferentes dispositivos:

payload = {
    "source": "universal",
    "url": url,
    "parse": True,
    "render": "html",
    "user_agent_type": "mobile"
}

Usando parâmetros específicos do destino

Muitos scrapers específicos por destino aceitam parâmetros adicionais:

# Exemplo para Kroger com parâmetros de localização
payload = {
    "source": "kroger_search",
    "query": "organic milk",
    "store_id": "01100002",
    "fulfillment_type": "pickup"
}

Tratamento de erros

Implemente um tratamento de erros adequado para aplicações de produção:

try:
    response = requests.post(
        "https://realtime.oxylabs.io/v1/queries",
        auth=(os.getenv("OXYLABS_USERNAME"), os.getenv("OXYLABS_PASSWORD")),
        json=payload,
        timeout=60
    )
    response.raise_for_status()
    # Processar resposta
except requests.exceptions.HTTPError as http_err:
    print(f"Ocorreu um erro HTTP: {http_err}")
except requests.exceptions.ConnectionError as conn_err:
    print(f"Ocorreu um erro de conexão: {conn_err}")
except requests.exceptions.Timeout as timeout_err:
    print(f"Ocorreu um erro de timeout: {timeout_err}")
except requests.exceptions.RequestException as req_err:
    print(f"Ocorreu um erro: {req_err}")