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.

Rememberizer - Docs by LangChainDocs by LangChain

Commencer

Prérequis

Avant de commencer, vous avez besoin de :

1. Un compte Rememberizer avec Common Knowledge créé

2. Une clé API pour accéder à votre Common Knowledge

3. 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 :

1. Variable d'environnement : Définissez la variable d'environnement REMEMBERIZER_API_KEY

   import os
   os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"

2. 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

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 = 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