LangChain

Use o framework LangChain junto com a Oxylabs Web Scraper API para puxar dados web e alimentá-los em fluxos de trabalho LLM—coletar, processar, analisar em um único pipeline.

O LangChain integração com o Oxylabs Web Scraper API permite que você colete e processe dados da web através de um LLM (Large Language Model) no mesmo fluxo de trabalho.

Visão geral

LangChain é uma estrutura para construir apps que usam LLMs juntamente com ferramentas, APIs e dados da web. Suporta tanto Python quanto JavaScript. Use-a com Oxylabs Web Scraper API para:

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

• Processar resultados com um LLM na mesma pipeline

• Construir fluxos de trabalho de ponta a ponta desde a extração até a saída com IA

Primeiros passos

Crie suas credenciais de usuário da API: inscreva-se para um teste gratuito ou compre o produto em Oxylabs dashboard 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, por favor entre em contato com nosso customer support ou envie uma mensagem para nosso suporte de 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 .env arquivo no diretório do seu projeto com seu usuário da API Oxylabs e credenciais OpenAI:

OXYLABS_USERNAME=your-username
OXYLABS_PASSWORD=your-password
OPENAI_API_KEY=your-openai-key

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

import os
from dotenv import load_dotenv

load_dotenv()

Métodos de integração

Existem duas maneiras principais de integrar a Web Scraper API da Oxylabs com o LangChain:

Usando o pacote langchain-oxylabs

Para consultas de pesquisa no Google, use o langchain-oxylabs pacote, que fornece 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()

# Initialize your preferred LLM model
llm = init_chat_model(
    "gpt-4o-mini",
    model_provider="openai",
    api_key=os.getenv("OPENAI_API_KEY")
)

# Initialize the Google search tool
search = OxylabsSearchRun(
    wrapper=OxylabsSearchAPIWrapper(
        oxylabs_username=os.getenv("OXYLABS_USERNAME"),
        oxylabs_password=os.getenv("OXYLABS_PASSWORD")
    )
)

# Create an agent that uses the Google search tool
agent = create_react_agent(llm, [search])

# Example usage
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 do Google Search, você pode enviar diretamente requisições 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):
    """Raspar 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"Failed to scrape website: {response.text}")
        return None

def process_content(content):
    """Processar o conteúdo raspado usando o LangChain"""
    if not content:
        print("No content to process.")
        return None
        
    prompt = PromptTemplate.from_template(
        "Analyze the following website content and summarize key points: {content}"
    )
    chain = prompt | OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    result = chain.invoke({"content": content})
    return result

def main(url):
    print("Scraping website...")
    scraped_content = scrape_website(url)
    if scraped_content:
        print("Processing scraped content with LangChain...")
        analysis = process_content(scraped_content)
        print("\nProcessed Analysis:\n", analysis)
    else:
        print("No content scraped.")

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

Scrapers específicos por alvo

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

Site	Parâmetro de origem	Parâmetros obrigatórios
Google	google_search	query
Amazon	amazon_search	query, domínio (opcional)
Walmart	walmart_search	query
Alvo	target_search	query
Kroger	kroger_search	query, store_id
Staples	staples_search	query

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

# Example for Amazon search
payload = {
    "source": "amazon_search",
    "query": "smartphone",
    "domain": "com",
    "parse": True
}

Configuração avançada

Tratando conteúdo dinâmico

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

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

Definindo o tipo de User-Agent

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

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

Usando parâmetros específicos do alvo

Muitos scrapers específicos por alvo suportam parâmetros adicionais:

# Example for Kroger with location parameters
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 em 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()
    # Process response
except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error occurred: {http_err}")
except requests.exceptions.ConnectionError as conn_err:
    print(f"Connection error occurred: {conn_err}")
except requests.exceptions.Timeout as timeout_err:
    print(f"Timeout error occurred: {timeout_err}")
except requests.exceptions.RequestException as req_err:
    print(f"An error occurred: {req_err}")