Rememberizer Docs
anmeldenMelden Sie sich anKontaktiere uns
Deutsch
Deutsch
  • Warum Rememberizer?
  • Hintergrund
    • Was sind Vektor-Embeddings und Vektor-Datenbanken?
    • Glossar
    • Standardisierte Terminologie
  • Persönliche Nutzung
    • Erste Schritte
      • Durchsuche dein Wissen
      • Zugriff auf Mementos-Filter
      • Allgemeines Wissen
      • Verwalte dein eingebettetes Wissen
  • Integrationen
    • Rememberizer App
    • Rememberizer Slack-Integration
    • Rememberizer Google Drive-Integration
    • Rememberizer Dropbox-Integration
    • Rememberizer Gmail-Integration
    • Rememberizer Memory-Integration
    • Rememberizer MCP-Server
    • Drittanbieter-Apps verwalten
  • Entwicklerressourcen
    • Entwicklerübersicht
  • Integrationsoptionen
    • Registrierung und Verwendung von API-Schlüsseln
    • Registrierung von Rememberizer-Apps
    • Autorisierung von Rememberizer-Apps
    • Erstellung eines Rememberizer GPT
    • LangChain-Integration
    • Vektor-Speicher
    • Talk-to-Slack die Beispiel-Webanwendung
  • Unternehmensintegration
    • Muster der Unternehmensintegration
  • API-Referenz
    • API-Dokumentation Startseite
    • Authentifizierung
  • Kern-APIs
    • Dokumente nach semantischer Ähnlichkeit suchen
    • Dokumente abrufen
    • Inhalte von Dokumenten abrufen
    • Slack-Inhalte abrufen
    • Inhalte an Rememberizer merken
  • Konto & Konfiguration
    • Aktuelle Kontodetails des Benutzers abrufen
    • Verfügbare Datenquellenintegrationen auflisten
    • Mementos
    • Alle hinzugefügten öffentlichen Kenntnisse abrufen
  • Vektor-Speicher-APIs
    • Dokumentation zum Vektor-Speicher
    • Vektor-Speicherinformationen abrufen
    • Liste der Dokumente in einem Vektor-Speicher abrufen
    • Dokumentinformationen abrufen
    • Neues Textdokument zu einem Vektor-Speicher hinzufügen
    • Dateien in einen Vektor-Speicher hochladen
    • Dateiinhalte in einem Vektor-Speicher aktualisieren
    • Ein Dokument im Vektor-Speicher entfernen
    • Nach Dokumenten im Vektor-Speicher anhand semantischer Ähnlichkeit suchen
  • Zusätzliche Ressourcen
    • Hinweise
      • Nutzungsbedingungen
      • Datenschutzrichtlinie
      • B2B
        • Über Reddit Agent
  • Veröffentlichungen
    • Versionshinweise Startseite
  • 2025 Veröffentlichungen
    • 25. Apr 2025
    • 18. Apr 2025
    • 11. Apr 2025
    • 4. Apr 2025
    • 28. Mär 2025
    • 21. Mär 2025
    • 14. Mär 2025
    • 17. Jan 2025
  • 2024 Veröffentlichungen
    • 27. Dez 2024
    • 20. Dez 2024
    • 13. Dez 2024
    • 6. Dez 2024
  • 29. Nov 2024
  • 22. Nov 2024
  • 15. Nov 2024
  • 8. Nov 2024
  • 1. Nov 2024
  • 25. Okt 2024
  • 18. Okt 2024
  • 11. Okt 2024
  • 4. Okt 2024
  • 27. Sep 2024
  • 20. Sep 2024
  • 13. Sep 2024
  • 16. Aug 2024
  • 9. Aug 2024
  • 2. Aug 2024
  • 26. Juli 2024
  • 12. Juli 2024
  • 28. Juni 2024
  • 14. Juni 2024
  • 31. Mai 2024
  • 17. Mai 2024
  • 10. Mai 2024
  • 26. Apr 2024
  • 19. Apr 2024
  • 12. Apr 2024
  • 5. Apr 2024
  • 25. März 2024
  • 18. März 2024
  • 11. März 2024
  • 4. März 2024
  • 26. Feb 2024
  • 19. Feb 2024
  • 12. Feb 2024
  • 5. Feb 2024
  • 29. Jan 2024
  • 22. Jan 2024
  • 15. Jan 2024
  • LLM-Dokumentation
    • Rememberizer LLM Bereit Dokumentation
Powered by GitBook
On this page
  • LangChain-Integration
  • Einführung
  • Erste Schritte
  • Konfigurationsoptionen
  • Grundlegende Verwendung
  • Fortgeschrittene Beispiele
  • API-Schlüssel einrichten
  • Initialisiere den Retriever und das Sprachmodell
  • Erstelle eine Retrieval QA-Kette
  • Stelle eine Frage
  • Drucke die Antwort
  • API-Schlüssel einrichten
  • Komponenten initialisieren
  • Erstellen Sie die Konversationskette
  • Beispielkonversation
  • Erstelle Abrufgeräte
  • Erstellen Sie ein Ensemble mit gewichtetem Score
  • Verwandte Ressourcen
  1. Integrationsoptionen

LangChain-Integration

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

PreviousErstellung eines Rememberizer GPTNextVektor-Speicher

Last updated 22 days ago

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:

  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

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

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

LangChain

LangChain

Rememberizer

in Rememberizer

- Ein alternativer Ansatz für die KI-Integration

Registrierung und Verwendung von API-Schlüsseln
Retriever konzeptioneller Leitfaden
Retriever Anleitungen
API-Dokumentation
Vektor-Speicher
Erstellen eines Rememberizer GPT
Rememberizer | 🦜️🔗 LangChain
Logo