LangChain

Usa el framework LangChain junto con Oxylabs Web Scraper API para extraer datos web y enviarlos a flujos de trabajo de LLM: recopilar, procesar, analizar en una sola canalización.

El LangChain integración con el Oxylabs Web Scraper API te permite recopilar y procesar datos web a través de un LLM (modelo de lenguaje grande) en el mismo flujo de trabajo.

Descripción general

LangChain es un framework para crear aplicaciones que usan LLMs junto con herramientas, APIs y datos web. Admite tanto Python como JavaScript. Úsalo con Oxylabs Web Scraper API para:

• Extraer datos estructurados sin tener que lidiar con CAPTCHAs, bloqueos de IP o renderizado de JS
• Procesar resultados con un LLM en la misma canalización
• Crear flujos de trabajo de extremo a extremo, desde la extracción hasta la salida impulsada por IA

Primeros pasos

Crea tus credenciales de usuario de la API: regístrate para una prueba gratuita o compra el producto en la panel de Oxylabs para crear tus credenciales de usuario de API (USERNAME y PASSWORD).

Si necesitas más de un usuario de API para tu cuenta, contacta con nuestro soporte al cliente o envía un mensaje a nuestro soporte de chat en vivo 24/7.

En esta guía usaremos el lenguaje de programación Python. Instala las bibliotecas requeridas usando pip:

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

Configuración del entorno

Crea un .env archivo en el directorio de tu proyecto con tus credenciales de usuario de la API de Oxylabs y de OpenAI:

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

Carga estas variables de entorno en tu script de Python:

import os
from dotenv import load_dotenv

load_dotenv()

Métodos de integración

Hay dos formas principales de integrar Oxylabs Web Scraper API con LangChain:

Usando el paquete langchain-oxylabs

Para consultas de búsqueda de Google, usa el paquete dedicado langchain-oxylabs paquete, que ofrece una integración lista para usar:

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 el Web Scraper API

Para acceder a otros sitios web más allá de la búsqueda de Google, puedes enviar directamente una solicitud al 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):
    """Scrape the website using 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):
    """Process the scraped content using 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 del sitio

Oxylabs proporciona scrapers especializados para varios sitios web populares. Aquí hay algunos ejemplos de fuentes disponibles:

Sitio web	Parámetro de fuente	Parámetros requeridos
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 un scraper específico, modifica el payload en la scrape_website función:

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

Configuración avanzada

Manejo de contenido dinámico

El Web Scraper API puede manejar renderizado de JavaScript añadiendo el render parámetro:

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

Configuración del tipo de user agent

Puedes especificar diferentes agentes de usuario para simular diferentes dispositivos:

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

Uso de parámetros específicos del objetivo

Muchos scrapers específicos del sitio admiten parámetros adicionales:

# Example for Kroger with location parameters
payload = {
    "source": "kroger_search",
    "query": "organic milk",
    "store_id": "01100002",
    "fulfillment_type": "pickup"
}

Manejo de errores

Implementa un manejo de errores adecuado para aplicaciones en producción:

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}")