fix

app.py

@@ -1,16 +1,22 @@
-# app.py - v1.1
+# app.py - v1.2
 # Beschreibung: State-of-the-Art RAG-Pipeline mit Gemma-3, FAISS,
 #               semantischem Chunking und Streaming-Antworten.
+#               (Fix: Korrekte FAISS-Indexierung mit langchain.Document)
 
 import os
 import torch
 import gradio as gr
 
-from typing import List, Tuple, Dict, Generator
+from typing import List, Tuple, Generator, Dict
+from threading import Thread
 
+# ML / Transformers
 from sentence_transformers import SentenceTransformer
 from transformers import AutoProcessor, Gemma3ForConditionalGeneration, TextStreamer
+
+# Dokumentenverarbeitung & RAG
 from pypdf import PdfReader
+from langchain_core.documents import Document
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_community.vectorstores import FAISS
 
@@ -77,14 +83,14 @@ def extract_text_from_file(path: str) -> str:
             return f.read()
 
     if ext == ".pdf":
-        text = []
+        text_parts = []
         try:
             reader = PdfReader(path)
             for page in reader.pages:
                 page_text = page.extract_text()
                 if page_text:
-                    text.append(page_text)
-            return "\n\n".join(text) # Seiten mit Doppel-Zeilenumbruch trennen
+                    text_parts.append(page_text)
+            return "\n\n".join(text_parts)
         except Exception as e:
             print(f"Fehler beim Lesen von PDF {path}: {e}")
             return ""
@@ -120,55 +126,45 @@ def index_files(file_paths: List[str], progress=gr.Progress(track_tqdm=True)) ->
     embed_model = get_embedding_model()
     text_splitter = get_text_splitter()
 
-    all_chunks = []
-    all_metadatas = []
+    documents: List[Document] = []
+    for path in progress.tqdm(file_paths, desc="1/2: Dateien verarbeiten & chunken"):
+        if path is None: continue
 
-    for path in progress.tqdm(file_paths, desc="Dateien verarbeiten"):
-        if path is None:
-            continue
         text = extract_text_from_file(path)
-        if not text.strip():
-            continue
+        if not text.strip(): continue
 
         chunks = text_splitter.split_text(text)
-        if not chunks:
-            continue
+        if not chunks: continue
 
         source_name = os.path.basename(path)
         for chunk in chunks:
-            all_chunks.append(chunk)
-            all_metadatas.append({"source": source_name})
+            doc = Document(page_content=chunk, metadata={"source": source_name})
+            documents.append(doc)
 
-    if not all_chunks:
+    if not documents:
         return "Kein Text in den Dateien gefunden, der indexiert werden konnte."
 
-    # Embeddings in Batches erstellen für Effizienz
-    progress(0.7, desc="Embeddings erstellen...")
-    embeddings = embed_model.encode(all_chunks, show_progress_bar=True)
-
-    progress(0.9, desc="FAISS Index aufbauen...")
-    new_store = FAISS.from_texts_and_embeddings(
-        texts=list(zip(all_chunks, all_metadatas)), # Workaround to store metadata
-        embedding=embed_model, # Pass the model directly
-    )
+    progress(0.5, desc="2/2: Embeddings erstellen & FAISS Index aufbauen...")
 
-    # Workaround: Manually set texts and metadatas in FAISS index
-    new_store.index_to_docstore_id = {i: str(i) for i in range(len(all_chunks))}
-    new_store.docstore._dict = {str(i): gr.Document(page_content=all_chunks[i], metadata=all_metadatas[i]) for i in range(len(all_chunks))}
-    new_store.index.add(embeddings)
+    # FAISS.from_documents kümmert sich um Embedding und Indexierung
+    new_store = FAISS.from_documents(documents, embed_model)
 
     if VECTOR_STORE is None:
         VECTOR_STORE = new_store
     else:
-        VECTOR_STORE.merge_from(new_store)
+        # Fügt neue Dokumente zum bestehenden Index hinzu
+        VECTOR_STORE.add_documents(documents)
 
-    return f"Index aktualisiert: {len(VECTOR_STORE.index_to_docstore_id)} Chunks insgesamt."
+    return f"Index aktualisiert: {VECTOR_STORE.index.ntotal} Chunks insgesamt."
 
 
 def clear_index() -> str:
     """Leert den Vektorindex."""
     global VECTOR_STORE
     VECTOR_STORE = None
+    # Garbage Collection anstoßen, um Speicher freizugeben
+    import gc
+    gc.collect()
     return "Index geleert."
 
 
@@ -177,7 +173,7 @@ def retrieve_relevant_chunks(query: str, top_k: int = 5) -> List[Dict]:
     if VECTOR_STORE is None:
         return []
 
-    # FAISS gibt Dokumente mit Metadaten und Scores zurück
+    # similarity_search_with_score gibt Dokumente und L2-Distanz-Scores zurück
     results_with_scores = VECTOR_STORE.similarity_search_with_score(query, k=top_k)
 
     formatted_results = []
@@ -185,7 +181,7 @@ def retrieve_relevant_chunks(query: str, top_k: int = 5) -> List[Dict]:
         formatted_results.append({
             "content": doc.page_content,
             "source": doc.metadata.get("source", "Unbekannt"),
-            "score": 1 - score  # FAISS L2-Distanz -> Kosinus-Ähnlichkeit (ungefähr)
+            "score": 1 - score  # Konvertiert Distanz in eine Ähnlichkeits-Metrik
         })
     return formatted_results
 
@@ -225,10 +221,7 @@ def answer_with_rag(question: str, history: List[Tuple[str, str]]) -> Generator[
     model, processor = get_llm()
     streamer = TextStreamer(processor, skip_prompt=True, skip_special_tokens=True)
 
-    # 1. Retrieve
     retrieved = retrieve_relevant_chunks(question, top_k=5)
-
-    # 2. Prompt
     prompt = build_rag_prompt(question, retrieved)
     messages = [{"role": "user", "content": prompt}]
 
@@ -239,7 +232,6 @@ def answer_with_rag(question: str, history: List[Tuple[str, str]]) -> Generator[
         return_tensors="pt"
     ).to(model.device)
 
-    # 3. Generate
     generation_kwargs = dict(
         inputs,
         streamer=streamer,
@@ -249,12 +241,9 @@ def answer_with_rag(question: str, history: List[Tuple[str, str]]) -> Generator[
         top_p=0.9,
     )
 
-    # In einem Thread ausführen, um das UI nicht zu blockieren
-    from threading import Thread
     thread = Thread(target=model.generate, kwargs=generation_kwargs)
     thread.start()
 
-    # Streamer-Ausgabe an das UI weitergeben
     for new_text in streamer:
         yield new_text
 
@@ -266,7 +255,7 @@ def build_demo() -> gr.Blocks:
     with gr.Blocks(title="Gemma 3 RAG mit FAISS", theme="soft") as demo:
         gr.Markdown(
             """
-            # 🔍 Gemma 3 RAG v1.1 – mit FAISS & Streaming
+            # 🔍 Gemma 3 RAG v1.2 – mit FAISS & Streaming
             **Eine "State of the Art" RAG-Pipeline mit `google/embeddinggemma-300m` und `google/gemma-3-4b-it`**
             1.  Lade deine Dokumente hoch und klicke auf "Index aktualisieren".
             2.  Stelle deine Fragen im Chatfenster. Die Antworten werden live gestreamt.
@@ -316,21 +305,35 @@ def build_demo() -> gr.Blocks:
                     )
                     send_btn = gr.Button("Senden", variant="primary", scale=1)
 
-        def chat_interface(message, history):
-            if not message.strip():
+        def chat_interface(message: str, history: list):
+            if not message or not message.strip():
+                # Leere Eingaben ignorieren
                 return history
 
+            # Neue Nachricht zur History hinzufügen mit Platzhalter für Antwort
             history.append((message, ""))
 
-            # Stream die Antwort in das letzte Element der History
+            # Stream die LLM-Antwort in den Platzhalter
             for token in answer_with_rag(message, history):
                 history[-1] = (message, history[-1][1] + token)
                 yield history
 
-        # Event Listeners
-        msg_textbox.submit(chat_interface, [msg_textbox, chatbot], chatbot)
-        send_btn.click(chat_interface, [msg_textbox, chatbot], chatbot).then(
-            lambda: gr.update(value=""), outputs=msg_textbox
+        # Event Listeners für das Senden einer Nachricht
+        msg_textbox.submit(
+            fn=chat_interface,
+            inputs=[msg_textbox, chatbot],
+            outputs=chatbot,
+        ).then(
+            fn=lambda: gr.update(value=""), # Textbox leeren
+            outputs=msg_textbox
+        )
+        send_btn.click(
+            fn=chat_interface,
+            inputs=[msg_textbox, chatbot],
+            outputs=chatbot
+        ).then(
+            fn=lambda: gr.update(value=""), # Textbox leeren
+            outputs=msg_textbox
         )
 
     return demo
@@ -338,5 +341,5 @@ def build_demo() -> gr.Blocks:
 
 if __name__ == "__main__":
     app_demo = build_demo()
-    # Share=True erzeugt einen öffentlichen Link (nützlich für Colab/Remote)
+    # Share=True erzeugt einen öffentlichen Link, nützlich für Colab/Remote
     app_demo.launch(share=True)

requirements.txt

@@ -1,21 +1,18 @@
-# requirements.txt - v1.1
-# Beschreibung: Aktualisierte Abhängigkeiten für eine robustere RAG-Pipeline.
+# requirements.txt - v1.2
+# Beschreibung: Korrigierte und erweiterte Abhängigkeiten für eine robuste RAG-Pipeline.
 
 # Core ML/UI Frameworks
 gradio>=4.44.0
 transformers>=4.50.0
 torch>=2.1.0
 accelerate>=0.33.0
+bitsandbytes>=0.43.0
 
 # SentenceTransformers für EmbeddingGemma
 sentence-transformers>=5.0.0
 
-# Dokumentenverarbeitung
+# Dokumentenverarbeitung und Vektor-Datenbank
 pypdf>=5.0.0
 langchain-text-splitters>=0.2.0  # Für robustes, semantisches Chunking
-
-# Vektordatenbank (In-Memory)
-faiss-cpu>=1.8.0  # Effiziente Vektorsuche, CPU-Version ist für HF Spaces ideal
-
-# Optional, aber empfohlen für Quantisierung und Performance
-bitsandbytes>=0.43.0
+langchain-community>=0.2.0       # BENÖTIGT für FAISS-Wrapper und Document-Objekt
+faiss-cpu>=1.8.0                 # Effiziente Vektorsuche (CPU-Version)