Iniciar sesiónInscribirseContáctenos

Integración con LangChain

Aprende cómo integrar Rememberizer como un recuperador de LangChain para proporcionar a tu aplicación de LangChain acceso a una poderosa búsqueda en bases de datos vectoriales.

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.

LogoRememberizer | 🦜️🔗 LangChain

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.

Instalación

Instala los paquetes requeridos:

pip install langchain langchain_community

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

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

    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

    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:

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:

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

PreviousCreando un Rememberizer GPTNextAlmacenes de Vectores

Last updated