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.

https://python.langchain.com/docs/integrations/retrievers/rememberizer/

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_community

Si vous prévoyez d'utiliser les modèles OpenAI (comme montré dans les exemples ci-dessous) :

pip install langchain_openai

Configuration de l'authentification¶

Il existe deux façons d'authentifier le RememberizerRetriever :

Variable d'environnement : Définissez la variable d'environnement REMEMBERIZER_API_KEY
```
import 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 :

Paramètre	Type	Par défaut	Description
`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 :

Paramètre Avancé	Description
`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 RememberizerRetriever

Dé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 ChatOpenAI

Configurer 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 ChatOpenAI

Configurer 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, WebResearchRetriever

Cré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¶

Erreurs d'authentification : Vérifiez que votre clé API est correcte et correctement configurée
Aucun résultat retourné : Assurez-vous que votre Connaissance Commune contient des informations pertinentes
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 = True
Examinez 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