# LangChain

A **LangChain** integração com o [**Oxylabs Web Scraper API**](https://oxylabs.io/products/scraper-api/web) permite coletar e processar dados da web por meio de um LLM (Modelo de Linguagem Grande) no mesmo fluxo de trabalho.

## Visão geral

**LangChain** é uma estrutura 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** ](http://developers.oxylabs.io/scraper-apis/web-scraper-api?_gl=1*1ljhay3*_gcl_aw*R0NMLjE3NDYxODM0ODcuQ2owS0NRancydEhBQmhDaUFSSXNBTlp6RFdvSXlSNVg3blQtd0ZEakxHOUlvdUhyQmtoRTRCeUNwc054dFJVMmh0Z3dZTTR3Nm90SjVKOGFBbHhhRUFMd193Y0I.*_gcl_au*MjU4NDEzMTkwLjE3NDExNzU2MzI.)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 ponta a ponta, da extração à saída com IA

## Começando

**Crie suas credenciais de usuário da API**: cadastre-se para um teste gratuito ou compre o produto na [**painel da Oxylabs**](https://dashboard.oxylabs.io/en/registration) para criar suas credenciais de usuário da API (`USERNAME` e `PASSWORD`).

{% hint style="warning" %}
Se você precisar de mais de um usuário de API para sua conta, entre em contato com nosso [**suporte ao cliente**](mailto:support@oxylabs.io) ou envie uma mensagem para nosso suporte por chat ao vivo 24/7.
{% endhint %}

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

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

## Configuração do ambiente

Crie um arquivo `.env` arquivo no diretório do seu projeto com as credenciais de usuário da API da Oxylabs e da 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:

```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 dedicado [`langchain-oxylabs`](https://python.langchain.com/docs/integrations/tools/oxylabs/) pacote, que oferece uma integração pronta para uso:

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

# 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 busca do Google
search = OxylabsSearchRun(
    wrapper=OxylabsSearchAPIWrapper(
        oxylabs_username=os.getenv("OXYLABS_USERNAME"),
        oxylabs_password=os.getenv("OXYLABS_PASSWORD")
    )
)

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

# Exemplo de uso
user_input = "Quando e por que a civilização maia entrou em colapso?"
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 diretamente uma requisição para 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):
    """Faça o scraping do 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 fazer scraping do site: {response.text}")
        return None

def process_content(content):
    """Processa 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 a seguir do site 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("Fazendo scraping do 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 alvo

A Oxylabs fornece [**scrapers especializados**](/api-targets/pt-br/qualquer-dominio.md) 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`, `domain` (opcional) |
| Walmart | `walmart_search`    | `query`                      |
| Destino | `target_search`     | `query`                      |
| Kroger  | `kroger_search`     | `query`, `store_id`          |
| Staples | `staples_search`    | `query`                      |

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

```python
# 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**](/products/pt-br/web-scraper-api/features/js-rendering-and-browser-control.md) adicionando o `render` parâmetro:

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

### Definindo o tipo de user agent

Você pode especificar diferentes [**agentes de usuário**](/products/pt-br/web-scraper-api/features/http-context-and-job-management/user-agent-type.md) para simular diferentes dispositivos:

```python
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**](https://developers.oxylabs.io/api-targets/pt-br/) oferecem suporte a parâmetros adicionais:

```python
# 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 o tratamento adequado de erros para aplicações em produção:

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


---

# Agent Instructions: Querying This Documentation

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

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://developers.oxylabs.io/products/pt-br/web-scraper-api/solutions-for-ai-workflows/langchain.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.