# Integración con LangChain

## Integración de LangChain

Rememberizer se integra con LangChain a través de la clase `RememberizerRetriever`, lo que te permite incorporar fácilmente las capacidades de búsqueda semántica de Rememberizer en tus aplicaciones impulsadas por LangChain. Esta guía explica cómo configurar y utilizar esta integración para construir aplicaciones avanzadas de LLM con acceso a tu base de conocimientos.

### Introducción

LangChain es un marco popular para construir aplicaciones con modelos de lenguaje grandes (LLMs). Al integrar Rememberizer con LangChain, puedes:

* Usar tu base de conocimientos de Rememberizer en aplicaciones RAG (Generación Aumentada por Recuperación)
* Crear chatbots con acceso a tus documentos y datos
* Construir sistemas de preguntas y respuestas que aprovechen tu conocimiento
* Desarrollar agentes que puedan buscar y razonar sobre tu información

La integración está disponible en el módulo `langchain_community.retrievers`.

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

### Empezando

#### Requisitos

Antes de comenzar, necesitas:

1. Una cuenta de Rememberizer con Conocimiento Común creada
2. Una clave API para acceder a tu Conocimiento Común
3. Un entorno de Python con LangChain instalado

Para instrucciones detalladas sobre cómo crear Conocimiento Común y generar una clave API, consulta [Registrando y Usando Claves API](https://docs.rememberizer.ai/developer/registering-and-using-api-keys).

#### Instalación

Instala los paquetes requeridos:

```bash
pip install langchain langchain_community
```

Si planeas usar modelos de OpenAI (como se muestra en los ejemplos a continuación):

```bash
pip install langchain_openai
```

#### Configuración de Autenticación

Hay dos formas de autenticar el `RememberizerRetriever`:

1. **Variable de Entorno**: Establecer la variable de entorno `REMEMBERIZER_API_KEY`

   ```python
   import os
   os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"
   ```
2. **Parámetro Directo**: Pasar la clave API directamente al inicializar el recuperador

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

### Opciones de Configuración

La clase `RememberizerRetriever` acepta estos parámetros:

| Parámetro              | Tipo | Predeterminado | Descripción                                                                      |
| ---------------------- | ---- | -------------- | -------------------------------------------------------------------------------- |
| `top_k_results`        | int  | 10             | Número de documentos a devolver de la búsqueda                                   |
| `rememberizer_api_key` | str  | None           | Clave API para autenticación (opcional si se establece como variable de entorno) |

Detrás de escena, el recuperador realiza llamadas a la API al punto final de búsqueda de Rememberizer con parámetros configurables adicionales:

| Parámetro Avanzado    | Descripción                                                                          |
| --------------------- | ------------------------------------------------------------------------------------ |
| `prev_chunks`         | Número de fragmentos antes del fragmento coincidente a incluir (predeterminado: 2)   |
| `next_chunks`         | Número de fragmentos después del fragmento coincidente a incluir (predeterminado: 2) |
| `return_full_content` | Si devolver el contenido completo del documento (predeterminado: true)               |

### Uso Básico

Aquí hay un ejemplo simple de cómo recuperar documentos de Rememberizer usando LangChain:

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

## Establece tu clave API

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

## Inicializar el recuperador

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

## Obtener documentos relevantes para una consulta

docs = retriever.get\_relevant\_documents(query="¿Cómo funcionan las incrustaciones vectoriales?")

## Mostrar el primer documento

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

````

### Comprendiendo la Estructura del Documento

Cada documento devuelto por el recuperador tiene:

- `page_content`: El contenido de texto del fragmento de documento coincidente
- `metadata`: Información adicional sobre el documento

Ejemplo de la estructura de metadatos:

```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'}
}
````

### Ejemplos Avanzados

#### Construyendo un Sistema de Preguntas y Respuestas RAG

Este ejemplo crea un sistema de preguntas y respuestas que recupera información de Rememberizer y utiliza GPT-3.5 para formular respuestas:

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

## Configurar claves API

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

## Inicializar el recuperador y el modelo de lenguaje

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

## Crear una cadena de QA de recuperación

qa\_chain = RetrievalQA.from\_chain\_type( llm=llm, chain\_type="stuff", # Método más simple - simplemente agrupar todos los documentos en el aviso retriever=retriever, return\_source\_documents=True )

## Haz una pregunta

response = qa\_chain.invoke({"query": "¿Qué es RAG en el contexto de la IA?"})

## Imprimir la respuesta

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

````

### Construyendo un Agente Conversacional con Memoria

Este ejemplo crea un agente conversacional que puede mantener el historial de la conversación:

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

## Crear la cadena conversacional

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

## Ejemplo de conversación

questions = \[ "¿Qué es RAG?", "¿Cómo lo utilizan los modelos de lenguaje grandes?", "¿Cuáles son las limitaciones de este enfoque?", ]

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

````

## Mejores Prácticas

### Optimización del Rendimiento de Recuperación

1. **Sé específico con las consultas**: Las consultas más específicas suelen dar mejores resultados
2. **Ajusta `top_k_results`**: Comienza con 3-5 resultados y ajusta según las necesidades de la aplicación
3. **Utiliza ventanas de contexto**: El recuperador incluye automáticamente contexto alrededor de los fragmentos coincidentes

### Consideraciones de Seguridad

1. **Protege tu clave API**: Almacénala de forma segura utilizando variables de entorno o herramientas de gestión de secretos
2. **Crea claves dedicadas**: Crea claves API separadas para diferentes aplicaciones
3. **Rota las claves regularmente**: Genera nuevas claves periódicamente y elimina las antiguas

### Patrones de Integración

1. **Procesamiento previo a la recuperación**: Considera el preprocesamiento de las consultas de los usuarios para mejorar la relevancia de la búsqueda
2. **Filtrado posterior a la recuperación**: Filtra o clasifica los documentos recuperados antes de pasarlos al LLM
3. **Búsqueda híbrida**: Combina Rememberizer con otros recuperadores utilizando `EnsembleRetriever`

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

## Crear recuperadores

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

## Crear un conjunto con puntuación ponderada

ensemble\_retriever = EnsembleRetriever( retrievers=\[rememberizer\_retriever, web\_retriever], weights=\[0.7, 0.3] # Los resultados de Rememberizer tienen mayor peso )

````

## Solución de problemas

### Problemas Comunes

1. **Errores de autenticación**: Verifica que tu clave API sea correcta y esté configurada adecuadamente
2. **No se devolvieron resultados**: Asegúrate de que tu Conocimiento Común contenga información relevante
3. **Limitación de tasa**: Ten en cuenta los límites de tasa de la API para aplicaciones de alto volumen

### Consejos de Depuración

- Establezca el modo de depuración de LangChain para ver llamadas a la API detalladas:
  ```python
  import langchain
  langchain.debug = True
````

* Examine los resultados de búsqueda en bruto antes de pasarlos a LLM para identificar problemas de recuperación

### Recursos Relacionados

* LangChain [Guía conceptual de Recuperadores](https://python.langchain.com/docs/concepts/#retrievers)
* LangChain [Guías prácticas de Recuperadores](https://python.langchain.com/docs/how_to/#retrievers)
* Rememberizer [Documentación de la API](https://docs.rememberizer.ai/developer/api-docs/)
* [Almacenes de Vectores](https://docs.rememberizer.ai/developer/vector-stores) en Rememberizer
* [Creando un GPT de Rememberizer](https://docs.rememberizer.ai/es/recursos-para-desarrolladores/integration-options/creating-a-rememberizer-gpt) - Un enfoque alternativo para la integración de IA