Intégration LangChain
Apprenez à intégrer Rememberizer en tant que récupérateur LangChain pour fournir à votre application LangChain un accès à une recherche puissante dans une base de données vectorielle.
Intégration LangChain
Rememberizer s'intègre à LangChain via la classe RememberizerRetriever, vous permettant d'incorporer facilement les capacités de recherche sémantique de Rememberizer dans vos applications alimentées par LangChain. Ce guide explique comment configurer et utiliser cette intégration pour construire des applications LLM avancées avec accès à votre base de connaissances.
Introduction
LangChain est un cadre populaire pour construire des applications avec de grands modèles de langage (LLMs). En intégrant Rememberizer avec LangChain, vous pouvez :
Utiliser votre base de connaissances Rememberizer dans des applications RAG (Génération Augmentée par Récupération)
Créer des chatbots ayant accès à vos documents et données
Construire des systèmes de questions-réponses qui tirent parti de vos connaissances
Développer des agents capables de rechercher et de raisonner sur vos informations
L'intégration est disponible dans le module langchain_community.retrievers.
Commencer
Prérequis
Avant de commencer, vous avez besoin de :
Un compte Rememberizer avec Common Knowledge créé
Une clé API pour accéder à votre Common Knowledge
Un environnement Python avec LangChain installé
Pour des instructions détaillées sur la création de Common Knowledge et la génération d'une clé API, consultez Enregistrement et utilisation des clés API.
Installation
Installez les packages requis :
pip install langchain langchain_communitySi vous prévoyez d'utiliser les modèles OpenAI (comme montré dans les exemples ci-dessous) :
pip install langchain_openaiConfiguration de l'authentification
Il existe deux façons d'authentifier le RememberizerRetriever :
Variable d'environnement : Définissez la variable d'environnement
REMEMBERIZER_API_KEYimport os os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"Paramètre direct : Passez la clé API directement lors de l'initialisation du récupérateur
retriever = RememberizerRetriever(rememberizer_api_key="rem_ck_your_api_key")
Options de Configuration
La classe RememberizerRetriever accepte ces paramètres :
top_k_results
int
10
Nombre de documents à retourner à partir de la recherche
rememberizer_api_key
str
None
Clé API pour l'authentification (optionnelle si définie comme variable d'environnement)
En coulisses, le récupérateur effectue des appels API au point de terminaison de recherche de Rememberizer avec des paramètres configurables supplémentaires :
prev_chunks
Nombre de morceaux avant le morceau correspondant à inclure (par défaut : 2)
next_chunks
Nombre de morceaux après le morceau correspondant à inclure (par défaut : 2)
return_full_content
Indique s'il faut retourner le contenu complet du document (par défaut : true)
Utilisation de base
Voici un exemple simple de récupération de documents depuis Rememberizer en utilisant LangChain :
import os
from langchain_community.retrievers import RememberizerRetrieverDéfinissez votre clé API
os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"
Initialiser le récupérateur
retriever = RememberizerRetriever(top_k_results=5)
Obtenir des documents pertinents pour une requête
docs = retriever.get_relevant_documents(query="Comment fonctionnent les embeddings vectoriels ?")
Afficher le premier document
if docs: print(f"Document : {docs[0].metadata['name']}") print(f"Contenu : {docs[0].page_content[:200]}...")
### Comprendre la structure des documents
Chaque document renvoyé par le récupérateur a :
- `page_content`: Le contenu textuel du morceau de document correspondant
- `metadata`: Informations supplémentaires sur le document
Exemple de structure de métadonnées :
```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'}
}Exemples Avancés
Construire un système de questions-réponses RAG
Cet exemple crée un système de questions-réponses qui récupère des informations de Rememberizer et utilise GPT-3.5 pour formuler des réponses :
import os
from langchain_community.retrievers import RememberizerRetriever
from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAIConfigurer les clés API
os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key" os.environ["OPENAI_API_KEY"] = "your_openai_api_key"
Initialiser le récupérateur et le modèle de langage
retriever = RememberizerRetriever(top_k_results=5) llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)
Créer une chaîne QA de récupération
qa_chain = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", # Méthode la plus simple - il suffit de mettre tous les documents dans l'invite retriever=retriever, return_source_documents=True )
Posez une question
response = qa_chain.invoke({"query": "Qu'est-ce que RAG dans le contexte de l'IA ?"})
Imprimer la réponse
print(f"Réponse : {response['result']}") print("\nSources :") for idx, doc in enumerate(response['source_documents']): print(f"{idx+1}. {doc.metadata['name']}")
### Construire un Agent Conversationnel avec Mémoire
Cet exemple crée un agent conversationnel capable de maintenir l'historique des conversations :
```python
import os
from langchain_community.retrievers import RememberizerRetriever
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAIConfigurer les clés API
os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key" os.environ["OPENAI_API_KEY"] = "your_openai_api_key"
Initialiser les composants
retriever = RememberizerRetriever(top_k_results=5) llm = ChatOpenAI(model_name="gpt-3.5-turbo") memory = ConversationBufferMemory( memory_key="chat_history", return_messages=True )
Créer la chaîne conversationnelle
conversation = ConversationalRetrievalChain.from_llm( llm=llm, retriever=retriever, memory=memory )
Exemple de conversation
questions = [ "Qu'est-ce que RAG ?", "Comment les grands modèles de langage l'utilisent-ils ?", "Quelles sont les limitations de cette approche ?", ]
for question in questions: response = conversation.invoke({"question": question}) print(f"Question : {question}") print(f"Réponse : {response['answer']}\n")
## Meilleures Pratiques
### Optimiser la performance de récupération
1. **Soyez spécifique avec les requêtes** : Des requêtes plus spécifiques donnent généralement de meilleurs résultats
2. **Ajustez `top_k_results`** : Commencez avec 3-5 résultats et ajustez en fonction des besoins de l'application
3. **Utilisez des fenêtres de contexte** : Le récupérateur inclut automatiquement le contexte autour des morceaux correspondants
### Considérations de sécurité
1. **Protégez votre clé API** : Stockez-la en toute sécurité en utilisant des variables d'environnement ou des outils de gestion des secrets
2. **Créez des clés dédiées** : Créez des clés API séparées pour différentes applications
3. **Faites tourner les clés régulièrement** : Générez périodiquement de nouvelles clés et éliminez les anciennes
### Modèles d'intégration
1. **Traitement pré-recherche** : Envisagez de prétraiter les requêtes des utilisateurs pour améliorer la pertinence de la recherche
2. **Filtrage post-recherche** : Filtrer ou classer les documents récupérés avant de les transmettre au LLM
3. **Recherche hybride** : Combiner Rememberizer avec d'autres récupérateurs en utilisant `EnsembleRetriever`
```python
from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import RememberizerRetriever, WebResearchRetrieverCréer des récupérateurs
rememberizer_retriever = RememberizerRetriever(top_k_results=3) web_retriever = WebResearchRetriever(...) # Configurer un autre récupérateur
Créer un ensemble avec un score pondéré
ensemble_retriever = EnsembleRetriever( retrievers=[rememberizer_retriever, web_retriever], weights=[0.7, 0.3] # Les résultats de Rememberizer ont un poids plus élevé )
## Dépannage
### Problèmes courants
1. **Erreurs d'authentification** : Vérifiez que votre clé API est correcte et correctement configurée
2. **Aucun résultat retourné** : Assurez-vous que votre Connaissance Commune contient des informations pertinentes
3. **Limitation de débit** : Soyez conscient des limites de débit de l'API pour les applications à fort volume
### Conseils de Débogage
- Activez le mode débogage de LangChain pour voir les appels API détaillés :
```python
import langchain
langchain.debug = TrueExaminez les résultats de recherche bruts avant de les transmettre à LLM pour identifier les problèmes de récupération
Ressources Associées
LangChain Guide conceptuel des Récupérateurs
LangChain Guides pratiques des Récupérateurs
Rememberizer Documentation de l'API
Magasins de Vecteurs dans Rememberizer
Créer un GPT Rememberizer - Une approche alternative pour l'intégration de l'IA
Last updated