Rememberizer Docs
Se connecterS'inscrireContactez-nous
Français
Français
  • Pourquoi Rememberizer ?
  • Contexte
    • Qu'est-ce que les embeddings vectoriels et les bases de données vectorielles ?
    • Glossaire
    • Terminologie standardisée
  • Utilisation personnelle
    • Commencer
      • Rechercher vos connaissances
      • Accès au filtre de souvenirs
      • Connaissances communes
      • Gérer vos connaissances intégrées
  • Intégrations
    • Application Rememberizer
    • Intégration Rememberizer Slack
    • Intégration Rememberizer Google Drive
    • Intégration Rememberizer Dropbox
    • Intégration Rememberizer Gmail
    • Intégration Rememberizer Memory
    • Serveurs MCP Rememberizer
    • Gérer les applications tierces
  • Ressources pour les développeurs
    • Aperçu des développeurs
  • Options d'intégration
    • Enregistrement et utilisation des clés API
    • Enregistrement des applications Rememberizer
    • Autorisation des applications Rememberizer
    • Création d'un GPT Rememberizer
    • Intégration LangChain
    • Magasins de vecteurs
    • Talk-to-Slack l'application Web d'exemple
  • Intégration d'entreprise
    • Modèles d'intégration d'entreprise
  • Référence API
    • Accueil de la documentation API
    • Authentification
  • APIs principales
    • Rechercher des documents par similarité sémantique
    • Récupérer des documents
    • Récupérer le contenu des documents
    • Récupérer le contenu Slack
    • Mémoriser le contenu dans Rememberizer
  • Compte & Configuration
    • Récupérer les détails du compte utilisateur actuel
    • Lister les intégrations de sources de données disponibles
    • Mementos
    • Obtenir toutes les connaissances publiques ajoutées
  • APIs de stockage vectoriel
    • Documentation sur le stockage vectoriel
    • Obtenir des informations sur le stockage vectoriel
    • Obtenir une liste de documents dans un stockage vectoriel
    • Obtenir des informations sur un document
    • Ajouter un nouveau document texte à un stockage vectoriel
    • Télécharger des fichiers dans un stockage vectoriel
    • Mettre à jour le contenu d'un fichier dans un stockage vectoriel
    • Supprimer un document dans le stockage vectoriel
    • Rechercher des documents de stockage vectoriel par similarité sémantique
  • Ressources supplémentaires
    • Avis
      • Conditions d'utilisation
      • Politique de confidentialité
      • B2B
        • À propos de Reddit Agent
  • Versions
    • Notes de version Accueil
  • Sorties 2025
    • 25 avr. 2025
    • 18 avr. 2025
    • 11 avr. 2025
    • 4 avr. 2025
    • 28 mar. 2025
    • 21 mar. 2025
    • 14 mar. 2025
    • 17 janv. 2025
  • Sorties 2024
    • 27 déc. 2024
    • 20 déc. 2024
    • 13 déc. 2024
    • 6 déc. 2024
  • 29 nov. 2024
  • 22 nov. 2024
  • 15 nov. 2024
  • 8 nov. 2024
  • 1er nov. 2024
  • 25 oct. 2024
  • 18 oct. 2024
  • 11 oct. 2024
  • 4 oct. 2024
  • 27 sept. 2024
  • 20 sept. 2024
  • 13 sept. 2024
  • 16 août 2024
  • 9 août 2024
  • 2 août 2024
  • 26 juil. 2024
  • 12 juil. 2024
  • 28 juin 2024
  • 14 juin 2024
  • 31 mai 2024
  • 17 mai 2024
  • 10 mai 2024
  • 26 avr. 2024
  • 19 avr. 2024
  • 12 avr. 2024
  • 5 avr. 2024
  • 25 mars 2024
  • 18 mars 2024
  • 11 mars 2024
  • 4 mars 2024
  • 26 févr. 2024
  • 19 févr. 2024
  • 12 févr. 2024
  • 5 févr. 2024
  • 29 janv. 2024
  • 22 janv. 2024
  • 15 janv. 2024
  • Documentation LLM
    • Documentation LLM Prête de Rememberizer
Powered by GitBook
On this page
  • Intégration LangChain
  • Introduction
  • Commencer
  • Options de Configuration
  • Utilisation de base
  • Définissez votre clé API
  • Initialiser le récupérateur
  • Obtenir des documents pertinents pour une requête
  • Afficher le premier document
  • Exemples Avancés
  • Configurer les clés API
  • Initialiser le récupérateur et le modèle de langage
  • Créer une chaîne QA de récupération
  • Posez une question
  • Imprimer la réponse
  • Configurer les clés API
  • Initialiser les composants
  • Créer la chaîne conversationnelle
  • Exemple de conversation
  • Créer des récupérateurs
  • Créer un ensemble avec un score pondéré
  • Ressources Associées
  1. Options d'intégration

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.

PreviousCréation d'un GPT RememberizerNextMagasins de vecteurs

Last updated 22 days ago

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 :

  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é

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

Pour des instructions détaillées sur la création de Common Knowledge et la génération d'une clé API, consultez .

LangChain

LangChain

Rememberizer

dans Rememberizer

- Une approche alternative pour l'intégration de l'IA

Enregistrement et utilisation des clés API
Guide conceptuel des Récupérateurs
Guides pratiques des Récupérateurs
Documentation de l'API
Magasins de Vecteurs
Créer un GPT Rememberizer
Rememberizer | 🦜️🔗 LangChain
Logo