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.
Erste Schritte
Voraussetzungen
Bevor Sie beginnen, benötigen Sie:
Ein Rememberizer-Konto mit Common Knowledge
Einen API-Schlüssel für den Zugriff auf Ihr Common Knowledge
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:
Umgebungsvariable: Setzen Sie die Umgebungsvariable
REMEMBERIZER_API_KEY
import os os.environ["REMEMBERIZER_API_KEY"] = "rem_ck_your_api_key"
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:
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:
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 Dokumentchunksmetadata
: 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
Last updated