# 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](/de/entwicklerressourcen/integration-options/creating-a-rememberizer-gpt.md) - Ein alternativer Ansatz für die KI-Integration


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.rememberizer.ai/de/entwicklerressourcen/integration-options/langchain-integration.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.