--- 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= OPENAI_API_KEY= PINECONE_API= INDEX_NAME= DIRNAME= MODELNAME= ```` * `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/)