Update app.py

app.py

@@ -1,104 +1,43 @@
+import faiss
+import numpy as np
+from sentence_transformers import SentenceTransformer
 import gradio as gr
-from langchain.vectorstores import Chroma
-from langchain.document_loaders import PyPDFLoader
-from langchain.embeddings import HuggingFaceEmbeddings
-from transformers import LayoutLMv3Processor, AutoModelForTokenClassification
-from langchain.chains import RetrievalQA
-from langchain.prompts import PromptTemplate
-import fitz  # PyMuPDF
-import os
 
-# Funktion zur Textextraktion mit PyMuPDF (fitz)
-def extract_text_from_pdf(pdf_path):
-    try:
-        doc = fitz.open(pdf_path)
-        text_pages = []
-        for page_num in range(len(doc)):
-            page = doc.load_page(page_num)
-            text = page.get_text("text")  # Extrahiert Text als normalen Text
-            text_pages.append(text)
-        return text_pages
-    except Exception as e:
-        print(f"Fehler bei der Textextraktion: {e}")
-        return []
+# Schritt 1: Lade das Modell für die Embeddings
+model = SentenceTransformer('all-MiniLM-L6-v2')
 
-# OCR-Tool mit LayoutLMv3 für strukturierte PDFs
-class OCRTool:
-    def __init__(self):
-        self.processor = LayoutLMv3Processor.from_pretrained("microsoft/layoutlmv3-base")
-        self.model = AutoModelForTokenClassification.from_pretrained("microsoft/layoutlmv3-base")
+# Beispiel-Dokumente (könnten auch aus PDFs oder anderen Quellen stammen)
+documents = [
+    "LangChain ist eine Bibliothek für die Verarbeitung von Text mit LLMs.",
+    "FAISS wird verwendet, um Vektoren effizient zu durchsuchen.",
+    "Hugging Face bietet eine Vielzahl von vortrainierten Modellen."
+]
 
-    def extract_text(self, pdf_path):
-        try:
-            # LayoutLMv3 für strukturierte PDFs verwenden
-            text_pages = extract_text_from_pdf(pdf_path)
-            return text_pages
-        except Exception as e:
-            print(f"Fehler bei der PDF-Verarbeitung: {e}")
-            return []
+# Schritt 2: Erzeuge Embeddings für die Dokumente
+document_embeddings = model.encode(documents)
 
-# OCR-Instanz erstellen
-ocr_tool = OCRTool()
+# FAISS-Index für die Vektoren erstellen
+dimension = len(document_embeddings[0])
+index = faiss.IndexFlatL2(dimension)
+document_embeddings = np.array(document_embeddings).astype('float32')
+index.add(document_embeddings)  # Füge Dokumente zum Index hinzu
 
-# Funktion zur Verarbeitung der PDF und Antwortgenerierung
-def process_pdf_and_query(pdf_path, question):
-    try:
-        # Dokument laden und in Vektoren umwandeln
-        loader = PyPDFLoader(pdf_path)
-        documents = loader.load()
+# Schritt 3: Suche nach einer ähnlichen Antwort auf eine Eingabeabfrage
+def search_documents(query):
+    query_embedding = model.encode([query])[0].astype('float32')
+    D, I = index.search(np.array([query_embedding]), k=1)  # Suche nach den Top 1 Treffern
+    return documents[I[0][0]]  # Gibt das am besten passende Dokument zurück
 
-        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-        vectordb = Chroma.from_documents(documents, embeddings)
-
-        retriever = vectordb.as_retriever()
-        prompt_template = "Beantworte die folgende Frage basierend auf dem Dokument: {context}\nFrage: {question}\nAntwort:"
-        prompt = PromptTemplate(input_variables=["context", "question"], template=prompt_template)
-
-        # RetrievalQA-Chain mit Hugging Face LLM
-        qa_chain = RetrievalQA.from_chain_type(
-            llm="huggingface/gpt2",  # Modell von Hugging Face
-            retriever=retriever,
-            chain_type_kwargs={"prompt": prompt}
-        )
-
-        response = qa_chain.run(input_documents=documents, question=question)
-        return response
-    except Exception as e:
-        print(f"Fehler bei der Fragebeantwortung: {e}")
-        return "Es gab ein Problem bei der Verarbeitung der Frage."
-
-# Funktion für die Chatbot-Antwort
-def chatbot_response(pdf, question):
-    try:
-        # Speichern der hochgeladenen PDF
-        pdf_path = "uploaded_pdf.pdf"
-        pdf.save(pdf_path)
-
-        # Textextraktion aus der PDF
-        extracted_text = ocr_tool.extract_text(pdf_path)
-        if not extracted_text:
-            return "Es konnte kein Text aus der PDF extrahiert werden."
-
-        # Frage beantworten basierend auf den extrahierten Daten
-        answer = process_pdf_and_query(pdf_path, question)
-        os.remove(pdf_path)
-        return answer
-    except Exception as e:
-        print(f"Fehler bei der Chatbot-Verarbeitung: {e}")
-        return "Es gab ein Problem bei der Verarbeitung der Anfrage."
-
-# Gradio-Interface
-pdf_input = gr.File(label="PDF-Datei hochladen")
-question_input = gr.Textbox(label="Frage eingeben")
-response_output = gr.Textbox(label="Antwort")
+# Gradio Interface
+def chatbot_response(query):
+    return search_documents(query)
 
 interface = gr.Interface(
     fn=chatbot_response,
-    inputs=[pdf_input, question_input],
-    outputs=response_output,
-    title="RAG Chatbot mit PDF-Unterstützung",
-    description="Lade eine PDF-Datei hoch und stelle Fragen zu ihrem Inhalt."
+    inputs="text",
+    outputs="text",
+    title="FAISS-basierter Chatbot",
+    description="Gib eine Frage ein, und erhalte eine Antwort basierend auf den Dokumenten."
 )
 
-if __name__ == "__main__":
-    interface.launch()
+interface.launch()