commit

app.py

@@ -0,0 +1,184 @@
+# app.py – SUPABASE RAG CHATBOT (Docker + Ollama)
+
+import gradio as gr
+
+from load_documents import load_documents, PDF_URL, HG_HTML_URL
+from split_documents import split_documents
+from vectorstore import build_vectorstore
+from retriever import get_retriever
+from llm import load_llm
+from rag_pipeline import answer
+from speech_io import transcribe_audio, synthesize_speech
+
+# ================= INITIALISIERUNG =====================
+
+print("🔹 Lade Dokumente aus Supabase …")
+_docs = load_documents()
+
+print("🔹 Splitte Dokumente …")
+_chunks = split_documents(_docs)
+
+print("🔹 Baue VectorStore …")
+_vs = build_vectorstore(_chunks)
+
+print("🔹 Erzeuge Retriever …")
+_retriever = get_retriever(_vs)
+
+print("🔹 Lade LLM (Ollama) …")
+_llm = load_llm()
+
+
+# ================= Quellen Markdown ====================
+
+def format_sources_markdown(sources):
+    if not sources:
+        return ""
+
+    lines = ["", "### 📚 Quellen (verwendete Dokumentstellen):"]
+
+    for s in sources:
+        sid = s["id"]
+        src = s["source"]
+        page = s["page"]
+        url = s["url"]
+        snippet = s["snippet"]
+
+        if page:
+            title = f"Quelle {sid} – {src}, Seite {page}"
+        else:
+            title = f"Quelle {sid} – {src}"
+
+        if url:
+            base = f"- [{title}]({url})"
+        else:
+            base = f"- {title}"
+
+        lines.append(base)
+        if snippet:
+            lines.append(f"  > {snippet}")
+
+    return "\n".join(lines)
+
+
+# ================= TEXT CHATBOT ========================
+
+def chatbot_text(user_message, history):
+    if not user_message:
+        return history, ""
+
+    answer_text, sources = answer(
+        question=user_message,
+        retriever=_retriever,
+        chat_model=_llm,
+    )
+
+    quellen_block = format_sources_markdown(sources)
+    bot_msg = answer_text + "\n\n" + quellen_block
+
+    history = history + [
+        {"role": "user", "content": user_message},
+        {"role": "assistant", "content": bot_msg},
+    ]
+
+    return history, ""
+
+
+# ================= VOICE CHATBOT =======================
+
+def chatbot_voice(audio_path, history):
+    text = transcribe_audio(audio_path)
+    if not text:
+        return history, None, ""
+
+    history = history + [{"role": "user", "content": text}]
+
+    answer_text, sources = answer(
+        question=text,
+        retriever=_retriever,
+        chat_model=_llm,
+    )
+
+    quellen_block = format_sources_markdown(sources)
+    bot_msg = answer_text + "\n\n" + quellen_block
+
+    history = history + [{"role": "assistant", "content": bot_msg}]
+
+    audio = synthesize_speech(bot_msg)
+    return history, audio, ""
+
+
+def read_last_answer(history):
+    if not history:
+        return None
+    for msg in reversed(history):
+        if msg["role"] == "assistant":
+            return synthesize_speech(msg["content"])
+    return None
+
+
+# ================= UI (Gradio) =========================
+
+with gr.Blocks(title="Prüfungsrechts-Chatbot (Supabase + Ollama)") as demo:
+
+    gr.Markdown("# 🧑‍⚖️ Prüfungsrechts-Chatbot (Supabase RAG, Ollama)")
+    gr.Markdown("Fragen zum Prüfungsrecht? Text oder Mikrofon möglich.")
+
+    with gr.Row():
+
+        # ---------- CHAT ----------
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(
+                type="messages",
+                label="Chat",
+                height=550,
+            )
+
+            msg = gr.Textbox(
+                label="Frage eingeben",
+                placeholder="Stelle deine Frage zum Prüfungsrecht …",
+                autofocus=True,
+            )
+            msg.submit(chatbot_text, [msg, chatbot], [chatbot, msg])
+
+            send_btn = gr.Button("Senden (Text)")
+            send_btn.click(chatbot_text, [msg, chatbot], [chatbot, msg])
+
+            gr.Markdown("### 🎙️ Spracheingabe")
+            voice_in = gr.Audio(sources=["microphone"], type="filepath")
+            voice_out = gr.Audio(label="Vorgelesene Antwort", type="numpy")
+
+            send_voice_btn = gr.Button("Sprechen & Senden")
+            send_voice_btn.click(
+                chatbot_voice,
+                [voice_in, chatbot],
+                [chatbot, voice_out, msg],
+            )
+
+            read_btn = gr.Button("Antwort erneut vorlesen")
+            read_btn.click(read_last_answer, [chatbot], [voice_out])
+
+            clear_btn = gr.Button("Chat löschen")
+            clear_btn.click(lambda: [], None, chatbot)
+
+        # ---------- VIEWER ----------
+        with gr.Column(scale=1):
+            gr.Markdown("### 📄 Prüfungsordnung (PDF)")
+            gr.HTML(
+                f"""
+                <iframe src="{PDF_URL}"
+                        style="width:100%; height:330px; border:none;">
+                </iframe>
+                """
+            )
+
+            gr.Markdown("### 📘 Hochschulgesetz NRW (Paragraph-Viewer)")
+            gr.HTML(
+                f"""
+                <iframe src="{HG_HTML_URL}"
+                        style="width:100%; height:330px; border:none;">
+                </iframe>
+                """
+            )
+
+if __name__ == "__main__":
+    demo.queue().launch(ssr_mode=False, show_error=True)

embeddings.py

@@ -0,0 +1,23 @@
+"""
+BƯỚC 3: EMBEDDINGS – local & free
+"""
+
+from langchain_huggingface import HuggingFaceEmbeddings
+
+EMBEDDING_MODEL = "sentence-transformers/paraphrase-multilingual-mpnet-base-v2"
+
+
+def get_embeddings():
+    print(f">>> Loading embedding model: {EMBEDDING_MODEL}")
+    embeddings = HuggingFaceEmbeddings(
+        model_name=EMBEDDING_MODEL,
+        model_kwargs={"device": "cpu"},
+        encode_kwargs={"normalize_embeddings": True},
+    )
+    print(">>> Embedding model loaded.\n")
+    return embeddings
+
+
+if __name__ == "__main__":
+    emb = get_embeddings()
+    print(emb.embed_query("Test"))

llm.py

@@ -0,0 +1,31 @@
+"""
+llm.py – LLM local über Ollama (z.B. qwen2.5:1.5b-instruct)
+Kein HF Inference, komplett kostenlos.
+"""
+
+from langchain_community.chat_models import ChatOllama
+
+
+MODEL_NAME = "qwen2.5:1.5b-instruct"
+
+
+def load_llm():
+    """
+    Erstellt ein ChatOllama-Modell, das auf den lokal laufenden
+    Ollama-Server (http://localhost:11434) zugreift.
+    """
+    print(f">>> Lade lokales Ollama-LLM: {MODEL_NAME}")
+
+    llm = ChatOllama(
+        model=MODEL_NAME,
+        temperature=0.0,       # deterministisch
+        base_url="http://127.0.0.1:11434",
+    )
+
+    print(">>> LLM ready.\n")
+    return llm
+
+
+if __name__ == "__main__":
+    llm = load_llm()
+    print(llm.invoke("Sag einen kurzen Satz auf Deutsch."))

load_documents.py

@@ -0,0 +1,92 @@
+# load_documents.py – Supabase + PDF + Paragraph-Viewer
+
+import os
+import requests
+import tempfile
+from supabase import create_client
+from langchain_core.documents import Document
+from langchain_community.document_loaders import PyPDFLoader
+
+# ===== ENV =====
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_ANON_KEY = os.getenv("SUPABASE_ANON_KEY")
+
+if not SUPABASE_URL or not SUPABASE_ANON_KEY:
+    raise RuntimeError("Missing SUPABASE_URL / SUPABASE_ANON_KEY")
+
+supabase = create_client(SUPABASE_URL, SUPABASE_ANON_KEY)
+
+# ===== PDF (Prüfungsordnung) im Storage =====
+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}"
+
+# ===== Paragraph-Viewer (hg_clean.html) im Bucket "hg_viewer" =====
+HG_HTML_URL = f"{SUPABASE_URL}/storage/v1/object/public/hg_viewer/hg_clean.html"
+
+
+def load_hg_nrw():
+    print(">>> Lade Hochschulgesetz NRW (§) aus Tabelle hg_nrw …")
+
+    rows = (
+        supabase.table("hg_nrw")
+        .select("*")
+        .order("order_index")
+        .execute()
+    ).data
+
+    docs = []
+    for r in rows:
+        abs_id = r["abs_id"]   # z.B. para_1
+        title = r["title"]     # z.B. § 1 (Fn 44) Geltungsbereich
+        content = r["content"] # kompletter Text inkl. Fußnoten
+
+        # HTML-Viewer: <div id="para_1">…</div>
+        viewer_url = f"{HG_HTML_URL}#{abs_id}"
+
+        docs.append(
+            Document(
+                page_content=f"{title}\n{content}",
+                metadata={
+                    "source": "Hochschulgesetz NRW",
+                    "paragraph": title,
+                    "url": viewer_url,
+                },
+            )
+        )
+
+    print(f"✔ {len(docs)} Paragraphen geladen.\n")
+    return docs
+
+
+def load_pdf():
+    print(">>> Lade Prüfungsordnung PDF …")
+
+    resp = requests.get(PDF_URL)
+    resp.raise_for_status()
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+        tmp.write(resp.content)
+        path = tmp.name
+
+    pages = PyPDFLoader(path).load()
+
+    for i, p in enumerate(pages):
+        p.metadata["source"] = "Prüfungsordnung (PDF)"
+        p.metadata["page"] = i
+        p.metadata["pdf_url"] = PDF_URL
+
+    print(f"✔ {len(pages)} PDF-Seiten geladen.\n")
+    return pages
+
+
+def load_documents():
+    docs = []
+    docs.extend(load_hg_nrw())
+    docs.extend(load_pdf())
+    print(f"✔ DOCUMENTS LOADED: {len(docs)}\n")
+    return docs
+
+
+if __name__ == "__main__":
+    d = load_documents()
+    print("Example doc:", d[0])

rag_pipeline.py

@@ -0,0 +1,111 @@
+# rag_pipeline.py – SUPABASE RAG VERSION
+
+from typing import List, Dict, Any, Tuple
+from langchain_core.messages import SystemMessage, HumanMessage
+
+MAX_CHARS = 900
+
+
+def build_sources_metadata(docs: List) -> List[Dict[str, Any]]:
+    srcs = []
+
+    for i, d in enumerate(docs):
+        meta = d.metadata
+        src = meta.get("source")
+        page = meta.get("page")
+        snippet = d.page_content[:300].replace("\n", " ")
+
+        if src == "Prüfungsordnung (PDF)":
+            pdf_url = meta["pdf_url"]
+            if isinstance(page, int) and pdf_url:
+                url = f"{pdf_url}#page={page + 1}"
+            else:
+                url = pdf_url
+
+        elif src == "Hochschulgesetz NRW":
+            url = meta["url"]
+            page = None
+
+        else:
+            url = None
+
+        srcs.append(
+            {
+                "id": i + 1,
+                "source": src,
+                "page": page + 1 if isinstance(page, int) else None,
+                "url": url,
+                "snippet": snippet,
+            }
+        )
+
+    return srcs
+
+
+def format_context(docs):
+    if not docs:
+        return "(Kein relevanter Kontext gefunden.)"
+
+    out_lines = []
+    for i, d in enumerate(docs):
+        txt = d.page_content[:MAX_CHARS]
+        src = d.metadata.get("source")
+        page = d.metadata.get("page")
+
+        if src == "Prüfungsordnung (PDF)" and isinstance(page, int):
+            src_str = f"{src}, Seite {page + 1}"
+        else:
+            src_str = src
+
+        out_lines.append(f"[KONTEXT {i+1}] ({src_str})\n{txt}")
+
+    return "\n\n".join(out_lines)
+
+
+SYSTEM_PROMPT = """
+Du bist ein juristisch präziser Chatbot für Prüfungsrecht.
+Du nutzt ausschließlich:
+
+- die Prüfungsordnung (PDF) und
+- das Hochschulgesetz NRW (Absätze aus der Datenbank)
+
+Regeln:
+
+1. Keine Halluzinationen – nur Inhalte aus dem gelieferten Kontext.
+2. Wenn der Kontext unklar ist, sage ausdrücklich, dass keine sichere
+   Aussage möglich ist.
+3. Antworte immer in gut verständlichem, ganzen Sätzen.
+4. Nenne, soweit im Kontext erkennbar:
+   - Paragraphen oder Überschriften,
+   - das Dokument (Prüfungsordnung / Hochschulgesetz NRW),
+   - Seitenzahl (bei der Prüfungsordnung).
+"""
+
+
+def answer(question: str, retriever, chat_model) -> Tuple[str, List[Dict[str, Any]]]:
+    docs = retriever.invoke(question)
+    context_str = format_context(docs)
+
+    human = f"""
+FRAGE:
+{question}
+
+NUTZE AUSSCHLIESSLICH DIESEN KONTEXT:
+{context_str}
+
+AUFGABE:
+Erstelle eine juristisch korrekte Antwort ausschließlich auf Basis
+des obigen Kontextes. Wenn der Kontext keine sichere Antwort zulässt,
+sage das ausdrücklich und verzichte auf Spekulationen.
+"""
+
+    msgs = [
+        SystemMessage(content=SYSTEM_PROMPT),
+        HumanMessage(content=human),
+    ]
+
+    result = chat_model.invoke(msgs)
+    answer_text = result.content.strip()
+
+    sources = build_sources_metadata(docs)
+    return answer_text, sources

retriever.py

@@ -0,0 +1,14 @@
+"""
+BƯỚC 5: RETRIEVER
+"""
+
+from langchain_community.vectorstores import FAISS
+
+RETRIEVER_K = 4
+
+
+def get_retriever(vectorstore: FAISS, k: int = RETRIEVER_K):
+    print(f">>> Creating retriever with k={k} ...")
+    retriever = vectorstore.as_retriever(search_kwargs={"k": k})
+    print(">>> Retriever ready.\n")
+    return retriever

speech_io.py

@@ -0,0 +1,100 @@
+"""
+speech_io.py – STT + TTS lokal (transformers)
+"""
+
+from typing import Optional, Tuple
+import numpy as np
+import soundfile as sf
+from scipy.signal import butter, filtfilt
+from transformers import pipeline
+
+ASR_MODEL_ID = "openai/whisper-small"
+TTS_MODEL_ID = "facebook/mms-tts-deu"
+
+_asr = None
+_tts = None
+
+
+def get_asr_pipeline():
+    global _asr
+    if _asr is None:
+        print(f">>> Lade ASR Modell: {ASR_MODEL_ID}")
+        _asr = pipeline(
+            task="automatic-speech-recognition",
+            model=ASR_MODEL_ID,
+            device="cpu",
+            return_timestamps=True,
+            chunk_length_s=30,
+        )
+    return _asr
+
+
+def get_tts_pipeline():
+    global _tts
+    if _tts is None:
+        print(f">>> Lade TTS Modell: {TTS_MODEL_ID}")
+        _tts = pipeline(
+            task="text-to-speech",
+            model=TTS_MODEL_ID,
+        )
+    return _tts
+
+
+def butter_highpass_filter(data, cutoff=60, fs=16000, order=4):
+    nyq = 0.5 * fs
+    norm_cutoff = cutoff / nyq
+    b, a = butter(order, norm_cutoff, btype="high")
+    return filtfilt(b, a, data)
+
+
+def apply_fade(audio, sr, duration_ms=10):
+    fade_samples = int(sr * duration_ms / 1000)
+    if fade_samples * 2 >= len(audio):
+        return audio
+    fade_in_curve = np.linspace(0, 1, fade_samples)
+    audio[:fade_samples] *= fade_in_curve
+    fade_out_curve = np.linspace(1, 0, fade_samples)
+    audio[-fade_samples:] *= fade_out_curve
+    return audio
+
+
+def transcribe_audio(audio_path: str) -> str:
+    if audio_path is None:
+        return ""
+    data, sr = sf.read(audio_path)
+    if len(data.shape) > 1:
+        data = data[:, 0]
+    MAX_SAMPLES = sr * 30
+    if len(data) > MAX_SAMPLES:
+        data = data[:MAX_SAMPLES]
+    asr = get_asr_pipeline()
+    print(">>> Transkribiere Audio...")
+    result = asr({"array": data, "sampling_rate": sr})
+    text = result.get("text", "").strip()
+    print("ASR:", text)
+    return text
+
+
+def synthesize_speech(text: str):
+    if not text or not text.strip():
+        return None
+    tts = get_tts_pipeline()
+    out = tts(text)
+    audio = np.array(out["audio"], dtype=np.float32)
+    sr = out.get("sampling_rate", 16000)
+    if sr is None or sr <= 0 or sr > 65535:
+        sr = 16000
+    if audio.ndim > 1:
+        audio = audio.squeeze()
+    if audio.ndim > 1:
+        audio = audio[:, 0]
+    try:
+        audio = butter_highpass_filter(audio, cutoff=60, fs=sr)
+    except Exception:
+        pass
+    max_val = np.max(np.abs(audio))
+    if max_val > 0:
+        audio = audio / max_val
+    audio = apply_fade(audio, sr)
+    audio_int16 = np.clip(audio * 32767, -32768, 32767).astype(np.int16)
+    return (sr, audio_int16)

split_documents.py

@@ -0,0 +1,28 @@
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+CHUNK_SIZE = 1500
+CHUNK_OVERLAP = 200
+
+
+def split_documents(docs):
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=CHUNK_SIZE,
+        chunk_overlap=CHUNK_OVERLAP,
+        separators=["\n\n", "\n", ". ", " ", ""],
+    )
+    chunks = splitter.split_documents(docs)
+
+    for c in chunks:
+        c.metadata["chunk_size"] = CHUNK_SIZE
+        c.metadata["chunk_overlap"] = CHUNK_OVERLAP
+
+    return chunks
+
+
+if __name__ == "__main__":
+    from load_documents import load_documents
+
+    docs = load_documents()
+    chunks = split_documents(docs)
+    print("Docs:", len(docs), "Chunks:", len(chunks))
+    print(chunks[0].page_content[:300], chunks[0].metadata)

vectorstore.py

@@ -0,0 +1,30 @@
+"""
+BƯỚC 4: VECTORSTORE (FAISS in-memory)
+"""
+
+from langchain_community.vectorstores import FAISS
+from embeddings import get_embeddings
+
+
+def build_vectorstore(chunks):
+    print(">>> Initialising embedding model for FAISS index ...")
+    embeddings = get_embeddings()
+
+    print(f">>> Building FAISS index from {len(chunks)} chunks ...")
+    vs = FAISS.from_documents(chunks, embeddings)
+    print(">>> FAISS index built.\n")
+    return vs
+
+
+if __name__ == "__main__":
+    from load_documents import load_documents
+    from split_documents import split_documents
+
+    docs = load_documents()
+    chunks = split_documents(docs)
+    vs = build_vectorstore(chunks)
+    res = vs.similarity_search(
+        "Fristen für die Prüfungsanmeldung im Bachelorstudium", k=3
+    )
+    for r in res:
+        print(r.page_content[:200], r.metadata)