app.py

import gradio as gr
import os
from langchain.vectorstores import Chroma
from langchain.document_loaders import PyPDFLoader  # Korrekt importiert
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
from pdf2image import convert_from_path
from transformers import LayoutLMv3Processor, AutoModelForTokenClassification

# OCR-Modell einrichten
class LayoutLMv3OCR:
    def __init__(self):
        self.processor = LayoutLMv3Processor.from_pretrained("microsoft/layoutlmv3-base")
        self.model = AutoModelForTokenClassification.from_pretrained("microsoft/layoutlmv3-base")

    def extract_text(self, pdf_path):
        images = convert_from_path(pdf_path)
        text_pages = []
        for image in images:
            inputs = self.processor(images=image, return_tensors="pt")
            outputs = self.model(**inputs)
            text = self.processor.batch_decode(outputs.logits, skip_special_tokens=True)[0]
            text_pages.append(text)
        return text_pages

ocr_tool = LayoutLMv3OCR()

def process_pdf_and_query(pdf_path, question):
    loader = PyPDFLoader(pdf_path)
    documents = loader.load()

    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)

    qa_chain = RetrievalQA.from_chain_type(llm=None, retriever=retriever, chain_type_kwargs={"prompt": prompt})
    response = qa_chain.run(input_documents=documents, question=question)
    return response

def chatbot_response(pdf, question):
    # Gradio gibt uns die PDF als NamedString, wir extrahieren den Inhalt als Byte-Stream
    pdf_path = "/mnt/data/uploaded_pdf.pdf"  # Verwendet das persistente Verzeichnis von Hugging Face Spaces
    
    # Extrahiere den Inhalt der Datei als Bytes
    pdf_content = pdf.read()  # Hier holen wir den Inhalt der PDF als Byte-Stream

    # Speichern des Byte-Streams von der Datei
    with open(pdf_path, "wb") as f:
        f.write(pdf_content)

    # OCR-Text extrahieren
    extracted_text = ocr_tool.extract_text(pdf_path)

    # Frage beantworten basierend auf der PDF und OCR-Inhalten
    answer = process_pdf_and_query(pdf_path, question)

    return answer

# Gradio Interface
pdf_input = gr.File(label="PDF-Datei hochladen")
question_input = gr.Textbox(label="Frage eingeben")
response_output = gr.Textbox(label="Antwort")

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."
)

if __name__ == "__main__":
    interface.launch()