commit

app.py

@@ -1,4 +1,4 @@
-# app.py
+# app.py – fixed Quelle links
 import os
 import base64
 import gradio as gr
@@ -10,30 +10,21 @@ from rag_pipeline import rag_answer
 client = OpenAI()
 BUCKET = os.environ["SUPABASE_BUCKET"]
 
-# ------------------------------------------
-# Public URLs để mở PDF/HTML khi nhấn Quelle
-# ------------------------------------------
-PDF_URL = f"{os.environ['SUPABASE_URL']}/storage/v1/object/public/{BUCKET}/pruefungsordnung.pdf"
-HG_URL  = f"{os.environ['SUPABASE_URL']}/storage/v1/object/public/{BUCKET}/hochschulgesetz.html"
+SUPABASE_URL = os.environ["SUPABASE_URL"]
+PDF_URL      = f"{SUPABASE_URL}/storage/v1/object/public/{BUCKET}/pruefungsordnung.pdf"
+HG_URL       = f"{SUPABASE_URL}/storage/v1/object/public/{BUCKET}/hochschulgesetz.html"
+
 
-# ------------------------------------------
-# Viewer PDF base64
-# ------------------------------------------
 def encode_pdf_src():
     pdf_bytes = load_file_bytes(BUCKET, "pruefungsordnung.pdf")
-    b64 = base64.b64encode(pdf_bytes).decode("utf-8")
-    return f"data:application/pdf;base64,{b64}"
+    return f"data:application/pdf;base64,{base64.b64encode(pdf_bytes).decode('utf-8')}"
+
 
-# ------------------------------------------
-# HTML viewer
-# ------------------------------------------
 def encode_html():
     html_bytes = load_file_bytes(BUCKET, "hochschulgesetz.html")
     return html_bytes.decode("utf-8", errors="ignore")
 
-# ------------------------------------------
-# Speech-to-text FIXED
-# ------------------------------------------
+
 def transcribe(audio_path):
     if audio_path is None:
         return ""
@@ -41,21 +32,18 @@ def transcribe(audio_path):
         result = client.audio.transcriptions.create(
             model="whisper-1",
             file=f,
-            language="de",      # ép tiếng Đức
-            temperature=0.0     # ổn định kết quả
+            language="de",
+            temperature=0.0
         )
     return (result.text or "").strip()
 
-# ------------------------------------------
-# MAIN CHAT FUNCTION
-# ------------------------------------------
+
 def chat_fn(text, audio, history):
     text = (text or "").strip()
 
-    # 1) Ưu tiên text, không dùng audio nếu text có
     if text:
         question = text
-    elif audio is not None:
+    elif audio:
         question = transcribe(audio)
     else:
         return history, "<p>Bitte Text oder Mikrofon benutzen.</p>", None
@@ -63,88 +51,72 @@ def chat_fn(text, audio, history):
     if not question:
         return history, "<p>Spracherkennung fehlgeschlagen.</p>", None
 
-    # 2) RAG
     answer, docs = rag_answer(question, history or [])
 
-    # 3) Build Quellen (click được, phân biệt PDF vs HTML)
     html = "<ol>"
     for i, d in enumerate(docs):
-        meta = d.get("metadata", {}) or {}
-        src = meta.get("source", "?")
-        page = meta.get("page", None)
-        anchor_id = meta.get("anchor_id")  # từ ingest.py
-
-        # Chọn link tùy nguồn
-        if "Prüfungsordnung" in src:
-            # cố gắng nhảy đúng Seite
-            if page:
-                link = f"{PDF_URL}#page={page}"
-            else:
-                link = PDF_URL
-            page_info = f"(Seite {page})" if page else ""
+        meta = d["metadata"]
+        src  = meta.get("source")
+        page = meta.get("page")
+        anchor = meta.get("anchor_id")
+
+        # PDF vs HTML
+        if src == "Prüfungsordnung (PDF)":
+            link = f"{PDF_URL}#page={page+1}" if isinstance(page, int) else PDF_URL
         else:
-            # Hochschulgesetz NRW – dùng anchor_id trong hochschulgesetz.html
-            if anchor_id:
-                link = f"{HG_URL}#{anchor_id}"
-            else:
-                link = HG_URL
-            page_info = ""  # HTML không có page
+            link = f"{HG_URL}#{anchor}" if anchor else HG_URL
 
-        snippet = (d.get("content") or "")[:200]
+        snippet = d["content"][:200].replace("\n", " ")
 
         html += f"""
         <li>
             <a href="{link}" target="_blank">
-                <b>Quelle {i+1}: {src} {page_info}</b>
+                <b>Quelle {i+1}: {src}</b>
             </a><br>
             {snippet}...
         </li>
         """
     html += "</ol>"
 
-    # 4) Gradio message history (kiểu messages)
     new_history = (history or []) + [
         {"role": "user", "content": question},
         {"role": "assistant", "content": answer},
     ]
 
-    # Reset audio input (xóa sóng cũ)
     return new_history, html, gr.update(value=None)
 
-# ------------------------------------------
-# UI LAYOUT
-# ------------------------------------------
+
 with gr.Blocks() as demo:
-    gr.Markdown("# ⚖️ Sprachbasierter Chatbot für Prüfungsrecht")
+    gr.Markdown("# ⚖️ Prüfungsrechts-Chatbot (RAG mit Supabase)")
 
     with gr.Row():
+
         with gr.Column(scale=3):
-            chatbot = gr.Chatbot(label="Chat (RAG)")
-            text_input = gr.Textbox(label="Text Eingabe")
+            chatbot = gr.Chatbot(type="messages", label="Chat")
+            text_input = gr.Textbox(label="Frage eingeben")
             audio_input = gr.Audio(
-                type="filepath",
-                label="Spracheingabe (Mikrofon)"
+                type="filepath", label="Spracheingabe (Mikrofon)"
             )
             send_btn = gr.Button("Senden")
 
         with gr.Column(scale=2):
-            gr.Markdown("### 📄 Prüfungsordnung PDF")
+            gr.Markdown("### Prüfungsordnung (PDF)")
             gr.HTML(
-                f"<iframe src='{encode_pdf_src()}' width='100%' height='250'></iframe>"
+                f"<iframe src='{encode_pdf_src()}' width='100%' height='260px'></iframe>"
             )
 
-            gr.Markdown("### 📜 Hochschulgesetz NRW")
+            gr.Markdown("### Hochschulgesetz NRW")
             gr.HTML(
-                f"<div style='overflow:auto;height:250px;'>{encode_html()}</div>"
+                f"<div style='overflow:auto;height:260px;'>{encode_html()}</div>"
             )
 
             sources_html = gr.HTML()
 
     send_btn.click(
         chat_fn,
-        inputs=[text_input, audio_input, chatbot],
-        outputs=[chatbot, sources_html, audio_input],
+        [text_input, audio_input, chatbot],
+        [chatbot, sources_html, audio_input]
     )
 
 if __name__ == "__main__":
-    demo.launch(ssr_mode=False)
+demo.queue().launch(ssr_mode=False, show_error=True)

ingest.py

@@ -10,55 +10,85 @@ from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_core.documents import Document
 
 BUCKET = os.environ["SUPABASE_BUCKET"]
+SUPABASE_URL = os.environ["SUPABASE_URL"]
+
+PDF_URL = f"{SUPABASE_URL}/storage/v1/object/public/{BUCKET}/pruefungsordnung.pdf"
+HG_URL  = f"{SUPABASE_URL}/storage/v1/object/public/{BUCKET}/hochschulgesetz.html"
+
 
 def load_pdf_docs():
     pdf_bytes = load_file_bytes(BUCKET, "pruefungsordnung.pdf")
     reader = PdfReader(BytesIO(pdf_bytes))
+
     docs = []
     for i, page in enumerate(reader.pages):
         text = page.extract_text() or ""
-        docs.append(Document(
-            page_content=text,
-            metadata={"source": "Prüfungsordnung", "page": i + 1},
-        ))
+
+        docs.append(
+            Document(
+                page_content=text,
+                metadata={
+                    "source": "Prüfungsordnung (PDF)",
+                    "page": i,                  # ZERO-based: Seite = i+1
+                    "pdf_url": PDF_URL,         # Basis-URL
+                },
+            )
+        )
     return docs
 
+
 def load_html_docs():
     html_bytes = load_file_bytes(BUCKET, "hochschulgesetz.html")
     html = html_bytes.decode("utf-8", errors="ignore")
+
     soup = BeautifulSoup(html, "html.parser")
     text = soup.get_text(separator="\n")
-    return [Document(
-        page_content=text,
-        metadata={"source": "Hochschulgesetz NRW"},
-    )]
+
+    # HTML nicht in Paragraphen getrennt → wir chunk’en später
+    return [
+        Document(
+            page_content=text,
+            metadata={
+                "source": "Hochschulgesetz NRW",
+                # anchor_id wird erst beim Chunken vergeben
+            },
+        )
+    ]
+
 
 def chunk_docs(docs):
     splitter = RecursiveCharacterTextSplitter(
-        chunk_size=900, chunk_overlap=100)
+        chunk_size=900,
+        chunk_overlap=100,
+    )
     return splitter.split_documents(docs)
 
+
 def ingest():
     pdf_docs = load_pdf_docs()
     hg_docs = load_html_docs()
+
     chunks = chunk_docs(pdf_docs + hg_docs)
 
-    # gán anchor_id
-    po_index = 1
-    hg_index = 1
+    po_idx = 1
+    hg_idx = 1
 
     for d in chunks:
         src = d.metadata["source"]
-        if src == "Prüfungsordnung":
-            d.metadata["anchor_id"] = f"po_{po_index}"
-            po_index += 1
+
+        if src == "Prüfungsordnung (PDF)":
+            d.metadata["anchor_id"] = f"po_{po_idx}"
+            po_idx += 1
         else:
-            d.metadata["anchor_id"] = f"hg_{hg_index}"
-            hg_index += 1
+            d.metadata["anchor_id"] = f"hg_{hg_idx}"
+            hg_idx += 1
+
+        # HTML Quelle als vollständige URL
+        if src == "Hochschulgesetz NRW":
+            d.metadata["url"] = f"{HG_URL}#{d.metadata['anchor_id']}"
 
     embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
 
-    # insert thủ công
     for d in chunks:
         emb = embeddings.embed_query(d.page_content)
         supabase.table("documents").insert({
@@ -67,7 +97,8 @@ def ingest():
             "embedding": emb
         }).execute()
 
-    print("OK ✔ ingest xong – đã có anchor_id cho tất cả documents")
+    print("OK ✔ ingest xong – PDF + HTML mit Quelle-URL")
+
 
 if __name__ == "__main__":
     ingest()

rag_pipeline.py

@@ -1,5 +1,5 @@
 # rag_pipeline.py
-import os
+from typing import List, Dict, Any
 from datetime import date
 from openai import OpenAI
 from supabase_client import supabase
@@ -8,14 +8,15 @@ from langchain_openai import OpenAIEmbeddings
 client = OpenAI()
 embedder = OpenAIEmbeddings(model="text-embedding-3-small")
 
+
 def get_relevant_docs(query, k=4):
     emb = embedder.embed_query(query)
-    resp = supabase.rpc("match_documents", {
-        "query_embedding": emb,
-        "filter": {}
-    }).execute()
+    resp = supabase.rpc("match_documents",
+        {"query_embedding": emb, "filter": {}}
+    ).execute()
     return (resp.data or [])[:k]
 
+
 def save_message(role, content):
     supabase.table("chat_history").insert({
         "session_date": date.today().isoformat(),
@@ -23,14 +24,16 @@ def save_message(role, content):
         "message": content
     }).execute()
 
+
 def rag_answer(query, history):
     docs = get_relevant_docs(query)
+
     context = ""
     for i, d in enumerate(docs):
         meta = d["metadata"]
-        src = meta["source"]
+        src  = meta.get("source")
         page = meta.get("page")
-        page_info = f"(Seite {page})" if page else ""
+        page_info = f"(Seite {page+1})" if isinstance(page, int) else ""
         context += f"[Quelle {i+1}] {src} {page_info}\n{d['content']}\n\n"
 
     messages = [
@@ -39,12 +42,13 @@ def rag_answer(query, history):
     ]
 
     res = client.chat.completions.create(
-        model="gpt-4.1-mini",
+        model="gpt-4o-mini",
         messages=messages,
-        temperature=0
+        temperature=0.0,
     )
 
     answer = res.choices[0].message.content
+
     save_message("user", query)
     save_message("assistant", answer)