# Integração com LangChain

## Integração LangChain

O Rememberizer se integra ao LangChain através da classe `RememberizerRetriever`, permitindo que você incorpore facilmente as capacidades de busca semântica do Rememberizer em suas aplicações alimentadas pelo LangChain. Este guia explica como configurar e usar essa integração para construir aplicações LLM avançadas com acesso à sua base de conhecimento.

### Introdução

LangChain é um framework popular para construir aplicações com grandes modelos de linguagem (LLMs). Ao integrar o Rememberizer com o LangChain, você pode:

* Usar sua base de conhecimento do Rememberizer em aplicações RAG (Geração Aumentada por Recuperação)
* Criar chatbots com acesso aos seus documentos e dados
* Construir sistemas de perguntas e respostas que aproveitam seu conhecimento
* Desenvolver agentes que podem pesquisar e raciocinar sobre suas informações

A integração está disponível no módulo `langchain_community.retrievers`.

{% embed url="<https://python.langchain.com/docs/integrations/retrievers/rememberizer/>" %}

### Começando

#### Pré-requisitos

Antes de começar, você precisa:

1. Uma conta Rememberizer com Conhecimento Comum criada
2. Uma chave de API para acessar seu Conhecimento Comum
3. Ambiente Python com LangChain instalado

Para instruções detalhadas sobre como criar Conhecimento Comum e gerar uma chave de API, veja [Registrando e Usando Chaves de API](https://docs.rememberizer.ai/developer/registering-and-using-api-keys).

#### Instalação

Instale os pacotes necessários:

```bash
pip install langchain langchain_community
```

Se você planeja usar modelos OpenAI (como mostrado nos exemplos abaixo):

```bash
pip install langchain_openai
```

#### Configuração de Autenticação

Existem duas maneiras de autenticar o `RememberizerRetriever`:

1. **Variável de Ambiente**: Defina a variável de ambiente `REMEMBERIZER_API_KEY`

   ```python
   import os
   os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"
   ```
2. **Parâmetro Direto**: Passe a chave da API diretamente ao inicializar o recuperador

   ```python
   retriever = RememberizerRetriever(rememberizer_api_key="rem_ck_your_api_key")
   ```

### Opções de Configuração

A classe `RememberizerRetriever` aceita estes parâmetros:

| Parâmetro              | Tipo | Padrão | Descrição                                                                       |
| ---------------------- | ---- | ------ | ------------------------------------------------------------------------------- |
| `top_k_results`        | int  | 10     | Número de documentos a retornar da busca                                        |
| `rememberizer_api_key` | str  | None   | Chave da API para autenticação (opcional se definida como variável de ambiente) |

Nos bastidores, o recuperador faz chamadas de API para o endpoint de busca do Rememberizer com parâmetros configuráveis adicionais:

| Parâmetro Avançado    | Descrição                                                            |
| --------------------- | -------------------------------------------------------------------- |
| `prev_chunks`         | Número de partes antes da parte correspondente a incluir (padrão: 2) |
| `next_chunks`         | Número de partes após a parte correspondente a incluir (padrão: 2)   |
| `return_full_content` | Se deve retornar o conteúdo completo do documento (padrão: true)     |

### Uso Básico

Aqui está um exemplo simples de recuperação de documentos do Rememberizer usando LangChain:

```python
import os
from langchain_community.retrievers import RememberizerRetriever
```

## Defina sua chave de API

os.environ\["REMEMBERIZER\_API\_KEY"] = "rem\_ck\_your\_api\_key"

## Inicializar o recuperador

retriever = RememberizerRetriever(top\_k\_results=5)

## Obter documentos relevantes para uma consulta

docs = retriever.get\_relevant\_documents(query="Como funcionam as incorporações vetoriais?")

## Exibir o primeiro documento

if docs: print(f"Documento: {docs\[0].metadata\['name']}") print(f"Conteúdo: {docs\[0].page\_content\[:200]}...")

````

### Compreendendo a Estrutura do Documento

Cada documento retornado pelo recuperador possui:

- `page_content`: O conteúdo textual do trecho do documento correspondente
- `metadata`: Informações adicionais sobre o documento

Exemplo da estrutura de metadata:

```python
{
  'id': 13646493,
  'document_id': '17s3LlMbpkTk0ikvGwV0iLMCj-MNubIaP',
  'name': 'What is a large language model (LLM)_ _ Cloudflare.pdf',
  'type': 'application/pdf',
  'path': '/langchain/What is a large language model (LLM)_ _ Cloudflare.pdf',
  'url': 'https://drive.google.com/file/d/17s3LlMbpkTk0ikvGwV0iLMCj-MNubIaP/view',
  'size': 337089,
  'created_time': '',
  'modified_time': '',
  'indexed_on': '2024-04-04T03:36:28.886170Z',
  'integration': {'id': 347, 'integration_type': 'google_drive'}
}
````

### Exemplos Avançados

#### Construindo um Sistema de Perguntas e Respostas RAG

Este exemplo cria um sistema de perguntas e respostas que recupera informações do Rememberizer e usa o GPT-3.5 para formular respostas:

```python
import os
from langchain_community.retrievers import RememberizerRetriever
from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI
```

## Configurar chaves da API

os.environ\["REMEMBERIZER\_API\_KEY"] = "rem\_ck\_your\_api\_key" os.environ\["OPENAI\_API\_KEY"] = "your\_openai\_api\_key"

## Inicialize o recuperador e o modelo de linguagem

retriever = RememberizerRetriever(top\_k\_results=5) llm = ChatOpenAI(model\_name="gpt-3.5-turbo", temperature=0)

## Crie uma cadeia de QA de recuperação

qa\_chain = RetrievalQA.from\_chain\_type( llm=llm, chain\_type="stuff", # Método mais simples - apenas coloque todos os documentos no prompt retriever=retriever, return\_source\_documents=True )

## Faça uma pergunta

response = qa\_chain.invoke({"query": "O que é RAG no contexto da IA?"})

## Imprimir a resposta

print(f"Resposta: {response\['result']}") print("\nFontes:") for idx, doc in enumerate(response\['source\_documents']): print(f"{idx+1}. {doc.metadata\['name']}")

````

### Construindo um Agente Conversacional com Memória

Este exemplo cria um agente conversacional que pode manter o histórico da conversa:

```python
import os
from langchain_community.retrievers import RememberizerRetriever
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI
````

## Configurar chaves da API

os.environ\["REMEMBERIZER\_API\_KEY"] = "rem\_ck\_your\_api\_key" os.environ\["OPENAI\_API\_KEY"] = "your\_openai\_api\_key"

## Inicializar componentes

retriever = RememberizerRetriever(top\_k\_results=5) llm = ChatOpenAI(model\_name="gpt-3.5-turbo") memory = ConversationBufferMemory( memory\_key="chat\_history", return\_messages=True )

## Crie a cadeia conversacional

conversation = ConversationalRetrievalChain.from\_llm( llm=llm, retriever=retriever, memory=memory )

## Exemplo de conversa

questions = \[ "O que é RAG?", "Como os grandes modelos de linguagem o utilizam?", "Quais são as limitações dessa abordagem?", ]

for question in questions: response = conversation.invoke({"question": question}) print(f"Pergunta: {question}") print(f"Resposta: {response\['answer']}\n")

````

## Melhores Práticas

### Otimizando o Desempenho de Recuperação

1. **Seja específico com as consultas**: Consultas mais específicas geralmente produzem melhores resultados
2. **Ajuste `top_k_results`**: Comece com 3-5 resultados e ajuste com base nas necessidades da aplicação
3. **Use janelas de contexto**: O recuperador inclui automaticamente contexto em torno dos trechos correspondentes

### Considerações de Segurança

1. **Proteja sua chave de API**: Armazene-a com segurança usando variáveis de ambiente ou ferramentas de gerenciamento de segredos
2. **Crie chaves dedicadas**: Crie chaves de API separadas para diferentes aplicações
3. **Gire as chaves regularmente**: Gere novas chaves periodicamente e descontinue as antigas

### Padrões de Integração

1. **Processamento pré-retrieval**: Considere pré-processar consultas de usuários para melhorar a relevância da busca
2. **Filtragem pós-retrieval**: Filtrar ou classificar documentos recuperados antes de passar para o LLM
3. **Busca híbrida**: Combine Rememberizer com outros recuperadores usando `EnsembleRetriever`

```python
from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import RememberizerRetriever, WebResearchRetriever
````

## Criar recuperadores

rememberizer\_retriever = RememberizerRetriever(top\_k\_results=3) web\_retriever = WebResearchRetriever(...) # Configurar outro recuperador

## Crie um conjunto com pontuação ponderada

ensemble\_retriever = EnsembleRetriever( retrievers=\[rememberizer\_retriever, web\_retriever], weights=\[0.7, 0.3] # Os resultados do Rememberizer têm maior peso )

````

## Solução de Problemas

### Problemas Comuns

1. **Erros de autenticação**: Verifique se sua chave de API está correta e devidamente configurada
2. **Nenhum resultado retornado**: Certifique-se de que seu Conhecimento Comum contém informações relevantes
3. **Limitação de taxa**: Esteja atento aos limites de taxa da API para aplicações de alto volume

### Dicas de Depuração

- Defina o modo de depuração do LangChain para ver chamadas de API detalhadas:
  ```python
  import langchain
  langchain.debug = True
````

* Examine os resultados de busca brutos antes de passar para o LLM para identificar problemas de recuperação

### Recursos Relacionados

* LangChain [Guia conceitual do Recuperador](https://python.langchain.com/docs/concepts/#retrievers)
* LangChain [Guias práticos do Recuperador](https://python.langchain.com/docs/how_to/#retrievers)
* Rememberizer [Documentação da API](https://docs.rememberizer.ai/developer/api-docs/)
* [Armazenamentos Vetoriais](https://docs.rememberizer.ai/developer/vector-stores) no Rememberizer
* [Criando um GPT do Rememberizer](https://docs.rememberizer.ai/pt/recursos-para-desenvolvedores/integration-options/creating-a-rememberizer-gpt) - Uma abordagem alternativa para integração de IA