# LangChain-Integration

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

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

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

#### Installation

Installieren Sie die erforderlichen Pakete:

```bash
pip install langchain langchain_community
```

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

```bash
pip install langchain_openai
```

#### Authentifizierungseinrichtung

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

1. **Umgebungsvariable**: Setzen Sie die Umgebungsvariable `REMEMBERIZER_API_KEY`

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

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

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

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

```python
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](https://python.langchain.com/docs/concepts/#retrievers)
* LangChain [Retriever Anleitungen](https://python.langchain.com/docs/how_to/#retrievers)
* Rememberizer [API-Dokumentation](https://docs.rememberizer.ai/developer/api-docs/)
* [Vektor-Speicher](https://docs.rememberizer.ai/developer/vector-stores) in Rememberizer
* [Erstellen eines Rememberizer GPT](https://docs.rememberizer.ai/de/entwicklerressourcen/integration-options/creating-a-rememberizer-gpt) - Ein alternativer Ansatz für die KI-Integration