# 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](/es/recursos-para-desarrolladores/integration-options/creating-a-rememberizer-gpt.md) - Un enfoque alternativo para la integración de IA


---

# 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://docs.rememberizer.ai/es/recursos-para-desarrolladores/integration-options/langchain-integration.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.