> For the complete documentation index, see [llms.txt](https://developers.oxylabs.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developers.oxylabs.io/ai-workflows/es/langchain.md).

# LangChain

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

La **LangChain** integración con la [**Oxylabs Web Scraper API**](https://oxylabs.io/products/scraper-api/web) te permite recopilar y procesar datos web mediante un LLM (Large Language Model) 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. Es compatible con Python y JavaScript. Úsalo con [**Oxylabs Web Scraper API** ](http://developers.oxylabs.io/scraper-apis/web-scraper-api?_gl=1*1ljhay3*_gcl_aw*R0NMLjE3NDYxODM0ODcuQ2owS0NRancydEhBQmhDaUFSSXNBTlp6RFdvSXlSNVg3blQtd0ZEakxHOUlvdUhyQmtoRTRCeUNwc054dFJVMmh0Z3dZTTR3Nm90SjVKOGFBbHhhRUFMd193Y0I.*_gcl_au*MjU4NDEzMTkwLjE3NDExNzU2MzI.)para:

* Extrae datos estructurados sin tener que lidiar con CAPTCHAs, bloqueos de IP ni renderizado de JS
* Procesa los resultados con un LLM en la misma canalización
* Crea 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 API**: regístrate para una prueba gratuita o compra el producto en el [**panel de Oxylabs**](https://dashboard.oxylabs.io/en/registration) para crear tus credenciales de usuario de API (`USERNAME` y `PASSWORD`).

{% hint style="warning" %}
Si necesitas más de un usuario de API para tu cuenta, contacta con nuestro [**soporte al cliente**](mailto:support@oxylabs.io) o escribe a nuestro soporte por chat en vivo 24/7.
{% endhint %}

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

```bash
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 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:

```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:

### Uso del paquete langchain-oxylabs

Para consultas de búsqueda en Google, usa el dedicado [`langchain-oxylabs`](https://python.langchain.com/docs/integrations/tools/oxylabs/) paquete, que ofrece una integración lista para usar:

```python
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)
```

### Uso de Web Scraper API

Para acceder a otros sitios web más allá de la búsqueda de Google, puedes enviar directamente una solicitud a Web Scraper API:

```python
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 de destino

Oxylabs ofrece [**scrapers especializados**](https://developers.oxylabs.io/api-targets/) para varios sitios web populares. Aquí hay algunos ejemplos de fuentes disponibles:

| Sitio web | Parámetro de source | 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:

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

## Configuración avanzada

### Manejo de contenido dinámico

Web Scraper API puede manejar [**renderizado de JavaScript**](broken://pages/cee294c2f1d2e9edc06953b48b6222fb27173ebb) añadiendo el `render` parámetro:

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

### Configuración del tipo de user agent

Puedes especificar diferentes [**agentes de usuario**](broken://pages/5fbafa03cdb3a381501df032aa730d14f0ed9ea1) para simular diferentes dispositivos:

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

### Uso de parámetros específicos de destino

Muchos [**scrapers específicos de destino**](https://developers.oxylabs.io/api-targets/) admiten parámetros adicionales:

```python
# 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 de producción:

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://developers.oxylabs.io/ai-workflows/es/langchain.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.