README copy.md

---
title: RAG-LangChain-Gradio
app_file: rag_execute.py
sdk: gradio
sdk_version: 5.46.0
---
# Retrieval-Augmented Generation (RAG)

Dieses Projekt implementiert ein **Retrieval-Augmented Generation (RAG)**-System unter Verwendung von LangChain, Mistral/OpenAI LLMs und Pinecone für die Vektordatenbanksuche. Das System ermöglicht es, Dokumente abzufragen und kontextbewusste Antworten über eine Chat-ähnliche Schnittstelle zu generieren.

---

## Inhaltsverzeichnis

1. [Übersicht](#übersicht)
2. [Anforderungen](#anforderungen)
3. [Einrichtung](#einrichtung)
4. [Vorbereitung der API-Schlüssel](#vorbereitung-der-api-schlüssel)
5. [Erstellung des Pinecone-Indexes](#erstellung-des-pinecone-indexes)
6. [Ausführung des RAG-Systems](#ausführung-des-rag-systems)
7. [Code-Struktur](#code-struktur)
8. [Prozessbeschreibung](#prozessbeschreibung)
9. [Evaluation](#evaluation)

---

## Übersicht

Dieses RAG-System arbeitet in drei Schritten:

1. **Dokumente einbetten**: Rohtextdateien in Chunks aufteilen und mit dem `llama-text-embed-v2` Embedding-Modell in Pinecone einbetten.
2. **Abruf (Retrieval)**: Semantische Suche in der Pinecone-Vektordatenbank durchführen, um die relevantesten Chunks für eine Anfrage abzurufen.
3. **Generierung**: Übergabe der Anfrage und des abgerufenen Kontexts an ein LLM (Mistral oder OpenAI), um die Antwort zu generieren.

---

## Anforderungen

Python 3.10+ empfohlen.

Enthaltene Abhängigkeiten:

* `langchain-community`
* `langchain-core`
* `langchain-text-splitters`
* `langchain-mistralai`
* `langchain-openai`
* `ragas`
* `datasets`
* `pinecone-client`
* `gradio`
* `python-dotenv`
* `pypdf`
* `pandas`
* `nbformat`
* `nbconvert`
* `unstructured` (mit Extras für `docx`, `pptx`, `html`, `md`)

Alle Abhängigkeiten sollten installiert werden, z. B. mit dem folgenden Befehl.
```
pip install langchain-mistralai langchain-community datasets ragas langchain-openai langchain-text-splitters langchain-core pinecone-client langgraph pypdf gradio python-dotenv nbformat nbconvert "unstructured[docx,pptx,html,md]"
```
Da eine requirements.txt-Datei vorhanden ist, kann die Installation auch durch folgenden Befehl durchgeführt werden:
```
pip install -r requirements.txt
```
---

## Einrichtung

1. Repository klonen.
2. Erstellen Sie eine `.env`-Datei im Hauptverzeichnis mit den folgenden Schlüsseln:

```dotenv
MISTRAL_API_KEY=<Ihr-mistral-api-schlüssel>
OPENAI_API_KEY=<Ihr-openai-api-schlüssel>
PINECONE_API=<Ihr-pinecone-api-schlüssel>
INDEX_NAME=<Ihr-pinecone-index-name>
DIRNAME=<Pfad-zu-Kontextdokumenten>
MODELNAME=<LLM-Modellname>                
````

* `MISTRAL_API_KEY` – Ihr API-Schlüssel für Mistral-Modelle.
* `OPENAI_API_KEY` – Ihr API-Schlüssel für OpenAI-Modelle. Es reicht aus, einen der OpenAI-/Mistral-Schlüssel (je nach ausgewähltem Modell) festzulegen.
* `PINECONE_API` – API-Schlüssel für Pinecone, um Vektoren zu speichern und abzufragen.
* `INDEX_NAME` – Name des Pinecone-Indexes, in dem die Dokumente abgelegt werden.
* `DIRNAME` – Unterordner innerhalb des festen `context/`-Verzeichnisses.

  * Wenn leer (`DIRNAME=`), werden alle Dokumente in `context/` verarbeitet.
  * Beispiel: `DIRNAME=llm_context` verarbeitet nur `context/llm_context/`.
* `MODELNAME` – LLM-Modell, z. B. `gpt-5-nano` für OpenAI oder `mistral-large-latest` für Mistral.
---

## Vorbereitung der API-Schlüssel

### Mistral

1. Registrieren bei [Mistral AI](https://www.mistral.ai).
2. API-Schlüssel erstellen.
3. In `.env` unter `MISTRAL_API_KEY` eintragen.

### OpenAI

1. Registrieren bei [OpenAI](https://platform.openai.com/).
2. API-Schlüssel erstellen.
3. In `.env` unter `OPENAI_API_KEY` eintragen.

### Pinecone

1. Registrieren bei [Pinecone](https://www.pinecone.io/).
2. API-Schlüssel erstellen.
3. In `.env` unter `PINECONE_API` eintragen.
4. Einen **Index** erstellen (z. B. `use-cases-index`) mit dem Embedding-Modell `llama-text-embed-v2`.

---

## Erstellung des Pinecone-Indexes

Das RAG-Vorbereitungsskript (`rag_func.py`) führt automatisch folgende Schritte aus:

1. Verbindung zu Pinecone über den API-Schlüssel herstellen.
2. Dokumente aus dem Verzeichnis `DIRNAME` laden.
3. Dokumente in Chunks aufteilen mit `RecursiveCharacterTextSplitter` (Standard: 1800 Tokens pro Chunk, 200 Tokens Überlappung).
4. Chunks mit `llama-text-embed-v2` einbetten.
5. Einbettungen in Batches in den Pinecone-Index hochladen.

> **Tipp:** Wenn alle Dokumente bereits hochgeladen wurden, kann `DIRNAME` leer bleiben, und das System überspringt die Dokumentenverarbeitung.

---

## Ausführung des RAG-Systems

Hauptskript ausführen:

```bash
python rag_execute.py
```

Dies bewirkt:

1. Laden der Dokumente (falls vorhanden) und Vorbereitung des RAG-Systems.
2. Starten einer **Chat-Schnittstelle** mit Gradio, in der Sie Fragen stellen können.
3. Abrufen relevanter Chunks aus Pinecone.
4. Generieren von Antworten mit dem ausgewählten LLM.

### Chat-Schnittstelle

* Geben Sie eine Anfrage in das Textfeld ein.
* Das System ruft den Kontext ab und erstellt eine Antwort.
* Antworten werden im Chat-Format angezeigt.

---

## Code-Struktur

```
├─ rag_execute.py      # Hauptskript für RAG mit Gradio-Schnittstelle
├─ rag_func.py         # Funktionen für RAG-Vorbereitung, Abruf und Generierung
├─ .env                # Umgebungsvariablen (API-Schlüssel, Index, Modell, Verzeichnis)
├─ context/          # Ordner mit Rohdokumenten (kann leer sein, falls bereits hochgeladen)
```

---

## Prozessbeschreibung

1. **LLM auswählen**: Mistral oder OpenAI.
2. **Dokumente vorbereiten**:

   * Text- oder JSON-Dokumente in den Ordner `DIRNAME` legen.
   * Wenn alle Dokumente bereits hochgeladen sind, kann der Ordner leer bleiben.
3. **Pinecone-Index erstellen**:

   * Index in `.env` benennen (`INDEX_NAME`).
   * Embedding-Modell `llama-text-embed-v2` verwenden.
4. **Dokumente aufteilen**: Mit `RecursiveCharacterTextSplitter`.
5. **Chunks einbetten**: Zur semantischen Suche an Pinecone senden.
6. **Relevante Chunks abrufen**: Bei einer Anfrage.
7. **Antwort generieren**: Anfrage + Kontext an LLM übergeben.
8. **Ergebnis zurückgeben**: Im Chat-Interface anzeigen.

---

## Evaluation

Das System unterstützt Evaluation mit **RAGAS**:

1. `generate_dataset()` ruft Kontext ab und generiert Antworten.
2. `evaluate_RAG()` berechnet **Faithfulness** und andere Metriken.
3. Ergebnisse werden zur Analyse ausgegeben.

---

## Hinweise

* Retry-Logik für Pinecone-Operationen ist implementiert, um Netzwerkfehler abzufangen.
* Chunk-Größe und Überlappung können in `prepare_RAG()` für größere oder kleinere Kontextgranularität angepasst werden.

---

## Beispiel

```python
from rag_func import prepare_RAG, retrieve_RAG, generate_RAG
import os

index, pc, llm = prepare_RAG(
    pinecone_API=os.getenv("PINECONE_API"),
    index_name=os.getenv("INDEX_NAME"),
    llm_model=os.getenv("MODELNAME"),
    dir_name=os.getenv("DIRNAME")
)

query = "Liste typische Anwendungsfälle von GenAI im Telekommunikationsbereich auf."
retrieved_chunks = retrieve_RAG(query, pc, index)
response = generate_RAG(query, llm, retrieved_chunks)
print(response.content)
```

---

## Referenzen

* [LangChain RAG Tutorial](https://python.langchain.com/docs/tutorials/rag/)
* [Pinecone Dokumentation](https://docs.pinecone.io)
* [RAGAS Evaluation](https://docs.ragas.io/en/stable/getstarted/evals/)