Integración de 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
.
Empezando
Requisitos
Antes de comenzar, necesitas:
Una cuenta de Rememberizer con Conocimiento Común creada
Una clave API para acceder a tu Conocimiento Común
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
:
Variable de Entorno: Establecer la variable de entorno
REMEMBERIZER_API_KEY
import os os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"
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:
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:
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
LangChain Guía conceptual de Recuperadores
LangChain Guías prácticas de Recuperadores
Rememberizer Documentación de la API
Almacenes de Vectores en Rememberizer
Creando un GPT de Rememberizer - Un enfoque alternativo para la integración de IA
Last updated