Hugging Face's logo

Spaces:
yadayana
/
Knowledge-Graph-Visualization
Sleeping

App Files Community
Knowledge-Graph-Visualization / README copy.md
Nadezhda Komarova
first commit
4be6b01
preview code
|
raw
history blame contribute delete
7.41 kB

A newer version of the Gradio SDK is available: 6.14.0

Upgrade
metadata 
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
  2. Anforderungen
  3. Einrichtung
  4. Vorbereitung der API-Schlüssel
  5. Erstellung des Pinecone-Indexes
  6. Ausführung des RAG-Systems
  7. Code-Struktur
  8. Prozessbeschreibung
  9. 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:
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.
  2. API-Schlüssel erstellen.
  3. In .env unter MISTRAL_API_KEY eintragen.

OpenAI

  1. Registrieren bei OpenAI.
  2. API-Schlüssel erstellen.
  3. In .env unter OPENAI_API_KEY eintragen.

Pinecone

  1. Registrieren bei Pinecone.
  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:

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 

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