commit

app.py

@@ -1,40 +1,36 @@
 # app.py
 import os
-from typing import List, Tuple
+from typing import List, Dict, Tuple
 
 import gradio as gr
 from langchain_core.documents import Document
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_community.vectorstores import FAISS
-from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
 
-from load_documents import load_documents  # <- giữ như hiện tại
+from load_documents import load_documents
 from speech_io import transcribe_audio, synthesize_speech
 
 
-# =============================
-# 1. Lade & indexiere Dokumente
-# =============================
-
+# ===============================
+# 1. Documents Laden
+# ===============================
 print("🔹 Lade Dokumente aus Supabase …")
 docs: List[Document] = load_documents()
-print(f"✔ DOCUMENTS LOADED: {len(docs)}")
+print("✔ DOCUMENTS LOADED:", len(docs))
 
 print("🔹 Splitte Dokumente …")
 text_splitter = RecursiveCharacterTextSplitter(
     chunk_size=800,
     chunk_overlap=200,
-    separators=["\n\n", "\n", ".", "?", "!", " "],
 )
 chunks = text_splitter.split_documents(docs)
 print(f"   - {len(chunks)} Chunks erzeugt.")
 
 print("🔹 Erzeuge VectorStore …")
-print(">>> Initialising embedding model for FAISS index ...")
 embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
 vectorstore = FAISS.from_documents(chunks, embeddings)
 retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
-print(">>> FAISS index built.")
 print(">>> Retriever ready.")
 
 print("🔹 Lade OpenAI LLM …")
@@ -44,179 +40,103 @@ llm = ChatOpenAI(
 )
 
 
-# =============================
-# 2. RAG-Antwortfunktion
-# =============================
-
+# ===============================
+# 2. RAG Engine
+# ===============================
 def build_context(docs: List[Document]) -> str:
-    """Baut einen konsolidierten Kontextstring mit Quelle-Infos."""
     parts = []
-    for i, d in enumerate(docs, start=1):
-        meta = d.metadata or {}
-        source = meta.get("source", "unbekannt")
-        page = meta.get("page", meta.get("page_number", "?"))
-        para = meta.get("abs_id", meta.get("paragraph_id", ""))
-        label = f"[Quelle {i}]"
-        if para:
-            label += f" Abs. {para}"
-        if page is not None and page != "?":
-            label += f", S. {page}"
-        parts.append(
-            f"{label} (source={source}):\n{d.page_content.strip()}\n"
-        )
+    for i, d in enumerate(docs, 1):
+        meta = d.metadata
+        src = meta.get("source")
+        page = meta.get("page")
+        abs_id = meta.get("abs_id")
+
+        label = f"[Quelle {i}] {src}"
+        if page:
+            label += f", Seite {page}"
+        if abs_id:
+            label += f", Abs. {abs_id}"
+
+        parts.append(f"{label}\n{d.page_content}")
     return "\n\n".join(parts)
 
-def rag_answer(user_query: str, mode: str = "Standard") -> Tuple[str, List[Document]]:
-    """
-    Erzeugt eine Antwort mit RAG.
-    mode: 'Kurz', 'Standard', 'Juristisch Präzise'
-    """
-    retrieved = retriever.invoke(user_query)
-    context = build_context(retrieved)
-
-    if mode == "Kurz":
-        length_instruction = "Formuliere die Antwort kurz und prägnant (max. 3 Sätze)."
-    elif mode == "Juristisch Präzise":
-        length_instruction = (
-            "Formuliere die Antwort möglichst juristisch präzise, "
-            "mit klarer Struktur (Sachverhalt, Rechtsgrundlage, Anwendung, Ergebnis)."
-        )
-    else:
-        length_instruction = "Formuliere die Antwort verständlich und vollständig."
-
-    system_prompt = (
-        "Du bist ein Chatbot für Prüfungsrecht (Hochschulgesetz NRW + Prüfungsordnung). "
-        "Du antwortest immer AUF DEUTSCH, ohne Englisch zu mischen. "
-        "Nutze NUR die gegebenen Quellen im Kontext. "
-        "Wenn etwas nicht eindeutig aus den Quellen hervorgeht, sage transparent, "
-        "dass du es nicht sicher weißt.\n\n"
-        "Ganz am Ende der Antwort liste die verwendeten Quellen in der Form "
-        "[Quelle 1], [Quelle 2], … mit kurzer Beschreibung auf."
-    )
 
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {
-            "role": "user",
-            "content": (
-                f"FRAGE:\n{user_query}\n\n"
-                f"KONTEXT (Auszüge aus Gesetz/Prüfungsordnung):\n{context}\n\n"
-                f"{length_instruction}"
-            ),
-        },
-    ]
+def rag_answer(query: str, mode: str) -> Tuple[str, List[Document]]:
+    retrieved = retriever.invoke(query)
+    ctx = build_context(retrieved)
 
-    resp = llm.invoke(messages)
-    answer_text = resp.content if isinstance(resp.content, str) else str(resp.content)
-    return answer_text, retrieved
+    modes = {
+        "Kurz": "Antworte sehr kurz (max. 3 Sätze).",
+        "Standard": "Antworte ausführlich und gut verständlich.",
+        "Juristisch Präzise": "Antworte fachlich-präzise mit juristischer Struktur.",
+    }
 
+    messages = [
+        {"role": "system",
+         "content": "Du bist ein Chatbot für Prüfungsrecht. Antworte NUR auf Deutsch."},
+        {"role": "user",
+         "content": f"FRAGE:\n{query}\n\nKONTEXT:\n{ctx}\n\n{modes[mode]}"}
+    ]
 
-# =============================
-# 3. Gradio-Callback-Funktionen
-# =============================
+    response = llm.invoke(messages)
+    answer = response.content
+    return answer, retrieved
 
-def chatbot_text(user_input: str, history: List[Tuple[str, str]], mode: str) -> Tuple[List[Tuple[str, str]], List[Tuple[str, str]]]:
-    if not user_input:
-        return history, history
 
-    answer, _ = rag_answer(user_input, mode=mode)
-    history = history + [(user_input, answer)]
+# ===============================
+# 3. Chatbot Funktionen (GRADIO v6 FORMAT!)
+# ===============================
+def chatbot_text(user_input: str, history: List[Dict], mode: str):
+    answer, _ = rag_answer(user_input, mode)
+    history = history + [
+        {"role": "user", "content": user_input},
+        {"role": "assistant", "content": answer},
+    ]
     return history, history
 
 
-def chatbot_voice(
-    audio_file: str,
-    history: List[Tuple[str, str]],
-    mode: str,
-    language_hint: str,
-):
-    """
-    - audio_file: đường dẫn file tạm từ Gradio
-    - history: lịch sử chat
-    - mode: Kurz / Standard / Juristisch Präzise
-    - language_hint: "", "de", "en", "vi", ...
-    """
-    if audio_file is None:
-        return history, None, "", history
-
-    # 1) Speech-to-Text
-    lang = language_hint.strip() or None
-    user_text = transcribe_audio(audio_file, language=lang)
-
-    # 2) RAG-Antwort
-    answer, _ = rag_answer(user_text, mode=mode)
-
-    # 3) Text-to-Speech
-    audio_out_path = synthesize_speech(answer)
-
-    # 4) Update History
-    history = history + [(user_text, answer)]
-
-    return history, audio_out_path, user_text, history
+def chatbot_voice(audio_file: str, history: List[Dict], mode: str, language_hint: str):
+    user_text = transcribe_audio(audio_file, language=language_hint or None)
+    answer, _ = rag_answer(user_text, mode)
+    audio_out = synthesize_speech(answer)
 
+    history = history + [
+        {"role": "user", "content": user_text},
+        {"role": "assistant", "content": answer},
+    ]
+    return history, audio_out, user_text, history
 
-# =============================
-# 4. Gradio UI
-# =============================
 
-with gr.Blocks(title="Prüfungsrechts-Chatbot (OpenAI)") as demo:
-    gr.Markdown("## 📚 Sprachbasierter Chatbot für Prüfungsrecht\n"
-                "Aktuelle Prüfungsordnung + Hochschulgesetz NRW (RAG, OpenAI).")
+# ===============================
+# 4. UI
+# ===============================
+with gr.Blocks(title="Prüfungsrechts-Chatbot") as demo:
 
     with gr.Tab("💬 Text-Chat"):
-        mode_text = gr.Radio(
-            ["Kurz", "Standard", "Juristisch Präzise"],
-            value="Standard",
-            label="Antwortmodus",
-        )
-        chatbot_t = gr.Chatbot(label="Chatverlauf")
-        text_in = gr.Textbox(label="Text eingeben", placeholder="Frage zum Prüfungsrecht …")
-        state_t = gr.State([])  # history
-
-        btn_send = gr.Button("Senden")
+        mode = gr.Radio(["Kurz", "Standard", "Juristisch Präzise"], value="Standard")
+        chat = gr.Chatbot(type="messages")
+        state = gr.State([])
+        inp = gr.Textbox(label="Frage eingeben")
+        send = gr.Button("Senden")
 
-        btn_send.click(
-            fn=chatbot_text,
-            inputs=[text_in, state_t, mode_text],
-            outputs=[chatbot_t, state_t],
-        )
+        send.click(chatbot_text, [inp, state, mode], [chat, state])
 
     with gr.Tab("🎙️ Sprach-Chat"):
-        mode_voice = gr.Radio(
-            ["Kurz", "Standard", "Juristisch Präzise"],
-            value="Standard",
-            label="Antwortmodus",
-        )
-        language_hint = gr.Textbox(
-            label="Sprach-Hint (optional)",
-            placeholder="z.B. de / en / vi – leer lassen = auto-detect",
-            value="",
-        )
-
-        chatbot_v = gr.Chatbot(label="Chatverlauf (Sprache)")
-        audio_in = gr.Audio(
-            label="Mikrofon",
-            sources=["microphone"],
-            type="filepath",
-        )
-        audio_out = gr.Audio(
-            label="Antwort (TTS)",
-            type="filepath",
-        )
-        transcript_box = gr.Textbox(
-            label="Transkript deiner Frage",
-            interactive=False,
-        )
+        mode_v = gr.Radio(["Kurz", "Standard", "Juristisch Präzise"], value="Standard")
+        chat_v = gr.Chatbot(type="messages")
         state_v = gr.State([])
 
-        btn_ask = gr.Button("Frage mit Mikrofon stellen")
+        mic = gr.Audio(sources=["microphone"], type="filepath")
+        lang_hint = gr.Textbox(label="Sprache (optional: de/en/vi)")
+        out_audio = gr.Audio(label="Antwort (TTS)")
+        trans_box = gr.Textbox(label="Transkript")
 
-        btn_ask.click(
-            fn=chatbot_voice,
-            inputs=[audio_in, state_v, mode_voice, language_hint],
-            outputs=[chatbot_v, audio_out, transcript_box, state_v],
+        btn = gr.Button("Sprechen")
+        btn.click(
+            chatbot_voice,
+            [mic, state_v, mode_v, lang_hint],
+            [chat_v, out_audio, trans_box, state_v]
         )
 
-# Wichtig für HuggingFace Spaces
 if __name__ == "__main__":
     demo.launch()

load_documents.py

@@ -1,89 +1,104 @@
-# load_documents.py – Dokumente für RAG laden (HG NRW + Prüfungsordnung PDF)
+# load_documents.py
 
 import os
-import requests
-import tempfile
-from supabase import create_client
+from io import BytesIO
+from typing import List
+
+from dotenv import load_dotenv
+from supabase import create_client, Client
+from pypdf import PdfReader
 from langchain_core.documents import Document
-from langchain_community.document_loaders import PyPDFLoader
 
-SUPABASE_URL = os.getenv("SUPABASE_URL")
-SUPABASE_ANON_KEY = os.getenv("SUPABASE_ANON_KEY")
+load_dotenv()
 
-if not SUPABASE_URL or not SUPABASE_ANON_KEY:
-    raise RuntimeError("Missing SUPABASE_URL / SUPABASE_ANON_KEY in environment.")
 
-supabase = create_client(SUPABASE_URL, SUPABASE_ANON_KEY)
+# ============== Supabase Init ==============
+def get_supabase_client() -> Client:
+    url = os.getenv("SUPABASE_URL")
+    key = (
+        os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+        or os.getenv("SUPABASE_SERVICE_ROLE")
+        or os.getenv("SUPABASE_KEY")
+    )
+    if not url or not key:
+        raise RuntimeError("Supabase ENV fehlen.")
 
-PDF_FILE = "f10_bpo_ifb_tei_mif_wii_2021-01-04.pdf"
-PDF_URL = f"{SUPABASE_URL}/storage/v1/object/public/File%20PDF/{PDF_FILE}"
+    return create_client(url, key)
 
 
-def load_hg_nrw():
+# ============== HG NRW Paragraphen ==============
+def load_hg_paragraphs(supabase: Client) -> List[Document]:
     print(">>> Lade Hochschulgesetz NRW (§) aus Supabase…")
 
-    rows = (
-        supabase.table("hg_nrw")
-        .select("*")
-        .order("order_index")
-        .execute()
-    ).data or []
-
-    print(f"   - {len(rows)} Paragraphen geladen.")
+    table = os.getenv("HG_TABLE_NAME", "hg_nrw")
+    rows = supabase.table(table).select("*").order("order_index").execute().data or []
 
     docs = []
-    for r in rows:
-        abs_id = r["abs_id"]
-        title = r["title"]
-        content = r["content"]
-
-        viewer_url = f"hg_view#{abs_id}"
-
-        docs.append(
-            Document(
-                page_content=f"{title}\n{content}",
-                metadata={
-                    "source": "Hochschulgesetz NRW",
-                    "paragraph": title,
-                    "abs_id": abs_id,
-                    "url": viewer_url,
-                },
-            )
-        )
-
+    for row in rows:
+        text = (row.get("title", "") + "\n\n" + row.get("content", "")).strip()
+        if not text:
+            continue
+
+        docs.append(Document(
+            page_content=text,
+            metadata={
+                "source": "Hochschulgesetz NRW",
+                "abs_id": row.get("abs_id"),
+                "order_index": row.get("order_index"),
+                "url": "https://recht.nrw.de/lmi/owa/br_text_anzeigen?v_id=10000000000000000654",
+                "type": "law",
+            }
+        ))
+
+    print(f"   - {len(docs)} Paragraphen geladen.")
     return docs
 
 
-def load_pdf():
-    print(">>> Lade Prüfungsordnung PDF …")
+# ============== Prüfungsordnung PDF ==============
+def load_pruefungsordnung_from_storage(supabase: Client) -> List[Document]:
+    bucket = os.getenv("PRUEF_BUCKET")
+    pdf_path = os.getenv("PRUEF_PDF_PATH")
 
-    resp = requests.get(PDF_URL)
-    resp.raise_for_status()
+    if not bucket or not pdf_path:
+        print(">>> Keine Prüfungsordnung-PDF definiert.")
+        return []
 
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
-        tmp.write(resp.content)
-        pdf_path = tmp.name
+    print(">>> Lade Prüfungsordnung PDF …")
 
-    pages = PyPDFLoader(pdf_path).load()
+    try:
+        data = supabase.storage.from_(bucket).download(pdf_path)
+    except Exception as e:
+        print("   Fehler beim PDF Download:", e)
+        return []
 
-    for i, p in enumerate(pages):
-        p.metadata["source"] = "Prüfungsordnung (PDF)"
-        p.metadata["page"] = i
-        p.metadata["pdf_url"] = PDF_URL
+    reader = PdfReader(BytesIO(data))
+    docs = []
 
-    print(f"   - {len(pages)} PDF-Seiten geladen.")
-    return pages
+    for i, page in enumerate(reader.pages):
+        text = (page.extract_text() or "").strip()
+        if not text:
+            continue
+
+        docs.append(Document(
+            page_content=text,
+            metadata={
+                "source": "Prüfungsordnung (PDF)",
+                "page": i + 1,
+                "type": "pruefungsordnung",
+            }
+        ))
+
+    print(f"   - {len(docs)} PDF-Seiten geladen.")
+    return docs
 
 
-def load_documents():
+# ============== Main Loader ==============
+def load_documents() -> List[Document]:
+    supabase = get_supabase_client()
     docs = []
-    docs.extend(load_hg_nrw())
-    docs.extend(load_pdf())
-    print(f"✔ DOCUMENTS LOADED: {len(docs)}")
-    return docs
 
+    docs += load_hg_paragraphs(supabase)
+    docs += load_pruefungsordnung_from_storage(supabase)
 
-if __name__ == "__main__":
-    docs = load_documents()
-    print(docs[0])
-    print("Total:", len(docs))
+    print(f"✔ DOCUMENTS LOADED: {len(docs)}")
+    return docs

speech_io.py

@@ -1,3 +1,4 @@
+# speech_io.py
 import os
 from tempfile import NamedTemporaryFile
 from typing import Optional
@@ -6,30 +7,42 @@ from openai import OpenAI
 client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 
 
+# ======================
+# 1. Speech-to-Text (STT)
+# ======================
 def transcribe_audio(file_path: str, language: Optional[str] = None) -> str:
+    """
+    Transkribiert Audio via OpenAI Audio Transcription API (gpt-4o-mini-transcribe).
+    """
     print(">>> Transkribiere Audio via OpenAI Audio API …")
 
     with open(file_path, "rb") as f:
         resp = client.audio.transcriptions.create(
             model="gpt-4o-mini-transcribe",
             file=f,
-            language=language
+            language=language,
         )
 
     return resp.text
 
 
+# ======================
+# 2. Text-to-Speech (TTS)
+# ======================
 def synthesize_speech(text: str, voice: str = "alloy") -> str:
+    """
+    Wandelt Text in Sprache um (OpenAI TTS - gpt-4o-mini-tts)
+    Speichert MP3-Datei und gibt den Pfad zurück.
+    """
     print(">>> Synthesizing speech via OpenAI TTS …")
 
-    # OpenAI SDK 2.x returns HttpxBinaryResponseContent
     response = client.audio.speech.create(
         model="gpt-4o-mini-tts",
         voice=voice,
-        input=text
+        input=text,
     )
 
-    # Correct extraction method
+    # HF Spaces + OpenAI SDK v2.x → raw bytes
     audio_bytes = response.read()
 
     tmp = NamedTemporaryFile(delete=False, suffix=".mp3")