# Intégration LangChain

## 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`.

{% embed url="<https://python.langchain.com/docs/integrations/retrievers/rememberizer/>" %}

### 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](https://docs.rememberizer.ai/developer/registering-and-using-api-keys).

#### Installation

Installez les packages requis :

```bash
pip install langchain langchain_community
```

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

```bash
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`

   ```python
   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

   ```python
   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 :

```python
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 :

```python
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](https://python.langchain.com/docs/concepts/#retrievers)
* LangChain [Guides pratiques des Récupérateurs](https://python.langchain.com/docs/how_to/#retrievers)
* Rememberizer [Documentation de l'API](https://docs.rememberizer.ai/developer/api-docs/)
* [Magasins de Vecteurs](https://docs.rememberizer.ai/developer/vector-stores) dans Rememberizer
* [Créer un GPT Rememberizer](/fr/ressources-pour-les-developpeurs/integration-options/creating-a-rememberizer-gpt.md) - Une approche alternative pour l'intégration de l'IA


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.rememberizer.ai/fr/ressources-pour-les-developpeurs/integration-options/langchain-integration.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.