LangChain-Integration

Erfahren Sie, wie Sie Rememberizer als LangChain-Retriever integrieren, um Ihrer LangChain-Anwendung Zugriff auf leistungsstarke Vektordatenbanksuchen zu ermöglichen.

LangChain-Integration

Rememberizer integriert sich mit LangChain über die Klasse RememberizerRetriever, die es Ihnen ermöglicht, die semantischen Suchfähigkeiten von Rememberizer einfach in Ihre von LangChain unterstützten Anwendungen einzubinden. Dieser Leitfaden erklärt, wie Sie diese Integration einrichten und verwenden, um fortschrittliche LLM-Anwendungen mit Zugriff auf Ihre Wissensdatenbank zu erstellen.

Einführung

LangChain ist ein beliebtes Framework zum Erstellen von Anwendungen mit großen Sprachmodellen (LLMs). Durch die Integration von Rememberizer mit LangChain können Sie:

• Ihre Rememberizer-Wissensdatenbank in RAG (Retrieval Augmented Generation)-Anwendungen nutzen

• Chatbots erstellen, die Zugriff auf Ihre Dokumente und Daten haben

• Frage-Antwort-Systeme entwickeln, die Ihr Wissen nutzen

• Agenten entwickeln, die über Ihre Informationen suchen und schlussfolgern können

Die Integration ist im Modul langchain_community.retrievers verfügbar.

Rememberizer | 🦜️🔗 LangChain

Erste Schritte

Voraussetzungen

Bevor Sie beginnen, benötigen Sie:

1. Ein Rememberizer-Konto mit Common Knowledge

2. Einen API-Schlüssel für den Zugriff auf Ihr Common Knowledge

3. Eine Python-Umgebung mit installiertem LangChain

Für detaillierte Anweisungen zur Erstellung von Common Knowledge und zur Generierung eines API-Schlüssels siehe Registrierung und Verwendung von API-Schlüsseln.

Installation

Installieren Sie die erforderlichen Pakete:

pip install langchain langchain_community

Wenn Sie planen, OpenAI-Modelle zu verwenden (wie in den folgenden Beispielen gezeigt):

pip install langchain_openai

Authentifizierungseinrichtung

Es gibt zwei Möglichkeiten, den RememberizerRetriever zu authentifizieren:

1. Umgebungsvariable: Setzen Sie die Umgebungsvariable REMEMBERIZER_API_KEY

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

2. Direkter Parameter: Übergeben Sie den API-Schlüssel direkt bei der Initialisierung des Retrievers

   retriever = RememberizerRetriever(rememberizer_api_key="rem_ck_your_api_key")

Konfigurationsoptionen

Die Klasse RememberizerRetriever akzeptiert diese Parameter:

Parameter	Typ	Standard	Beschreibung
top_k_results	int	10	Anzahl der Dokumente, die aus der Suche zurückgegeben werden
rememberizer_api_key	str	None	API-Schlüssel zur Authentifizierung (optional, wenn als Umgebungsvariable gesetzt)

Hinter den Kulissen führt der Retriever API-Aufrufe an den Suchendpunkt von Rememberizer mit zusätzlichen konfigurierbaren Parametern durch:

Erweiterter Parameter	Beschreibung
prev_chunks	Anzahl der Chunks vor dem übereinstimmenden Chunk, die einbezogen werden sollen (Standard: 2)
next_chunks	Anzahl der Chunks nach dem übereinstimmenden Chunk, die einbezogen werden sollen (Standard: 2)
return_full_content	Ob der gesamte Dokumentinhalt zurückgegeben werden soll (Standard: true)

Grundlegende Verwendung

Hier ist ein einfaches Beispiel zum Abrufen von Dokumenten von Rememberizer mit LangChain:

import os
from langchain_community.retrievers import RememberizerRetriever

# Setzen Sie Ihren API-Schlüssel
os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"

# Initialisiere den Abrufdienst
retriever = RememberizerRetriever(top_k_results=5)

# Holen Sie sich relevante Dokumente für eine Anfrage
docs = retriever.get_relevant_documents(query="Wie funktionieren Vektor-Embeddings?")

# Zeige das erste Dokument an
if docs:
    print(f"Dokument: {docs[0].metadata['name']}")
    print(f"Inhalt: {docs[0].page_content[:200]}...")

Verständnis der Dokumentstruktur

Jedes Dokument, das vom Retriever zurückgegeben wird, hat:

• page_content: Der Textinhalt des übereinstimmenden Dokumentchunks

• metadata: Zusätzliche Informationen über das Dokument

Beispiel für die Metadatenstruktur:

{
  'id': 13646493,
  'document_id': '17s3LlMbpkTk0ikvGwV0iLMCj-MNubIaP',
  'name': 'Was ist ein großes Sprachmodell (LLM)_ _ Cloudflare.pdf',
  'type': 'application/pdf',
  'path': '/langchain/Was ist ein großes Sprachmodell (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'}
}

Fortgeschrittene Beispiele

Aufbau eines RAG-Frage-Antwort-Systems

Dieses Beispiel erstellt ein Frage-Antwort-System, das Informationen von Rememberizer abruft und GPT-3.5 verwendet, um Antworten zu formulieren:

import os
from langchain_community.retrievers import RememberizerRetriever
from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI

API-Schlüssel einrichten

os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key" os.environ["OPENAI_API_KEY"] = "your_openai_api_key"

Initialisiere den Retriever und das Sprachmodell

retriever = RememberizerRetriever(top_k_results=5) llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)

Erstelle eine Retrieval QA-Kette

qa_chain = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", # Einfachste Methode - alle Dokumente einfach in den Prompt stopfen retriever=retriever, return_source_documents=True )

Stelle eine Frage

response = qa_chain.invoke({"query": "Was ist RAG im Kontext von KI?"})

Drucke die Antwort

print(f"Antwort: {response['result']}") print("\nQuellen:") for idx, doc in enumerate(response['source_documents']): print(f"{idx+1}. {doc.metadata['name']}")

### Erstellung eines Konversationsagenten mit Gedächtnis

Dieses Beispiel erstellt einen Konversationsagenten, der den Gesprächsverlauf beibehalten kann:

```python
import os
from langchain_community.retrievers import RememberizerRetriever
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI

API-Schlüssel einrichten

os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key" os.environ["OPENAI_API_KEY"] = "your_openai_api_key"

Komponenten initialisieren

retriever = RememberizerRetriever(top_k_results=5) llm = ChatOpenAI(model_name="gpt-3.5-turbo") memory = ConversationBufferMemory( memory_key="chat_history", return_messages=True )

Erstellen Sie die Konversationskette

conversation = ConversationalRetrievalChain.from_llm( llm=llm, retriever=retriever, memory=memory )

Beispielkonversation

questions = [ "Was ist RAG?", "Wie nutzen große Sprachmodelle es?", "Was sind die Einschränkungen dieses Ansatzes?", ]

for question in questions: response = conversation.invoke({"question": question}) print(f"Frage: {question}") print(f"Antwort: {response['answer']}\n")

## Beste Praktiken

### Optimierung der Abrufleistung

1. **Seien Sie spezifisch mit Abfragen**: Spezifischere Abfragen führen in der Regel zu besseren Ergebnissen
2. **Passen Sie `top_k_results` an**: Beginnen Sie mit 3-5 Ergebnissen und passen Sie sie basierend auf den Anforderungen der Anwendung an
3. **Verwenden Sie Kontextfenster**: Der Abrufmechanismus schließt automatisch den Kontext um die übereinstimmenden Abschnitte ein

### Sicherheitsüberlegungen

1. **Schützen Sie Ihren API-Schlüssel**: Bewahren Sie ihn sicher auf, indem Sie Umgebungsvariablen oder Geheimnisverwaltungs-Tools verwenden
2. **Erstellen Sie dedizierte Schlüssel**: Erstellen Sie separate API-Schlüssel für verschiedene Anwendungen
3. **Drehen Sie Schlüssel regelmäßig**: Generieren Sie regelmäßig neue Schlüssel und phasen Sie alte aus

### Integrationsmuster

1. **Vorabverarbeitung**: Erwägen Sie die Vorverarbeitung von Benutzeranfragen, um die Relevanz der Suche zu verbessern
2. **Nachverarbeitungsfilterung**: Filtern oder bewerten Sie die abgerufenen Dokumente, bevor Sie sie an das LLM übergeben
3. **Hybride Suche**: Kombinieren Sie Rememberizer mit anderen Abrufsystemen unter Verwendung von `EnsembleRetriever`

```python
from langchain.retrievers import EnsembleRetriever
from langchain_community.retrievers import RememberizerRetriever, WebResearchRetriever

Erstelle Abrufgeräte

rememberizer_retriever = RememberizerRetriever(top_k_results=3) web_retriever = WebResearchRetriever(...) # Konfiguriere ein weiteres Abrufgerät

Erstellen Sie ein Ensemble mit gewichtetem Score

ensemble_retriever = EnsembleRetriever( retrievers=[rememberizer_retriever, web_retriever], weights=[0.7, 0.3] # Rememberizer-Ergebnisse haben ein höheres Gewicht )

## Fehlersuche

### Häufige Probleme

1. **Authentifizierungsfehler**: Überprüfen Sie, ob Ihr API-Schlüssel korrekt und richtig konfiguriert ist
2. **Keine Ergebnisse zurückgegeben**: Stellen Sie sicher, dass Ihr Gemeinsames Wissen relevante Informationen enthält
3. **Ratenbegrenzung**: Achten Sie auf die API-Ratenlimits für Anwendungen mit hohem Volumen

### Debug-Tipps

- Setzen Sie den LangChain-Debug-Modus, um detaillierte API-Aufrufe zu sehen:
  ```python
  import langchain
  langchain.debug = True

• Überprüfen Sie die Rohsuchergebnisse, bevor Sie sie an LLM weitergeben, um Abrufprobleme zu identifizieren

Verwandte Ressourcen

• LangChain Retriever konzeptioneller Leitfaden
• LangChain Retriever Anleitungen
• Rememberizer API-Dokumentation
• Vektor-Speicher in Rememberizer
• Erstellen eines Rememberizer GPT - Ein alternativer Ansatz für die KI-Integration