LangChain

Usa el framework LangChain junto con la Web Scraper API de Oxylabs para extraer datos web e introducirlos en flujos de trabajo LLM: recopila, procesa y analiza en una sola canalización.

El LangChain integración con el Oxylabs Web Scraper API le permite recopilar y procesar datos web a través de un LLM (Large Language Model) en el mismo flujo de trabajo.

Resumen

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

• Raspar datos estructurados sin manejar CAPTCHAs, bloqueos de IP o renderizado JS

• Procesar resultados con un LLM en la misma canalización

• Construir flujos de trabajo de extremo a extremo desde la extracción hasta la salida impulsada por IA

que quieras.

Primeros pasos: regístrate para una prueba gratuita o compra el producto en el : Regístrate para una prueba gratuita o compra el producto en el panel de Oxylabspara crear tus credenciales de usuario API ( y y).

PASSWORD Si necesitas más de un usuario API para tu cuenta, por favor contacta con nuestro soporte al cliente

En esta guía usaremos el lenguaje de programación Python. Instala las librerías 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 su proyecto con su usuario de API de Oxylabs y credenciales 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 en Google, use el langchain-oxylabs paquete, que proporciona 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()

# Inicialice su modelo LLM preferido
llm = init_chat_model(
    "gpt-4o-mini",
    model_provider="openai",
    api_key=os.getenv("OPENAI_API_KEY")
)

# Inicialice la herramienta de búsqueda de Google
search = OxylabsSearchRun(
    wrapper=OxylabsSearchAPIWrapper(
        oxylabs_username=os.getenv("OXYLABS_USERNAME"),
        oxylabs_password=os.getenv("OXYLABS_PASSWORD")
    )
)

# Cree un agente que use la herramienta de búsqueda de Google
agent = create_react_agent(llm, [search])

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

Usando la Web Scraper API

Para acceder a otros sitios web más allá de la búsqueda de Google, puede enviar directamente solicitudes a la 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 el sitio web usando 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")),
        auth=('USERNAME', 'PASSWORD'),
    )
    
    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):
    """Procesar el contenido raspado usando 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)

Rastreadores específicos por objetivo

Oxylabs proporciona rastreadores 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, dominio (opcional)
Walmart	walmart_search	query
Objetivo	target_search	query
Kroger	kroger_search	query, store_id
Staples	staples_search	query

Para usar un rastreador específico, modifique la carga útil en la scrape_website función:

# Ejemplo para búsqueda en Amazon
payload = {
    "source": "amazon_search",
    "query": "smartphone",
    "domain": "com",
    "parse": True
}

Configuración avanzada

Manejo de contenido dinámico

La Web Scraper API puede manejar representación de JavaScript al agregar el user_agent_type parámetro:

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

Configuración del tipo de User-Agent

Puede especificar diferentes user agents 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 rastreadores específicos por objetivo admiten parámetros adicionales:

# Ejemplo para Kroger con parámetros de ubicación
payload = {
    "source": "kroger_search",
    "query": "organic milk",
    "store_id": "01100002",
    "fulfillment_type": "pickup"
}

Manejo de errores

Implemente 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()
    # Procesar respuesta
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}")