Update app.py

app.py

@@ -1,152 +1,67 @@
 import gradio as gr
-import requests
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-from langchain.chains import ConversationalRetrievalChain
-from langchain_community.vectorstores import FAISS
-from langchain_community.embeddings import HuggingFaceEmbeddings
-from langchain_community.llms import HuggingFacePipeline
-from langchain.prompts import PromptTemplate
-from langchain_community.document_loaders import PyPDFLoader
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from transformers import pipeline, AutoModelForQuestionAnswering
-import logging
-
-# Logging einrichten
-logging.basicConfig(level=logging.INFO)
-
-# 1. Initialisiere das Embedding-Modell von Hugging Face
-embedding_model_name = "sentence-transformers/all-MiniLM-L6-v2"
-embeddings = HuggingFaceEmbeddings(model_name=embedding_model_name)
-
-# FastAPI Backend
-app = FastAPI()
-
-# CORS-Middleware hinzufügen
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Erlaubt alle Ursprünge
-    allow_credentials=True,
-    allow_methods=["*"],  # Alle Methoden
-    allow_headers=["*"],  # Alle Header
-)
-
-class QueryRequest(BaseModel):
-    question: str
-    chat_history: list
-    num_sources: int = 3  # Standardmäßig 3 Quellen zurückgeben
-
-@app.post("/query")
-async def query(request: QueryRequest):
-    try:
-        logging.info(f"Received query: {request.question}")
-        
-        result = qa_chain({"question": request.question, "chat_history": request.chat_history})
-        
-        # Begrenze die Anzahl der zurückgegebenen Quellen
-        sources = [
-            {"source": doc.metadata["source"], "content": doc.page_content}
-            for doc in result["source_documents"][:request.num_sources]
-        ]
-        
-        response = {
-            "answer": result["answer"],
-            "sources": sources
-        }
-        
-        logging.info(f"Answer: {response['answer']}")
-        return JSONResponse(content=response)
+import easyocr
+from pdf2image import convert_from_path
+from transformers import RagTokenizer, RagRetriever, RagSequenceForGeneration
+import os
+
+# Initialisiere EasyOCR für Deutsch
+reader = easyocr.Reader(['de'])  # für die deutsche Sprache
+
+# Initialisiere das deutsche Modell und den Tokenizer für RAG
+model_name = "deepset/gbert-base"  # Beispiel für ein deutsches Modell
+tokenizer = RagTokenizer.from_pretrained(model_name)
+model = RagSequenceForGeneration.from_pretrained(model_name)
+retriever = RagRetriever.from_pretrained(model_name, index_name="exact", use_dummy_dataset=True)
+
+# OCR-Funktion: Konvertiert PDF zu Bildern und extrahiert Text mit EasyOCR
+def extract_text_from_pdf(file):
+    # Konvertiere PDF-Seiten in Bilder
+    images = convert_from_path(file.name, 300)  # 300 DPI für bessere Qualität
     
-    except Exception as e:
-        logging.error(f"Error processing query: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-# 2. Lade PDF-Dokumente und extrahiere Inhalte
-def load_pdf(file):
-    loader = PyPDFLoader(file.name)
-    pages = loader.load()
-
-    # Text-Splitting für eine bessere Genauigkeit bei der Abfrage
-    text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
-
-    # Seiten mit einer fortlaufenden Seitenzahl versehen und in Document-Objekte umwandeln
-    documents = [
-        {"content": page.page_content, "metadata": {"source": f"Seite {i + 1}"}} 
-        for i, page in enumerate(pages)
-    ]
-    # Texte splitten
-    split_texts = text_splitter.split_documents(pages)
-
-    # FAISS Vektorspeicher mit den gesplitteten Texten
-    vectorstore = FAISS.from_texts([text.page_content for text in split_texts], embeddings, metadatas=[text.metadata for text in split_texts])
-    return vectorstore
-
-# 3. Initialisiere ein Frage-Antwort Modell
-qa_pipeline = pipeline("question-answering", model="deepset/roberta-base-squad2", tokenizer="deepset/roberta-base-squad2")
-
-# 4. Konfiguriere den Prompt für die Retrieval-Augmented-Generation
-prompt_template = """
-Du bist ein hilfreicher KI-Chatbot. Nutze die folgenden Informationen, um die Frage zu beantworten:
-{context}
-
-Frage: {question}
-Antwort:
-"""
-prompt = PromptTemplate(template=prompt_template, input_variables=["context", "question"])
-
-# 5. Baue die ConversationalRetrievalChain
-qa_chain = ConversationalRetrievalChain(
-    retriever=vectorstore.as_retriever(),
-    llm=HuggingFacePipeline(pipeline=qa_pipeline),
-    prompt=prompt,
-    return_source_documents=True
-)
+    text = ""
+    # Extrahiere Text aus jedem Bild mit EasyOCR
+    for image in images:
+        ocr_result = reader.readtext(image)
+        for detection in ocr_result:
+            text += detection[1] + "\n"
+    
+    return text
 
-# Gradio Frontend
-API_URL = "http://localhost:8000/query"  # Kann auf die interne API umgestellt werden
+# Funktion zur Generierung einer Antwort basierend auf dem hochgeladenen Dokument
+def get_rag_answer(input_message, uploaded_file):
+    # Extrahiere den Text aus dem hochgeladenen PDF-Dokument mit OCR
+    document_text = extract_text_from_pdf(uploaded_file)
 
-def chat_with_bot(user_input, chat_history):
-    response = requests.post(
-        API_URL,
-        json={"question": user_input, "chat_history": chat_history}
-    )
-    if response.status_code == 200:
-        data = response.json()
-        answer = data["answer"]
-        sources = data.get("sources", [])
-        sources_text = "\n".join([f"{src['source']}: {src['content']}" for src in sources])
-        chat_history.append((user_input, answer))
-        return answer, chat_history, sources_text
-    else:
-        return "Ein Fehler ist aufgetreten: " + response.text, chat_history, ""
+    # Simuliere den Retrieval-Mechanismus, indem wir den extrahierten Text verwenden
+    inputs = tokenizer(input_message, return_tensors="pt")
+    retrieved_docs = retriever.retrieve(input_ids=inputs["input_ids"])
 
-def upload_pdf(file):
-    vectorstore = load_pdf(file)
-    return "PDF erfolgreich hochgeladen."
+    # Kombiniere die extrahierten Dokumente und frage das Modell zur Generierung einer Antwort
+    input_ids = tokenizer(input_message, return_tensors="pt").input_ids
+    generated_ids = model.generate(input_ids=input_ids, 
+                                   decoder_start_token_id=model.config.pad_token_id, 
+                                   num_beams=4, 
+                                   max_length=100)
 
-with gr.Blocks() as demo:
-    gr.Markdown("## Chatbot mit RAG (LangChain)")
+    answer = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
     
-    # Datei-Upload-Komponente
-    with gr.Row():
-        upload_button = gr.File(label="Lade PDF hoch", file_count="single")
-        upload_button.upload(upload_pdf, inputs=upload_button, outputs="status")
-    
-    chatbot = gr.Chatbot(label="Chatbot")
-    question = gr.Textbox(label="Deine Frage")
-    sources = gr.Textbox(label="Quellen", interactive=False)
-    submit = gr.Button("Senden")
-    clear = gr.Button("Chatverlauf löschen")
-    chat_history = gr.State([])
-
-    submit.click(
-        fn=chat_with_bot,
-        inputs=[question, chat_history],
-        outputs=[chatbot, chat_history, sources],
-        show_progress=True,
+    # Hier könnten wir eine Referenz (z.B. Absatz, Seite) in die Antwort einfügen
+    references = "Referenz: Abschnitt X, Seite Y (aus Dokument)"  # Füge diese Infos hinzu, falls möglich
+
+    return f"{answer} \n\n{references}"
+
+# Gradio-Oberfläche
+def gradio_interface():
+    iface = gr.Interface(
+        fn=get_rag_answer,
+        inputs=[
+            gr.Textbox(label="User Input", placeholder="Stellen Sie eine Frage..."),
+            gr.File(label="Laden Sie ein PDF-Dokument hoch", type="file")  # Ermöglicht das Hochladen von PDF-Dateien
+        ],
+        outputs=gr.Textbox(label="Antwort des Chatbots"),
+        live=True  # Sofortige Antwortgenerierung
     )
-    clear.click(lambda: ([], [], ""), inputs=[], outputs=[chatbot, chat_history, sources])
+    iface.launch()
 
-    demo.launch()
+# Starte die Gradio-Oberfläche
+gradio_interface()