commit

app.py

@@ -2,12 +2,16 @@
 import os
 import re
 import base64
+
 import gradio as gr
 from openai import OpenAI
 
 from supabase_client import load_file_bytes
-from rag_pipeline import rag_answer
+from rag_pipeline import rag_answer  # agent_answer alias
 
+# -------------------------------------------------------------------
+# OpenAI client cho Whisper (Speech-to-Text)
+# -------------------------------------------------------------------
 client = OpenAI()
 
 BUCKET = os.environ["SUPABASE_BUCKET"]
@@ -18,32 +22,46 @@ HG_URL = "https://recht.nrw.de/lmi/owa/br_text_anzeigen?v_id=1000000000000000065
 
 
 # -------------------------------------------------------------------
-# PDF BASE64 để nhúng iframe
+# PDF Viewer (Base64 iframe)
 # -------------------------------------------------------------------
-def encode_pdf_src():
+def encode_pdf_src() -> str:
     pdf_bytes = load_file_bytes(BUCKET, "pruefungsordnung.pdf")
     b64 = base64.b64encode(pdf_bytes).decode("utf-8")
     return f"data:application/pdf;base64,{b64}"
 
 
 # -------------------------------------------------------------------
-# CLEAN STT
+# Speech-to-Text (Whisper) + cleaning
 # -------------------------------------------------------------------
-FILLER = ["äh", "ähm", "uh", "hmm", "mmh", "ah", "oh", "also", "sozusagen", "halt"]
-
-
-def clean_transcript(t):
+FILLER = [
+    "äh",
+    "ähm",
+    "uh",
+    "hmm",
+    "mmh",
+    "ah",
+    "oh",
+    "also",
+    "sozusagen",
+    "halt",
+    "irgendwie",
+]
+
+
+def clean_transcript(t: str) -> str:
     if not t:
         return ""
     t = t.lower().strip()
     for f in FILLER:
-        t = re.sub(rf"\b{f}\b", "", t)
+        t = re.sub(rf"\b{re.escape(f)}\b", "", t)
     t = re.sub(r"[^a-zA-ZäöüÄÖÜß0-9,.? ]+", " ", t)
     t = re.sub(r"\s+", " ", t).strip()
-    return t.capitalize()
+    if len(t) > 1:
+        t = t[0].upper() + t[1:]
+    return t
 
 
-def transcribe(audio_path):
+def transcribe(audio_path: str) -> str:
     if audio_path is None:
         return ""
     with open(audio_path, "rb") as f:
@@ -53,53 +71,69 @@ def transcribe(audio_path):
             language="de",
             temperature=0.0,
         )
-    return clean_transcript(result.text or "")
+    raw = (result.text or "").strip()
+    cleaned = clean_transcript(raw)
+    return cleaned if len(cleaned) >= 3 else ""
 
 
 # -------------------------------------------------------------------
-# CHAT FUNCTION — KHÔNG ƯU TIÊN TEXT/AUDIO
-# User CHỌN mode: "text" hoặc "audio"
+# Hàm CHAT chính – gọi Agent (rag_answer)
 # -------------------------------------------------------------------
 def chat_fn(mode, text, audio, history):
     history = history or []
 
-    # --- MODE: TEXT ---
+    # 1) Chọn câu hỏi theo mode
     if mode == "text":
         if not (text or "").strip():
             return history, "Bitte Text eingeben.", None
         question = text.strip()
-
-    # --- MODE: SPRACHE ---
-    if mode == "audio":
+    else:  # mode == "audio"
         if audio is None:
             return history, "Bitte ins Mikrofon sprechen.", None
-
         question = transcribe(audio)
         if not question:
-            return history, "Spracherkennung fehlgeschlagen. Bitte erneut versuchen.", None
+            return (
+                history,
+                "Spracherkennung fehlgeschlagen. Bitte erneut versuchen.",
+                None,
+            )
 
-    # --- RAG ---
+    # 2) Gọi Agent (RAG + Tools)
     answer, docs = rag_answer(question, history)
 
-    # --- Quellen ---
-    quellen = ["", "### 📚 Quellen:"]
-    for i, d in enumerate(docs):
-        meta = d["metadata"]
-        src = meta.get("source")
+    # 3) Xây block Quellen (UI-friendly)
+    quellen_md_lines = ["", "### 📚 Verwendete Quellen"]
 
-        if src.startswith("Prüfungsordnung"):
-            page = meta.get("page")
-            url = f"{PDF_URL}#page={page}"
-            title = f"Quelle {i+1} – Prüfungsordnung, Seite {page}"
+    for i, d in enumerate(docs):
+        meta = d.get("metadata", {}) or {}
+        src = meta.get("source", "?")
+        page = meta.get("page", None)
+
+        # Prüfungsordnung – nhảy đúng Seite
+        if isinstance(src, str) and src.startswith("Prüfungsordnung"):
+            page_num = page if isinstance(page, int) else None
+            if page_num:
+                url = f"{PDF_URL}#page={page_num}"
+                title = f"Quelle {i+1}: Prüfungsordnung (Seite {page_num})"
+            else:
+                url = PDF_URL
+                title = f"Quelle {i+1}: Prüfungsordnung"
+        # Hochschulgesetz – link trang chính thức
         else:
             url = HG_URL
-            title = f"Quelle {i+1} – Hochschulgesetz NRW"
+            title = f"Quelle {i+1}: Hochschulgesetz NRW"
 
-        snip = d["content"][:160].replace("\n", " ")
-        quellen.append(f"- [{title}]({url})")
-        quellen.append(f"  > {snip}")
+        snippet = (d.get("content") or "").strip().replace("\n", " ")
+        snippet = snippet[:200] + ("…" if len(snippet) > 200 else "")
 
-    bot_msg = answer + "\n\n" + "\n".join(quellen)
+        quellen_md_lines.append(
+            f"- [{title}]({url})\n"
+            f"  - **Ausschnitt:** „{snippet}“"
+        )
+
+    quellen_md = "\n".join(quellen_md_lines)
+
+    bot_msg = answer + "\n\n" + quellen_md
 
     new_history = history + [
         {"role": "user", "content": question},
@@ -110,22 +144,26 @@ def chat_fn(mode, text, audio, history):
 
 
 # -------------------------------------------------------------------
-# UI — GIỐNG HÌNH ĐÍNH KÈM
+# Giao diện Gradio – UI thân thiện
 # -------------------------------------------------------------------
 with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+# ⚖️ Prüfungsrechts-Assistent (NRW)
 
-    gr.Markdown("""
-    # ⚖️ Sprachbasierter Chatbot für Prüfungsrecht  
-    Wähle eine Eingabemethode: Text oder Sprache.
-    """)
+Willkommen!  
+Ich beantworte Ihre Fragen auf Basis der **offiziellen Dokumente**:
 
-    with gr.Row():
+- 📘 *Prüfungsordnung Ihrer Hochschule*  
+- 📗 *Hochschulgesetz NRW (recht.nrw.de)*  
 
-        # ======================
-        # LEFT SIDE: CHAT UI
-        # ======================
-        with gr.Column(scale=3):
+Wählen Sie unten: **Text** oder **Sprache**.
+"""
+    )
 
+    with gr.Row():
+        # LEFT: Chat
+        with gr.Column(scale=3):
             chatbot = gr.Chatbot(label="Chatverlauf")
 
             mode_select = gr.Radio(
@@ -136,16 +174,15 @@ with gr.Blocks() as demo:
             )
 
             text_input = gr.Textbox(label="Text eingeben")
-            audio_input = gr.Audio(type="filepath", label="Spracheingabe (Mikrofon)")
+            audio_input = gr.Audio(
+                type="filepath", label="Spracheingabe (Mikrofon)"
+            )
 
             send_btn = gr.Button("Senden")
             answer_preview = gr.Markdown("")
 
-        # ======================
-        # RIGHT SIDE: VIEWER
-        # ======================
+        # RIGHT: Viewer
         with gr.Column(scale=2):
-
             gr.Markdown("### 📄 Prüfungsordnung (PDF)")
             gr.HTML(
                 f"<iframe src='{encode_pdf_src()}' width='100%' height='250' style='border:none;'></iframe>"

ingest.py

@@ -6,9 +6,11 @@ from bs4 import BeautifulSoup
 from pypdf import PdfReader
 
 from supabase_client import supabase, load_file_bytes
+
 from langchain_openai import OpenAIEmbeddings
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_core.documents import Document
+from langchain_community.vectorstores import SupabaseVectorStore
 
 # -------------------------------------------------------------------
 # ENV + URLs
@@ -16,12 +18,12 @@ from langchain_core.documents import Document
 BUCKET = os.environ["SUPABASE_BUCKET"]
 SUPABASE_URL = os.environ["SUPABASE_URL"]
 
-# Public URLs trong Supabase Storage (chỉ dùng để tham chiếu / Quelle)
 PDF_URL = f"{SUPABASE_URL}/storage/v1/object/public/{BUCKET}/pruefungsordnung.pdf"
 HG_STORAGE_URL = f"{SUPABASE_URL}/storage/v1/object/public/{BUCKET}/hochschulgesetz.html"
 
-# (In App dùng link chính thức của HG NRW, còn đây chỉ để meta nếu cần)
-OFFICIAL_HG_URL = "https://recht.nrw.de/lmi/owa/br_text_anzeigen?v_id=10000000000000000654"
+OFFICIAL_HG_URL = (
+    "https://recht.nrw.de/lmi/owa/br_text_anzeigen?v_id=10000000000000000654"
+)
 
 
 # -------------------------------------------------------------------
@@ -29,13 +31,8 @@ OFFICIAL_HG_URL = "https://recht.nrw.de/lmi/owa/br_text_anzeigen?v_id=1000000000
 # -------------------------------------------------------------------
 def load_pdf_docs():
     """
-    PDF Prüfungsordnung:
-    - Đọc từ Supabase Storage
-    - Trích text từng trang
-    - Mỗi trang là 1 Document với metadata:
-        - source: "Prüfungsordnung (PDF)"
-        - page: SỐ TRANG 1-based (Seite 1, 2, 3, ...)
-        - pdf_url: URL public của PDF trong Supabase (không #page)
+    Đọc Prüfungsordnung.pdf từ Supabase Storage và tạo 1 Document cho mỗi
+    trang (page 1-based).
     """
     pdf_bytes = load_file_bytes(BUCKET, "pruefungsordnung.pdf")
     reader = PdfReader(BytesIO(pdf_bytes))
@@ -43,8 +40,6 @@ def load_pdf_docs():
     docs = []
     for i, page in enumerate(reader.pages):
         text = page.extract_text() or ""
-
-        # Lưu page 1-based để sau dùng trực tiếp trong UI
         page_num = i + 1
 
         docs.append(
@@ -52,8 +47,8 @@ def load_pdf_docs():
                 page_content=text,
                 metadata={
                     "source": "Prüfungsordnung (PDF)",
-                    "page": page_num,          # 1-based
-                    "pdf_url": PDF_URL,        # Basis-URL
+                    "page": page_num,
+                    "pdf_url": PDF_URL,
                 },
             )
         )
@@ -61,15 +56,12 @@ def load_pdf_docs():
 
 
 # -------------------------------------------------------------------
-# Loader HTML Hochschulgesetz (từ Storage)
+# Loader HTML Hochschulgesetz
 # -------------------------------------------------------------------
 def load_html_docs():
     """
-    Hochschulgesetz NRW (giữ 1 Document lớn, chunk sau).
-    Lưu ý:
-    - Ta load bản HTML từ Supabase Storage (trước đó đã crawl/lưu).
-    - get_text(separator="\\n") để giữ cấu trúc tương đối.
-    - Việc chunk sẽ do TextSplitter xử lý.
+    Đọc hochschulgesetz.html từ Supabase Storage, parse bằng BeautifulSoup,
+    lấy toàn bộ text thành 1 Document lớn (chunk sau).
     """
     html_bytes = load_file_bytes(BUCKET, "hochschulgesetz.html")
     html = html_bytes.decode("utf-8", errors="ignore")
@@ -82,7 +74,6 @@ def load_html_docs():
             page_content=text,
             metadata={
                 "source": "Hochschulgesetz NRW",
-                # anchor_id sẽ được gán sau khi chunk
                 "official_url": OFFICIAL_HG_URL,
             },
         )
@@ -90,14 +81,9 @@ def load_html_docs():
 
 
 # -------------------------------------------------------------------
-# Text-Splitter chung
+# Chunking – RecursiveCharacterTextSplitter
 # -------------------------------------------------------------------
 def chunk_docs(docs):
-    """
-    Dùng RecursiveCharacterTextSplitter để chia nhỏ nội dung.
-    - chunk_size: 900
-    - chunk_overlap: 100
-    """
     splitter = RecursiveCharacterTextSplitter(
         chunk_size=900,
         chunk_overlap=100,
@@ -106,20 +92,41 @@ def chunk_docs(docs):
 
 
 # -------------------------------------------------------------------
-# Ingest vào Supabase (bảng documents)
+# Xoá dữ liệu cũ trong bảng documents
+# -------------------------------------------------------------------
+def delete_old_data():
+    """
+    Xoá toàn bộ rows trong bảng 'documents'.
+
+    Cột id là UUID, nên dùng điều kiện >= với UUID nhỏ nhất để tránh lỗi
+    'invalid input syntax for type uuid'.
+    """
+    print("🔄 Lösche alte Daten aus Tabelle 'documents' ...")
+    supabase.table("documents").delete().gte(
+        "id", "00000000-0000-0000-0000-000000000000"
+    ).execute()
+    print("✔ Alte Daten in 'documents' gelöscht.")
+
+
+# -------------------------------------------------------------------
+# Ingest chính
 # -------------------------------------------------------------------
 def ingest():
-    # 1) Load nguồn
+    print("🚀 Starte Ingest (PDF + Hochschulgesetz) ...")
+
+    # 1) Xoá data cũ
+    delete_old_data()
+
+    # 2) Load nguồn
     pdf_docs = load_pdf_docs()
     hg_docs = load_html_docs()
 
-    # 2) Chunk
+    # 3) Chunk
     chunks = chunk_docs(pdf_docs + hg_docs)
 
-    # 3) Thêm anchor_id cho từng chunk để nhận diện
+    # 4) Gắn anchor_id & URL meta
     po_idx = 1
     hg_idx = 1
-
     for d in chunks:
         src = d.metadata.get("source")
 
@@ -129,26 +136,22 @@ def ingest():
         else:
             d.metadata["anchor_id"] = f"hg_{hg_idx}"
             hg_idx += 1
-
-        # Thêm URL cho HG nếu muốn dùng sau
-        if src == "Hochschulgesetz NRW":
             d.metadata["url"] = OFFICIAL_HG_URL
 
-    # 4) Embeddings
+    # 5) Embeddings + SupabaseVectorStore
     embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
 
-    for d in chunks:
-        emb = embeddings.embed_query(d.page_content)
-
-        supabase.table("documents").insert(
-            {
-                "content": d.page_content,
-                "metadata": d.metadata,
-                "embedding": emb,
-            }
-        ).execute()
+    print("🔍 Erstelle Embeddings und speichere in SupabaseVectorStore ...")
+    SupabaseVectorStore.from_documents(
+        chunks,
+        embeddings,
+        client=supabase,
+        table_name="documents",
+        query_name="match_documents",
+        chunk_size=500,  # batch size khi insert
+    )
 
-    print("OK ✔ ingest xong – Prüfungsordnung (PDF) + Hochschulgesetz (HTML)")
+    print("🎉 Ingest fertig – 'documents' ist frisch aufgebaut.")
 
 
 if __name__ == "__main__":

rag_pipeline.py

@@ -1,70 +1,112 @@
 # rag_pipeline.py
-from typing import List, Dict, Any
+from typing import Any, List, Dict
 from datetime import date
 
-from openai import OpenAI
 from supabase_client import supabase
-from langchain_openai import OpenAIEmbeddings
+
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from langchain_community.vectorstores import SupabaseVectorStore
+from langchain.tools.retriever import create_retriever_tool
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.messages import HumanMessage, AIMessage
+from langchain.agents import create_openai_tools_agent, AgentExecutor
 
 # -------------------------------------------------------------------
-# OpenAI + Embeddings
+# LLM, Embeddings, VectorStore, Retriever
 # -------------------------------------------------------------------
-client = OpenAI()
-embedder = OpenAIEmbeddings(model="text-embedding-3-small")
+_embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
+
+_vector_store = SupabaseVectorStore(
+    embedding=_embeddings,
+    client=supabase,
+    table_name="documents",
+    query_name="match_documents",
+)
+
+_retriever = _vector_store.as_retriever(search_kwargs={"k": 4})
+
+_llm = ChatOpenAI(
+    model="gpt-4o-mini",
+    temperature=0.0,
+)
 
 # -------------------------------------------------------------------
-# System Prompt (Rất quan trọng cho độ chính xác)
+# Prompt engineering – legal guardrails
 # -------------------------------------------------------------------
 SYSTEM_PROMPT = """
-Du bist ein hochpräziser, fachlich korrekter Chatbot für Prüfungsrecht in NRW.
-Du beantwortest ausschließlich auf Grundlage der offiziellen Rechtsquellen:
-
-- Prüfungsordnung (PDF)
-- Hochschulgesetz NRW (recht.nrw.de)
-
-REGELN:
-1. Verwende NUR Informationen aus den bereitgestellten Dokumenten (RAG-Kontext).
-2. Spekuliere nie. Wenn etwas nicht im Dokument steht, sage explizit, dass es dort nicht geregelt ist.
-3. Antworte in klaren, gut strukturierten Sätzen auf Deutsch.
-4. Füge am Ende deiner Antwort keine eigenen Quellen hinzu – die Quellen werden separat im UI angezeigt.
-5. Zitiere sinngemäß, nicht wortwörtlich.
-6. Wenn die Frage unklar ist, bitte freundlich um Präzisierung.
-7. Wenn mehrere Dokumentstellen relevant sind, vergleiche sie kurz.
-
-Wenn du dir unsicher bist, sag offen, dass du es auf Basis der vorliegenden Dokumente nicht sicher beantworten kannst.
-"""
+Du bist ein hochpräziser juristischer Assistent für Prüfungsrecht in NRW.
+Du arbeitest ausschließlich auf Grundlage der folgenden Dokumente:
+
+1. Prüfungsordnung (PDF)
+2. Hochschulgesetz NRW (offizielle Fassung auf recht.nrw.de)
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+REGELN FÜR DEINE ANTWORT
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+1) Nutze AUSSCHLIESSLICH die Dokumentauszüge, die du über das Tool
+   'suche_pruefungsrecht_dokumente' erhältst.
+   - Wenn eine Information NICHT im Kontext steht, antworte:
+     „Dazu liegen im bereitgestellten Dokumentenkontext keine Informationen vor.“
+
+2) Spekuliere nicht, erfinde nichts, nutze keine externen Quellen.
+
+3) Antworte strukturiert:
+   (a) kurze Einordnung,
+   (b) Kernaussage / Rechtsgrundlage,
+   (c) wichtige Bedingungen oder Ausnahmen,
+   (d) praktische Konsequenz für Studierende.
+
+4) Du fügst selbst KEINE Quellenlinks hinzu.
+   - Die UI zeigt die Quellen separat an.
+   - Du kannst aber sinngemäß auf „die Prüfungsordnung“ oder „das Hochschulgesetz“
+     verweisen.
+
+5) Wenn mehrere Dokumentstellen relevant sind, vergleiche sie kurz.
 
+6) Wenn die Frage unklar ist, bitte freundlich um Präzisierung.
+
+7) Schreibe so, dass Studierende ohne Jurastudium dich verstehen.
+"""
 
 # -------------------------------------------------------------------
-# Helper: DB RPC – match_documents
+# Retriever Tool cho Agent
 # -------------------------------------------------------------------
-def get_relevant_docs(query: str, k: int = 4) -> List[Dict[str, Any]]:
-    """
-    Ruft die RPC-Funktion `match_documents` in Supabase auf, um die relevantesten
-    Dokument-Chunks für eine Query zu finden.
-    """
-    emb = embedder.embed_query(query)
-
-    resp = (
-        supabase.rpc(
-            "match_documents",
-            {"query_embedding": emb, "filter": {}},
-        )
-        .execute()
-    )
+retriever_tool = create_retriever_tool(
+    _retriever,
+    name="suche_pruefungsrecht_dokumente",
+    description=(
+        "Suche in der Prüfungsordnung (PDF) und im Hochschulgesetz NRW "
+        "nach relevanten Gesetzesstellen zum Prüfungsrecht. "
+        "Nutze dieses Tool IMMER, bevor du eine Antwort gibst."
+    ),
+)
+
+tools = [retriever_tool]
+
+# Prompt cho Agent (dùng Tools + Memory)
+prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", SYSTEM_PROMPT),
+        MessagesPlaceholder("chat_history"),
+        (
+            "user",
+            "Aktuelle Frage:\n{input}\n\n"
+            "Nutze das Tool, um relevante Dokumentstellen zu finden, "
+            "und beantworte die Frage ausschließlich anhand dieses Kontextes.",
+        ),
+    ]
+)
 
-    data = resp.data or []
-    return data[:k]
+# Tạo Agent + Executor
+agent = create_openai_tools_agent(_llm, tools, prompt)
+agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=False)
 
 
 # -------------------------------------------------------------------
-# Helper: Chat-History in DB speichern
+# Lưu chat_history (logging) vào Supabase
 # -------------------------------------------------------------------
 def save_message(role: str, content: str) -> None:
-    """
-    Speichert eine Chatnachricht (role, content) zusammen mit dem heutigen Datum
-    in der Tabelle `chat_history`.
-    """
     supabase.table("chat_history").insert(
         {
             "session_date": date.today().isoformat(),
@@ -75,80 +117,86 @@ def save_message(role: str, content: str) -> None:
 
 
 # -------------------------------------------------------------------
-# Hauptfunktion: RAG-Antwort generieren
+# Convert history của Gradio → chat_history cho Agent
 # -------------------------------------------------------------------
-def rag_answer(query: str, history: Any):
+def _convert_history(history: Any):
     """
-    Generiert eine Antwort mit RAG:
-
-    1. Hole relevante Dokumente aus Supabase (Vektorsuche).
-    2. Baue einen kompakten Kontext-String mit Metadaten + Ausschnitten.
-    3. Erzeuge eine Chat-Completion mit SYSTEM_PROMPT + Nutzerfrage + Kontext.
-    4. Speichere User- und Assistant-Nachricht in chat_history.
+    Gradio history: list[{"role": "user"/"assistant", "content": str}, ...]
+    → list[HumanMessage/AIMessage] cho MessagesPlaceholder.
     """
+    msgs: List[Any] = []
+    if not isinstance(history, list):
+        return msgs
+
+    for h in history[-8:]:  # chỉ lấy ~8 lượt gần nhất
+        if not isinstance(h, dict):
+            continue
+        role = h.get("role")
+        content = h.get("content")
+        if not content:
+            continue
+        if role == "user":
+            msgs.append(HumanMessage(content=content))
+        elif role == "assistant":
+            msgs.append(AIMessage(content=content))
+    return msgs
 
-    # 1) Relevante Dokumente
-    docs = get_relevant_docs(query)
 
-    # 2) Kontext aus Dokumenten bauen (gekürzt, um "Context Noise" zu vermeiden)
-    context = ""
-    for i, d in enumerate(docs):
-        meta = d.get("metadata", {}) or {}
-        src = meta.get("source", "Unbekannte Quelle")
-        page = meta.get("page")
-
-        # Seitenangabe (falls vorhanden)
-        if isinstance(page, int):
-            page_info = f"(Seite {page})"
-        else:
-            page_info = ""
-
-        # Text-Ausschnitt
-        snippet = (d.get("content") or "").replace("\n", " ").strip()
-        short = snippet[:450]  # Kontext absichtlich begrenzen
-
-        context += f"[Quelle {i+1}] {src} {page_info}\n{short}\n\n"
-
-    # Optional: kurzen bisherigen Verlauf (für mehr Kontext), nur letzte 6 Einträge
-    history_text = ""
-    if isinstance(history, list):
-        for h in history[-6:]:
-            if isinstance(h, dict):
-                r = h.get("role")
-                c = h.get("content")
-                if r in ("user", "assistant") and c:
-                    history_text += f"{r}: {c}\n"
-
-    # 3) Messages für OpenAI
-    user_prompt = f"""
-Bisheriger Chatverlauf (kurz):
-
-{history_text}
-
-Aktuelle Frage des Nutzers:
-{query}
-
-Relevante Dokumentauszüge:
-{context}
+# -------------------------------------------------------------------
+# Hàm chính: Agent-Antwort + Dokumente für Quellen
+# -------------------------------------------------------------------
+def agent_answer(query: str, history: Any):
+    """
+    Dùng OpenAI Tools Agent để trả lời câu hỏi:
+    - Agent gọi tool 'suche_pruefungsrecht_dokumente' (Retriever) khi cần.
+    - Đồng thời, ta tự gọi retriever để lấy docs cho UI (Quellen).
+
+    Returns
+    -------
+    answer : str
+        Câu trả lời đã qua prompt engineering (không có link).
+    docs_info : list[dict]
+        Thông tin document cho phần Quellen trong UI.
+    """
+    chat_history_msgs = _convert_history(history)
 
-Bitte beantworte die aktuelle Frage ausschließlich auf Basis der Dokumentauszüge.
-"""
+    result = agent_executor.invoke(
+        {
+            "input": query,
+            "chat_history": chat_history_msgs,
+        }
+    )
 
-    messages = [
-        {"role": "system", "content": SYSTEM_PROMPT},
-        {"role": "user", "content": user_prompt},
-    ]
+    answer: str = result["output"]
 
-    res = client.chat.completions.create(
-        model="gpt-4o-mini",
-        messages=messages,
-        temperature=0.0,
-    )
+    # Safety-Hinweis, falls Agent selbst zugibt, dass Kontext nicht reicht
+    if "keine informationen vor" in answer.lower():
+        answer = (
+            "⚠️ **Hinweis:** Die Frage kann anhand des bereitgestellten "
+            "Dokumentenkontextes nur eingeschränkt beantwortet werden.\n\n"
+            + answer
+        )
 
-    answer = res.choices[0].message.content
+    # Dokumente separat für UI holen (gleiches Retriever wie Agent)
+    retrieved_docs = _retriever.get_relevant_documents(query)
+    docs_info: List[Dict[str, Any]] = []
+    for doc in retrieved_docs:
+        docs_info.append(
+            {
+                "content": doc.page_content,
+                "metadata": doc.metadata or {},
+                "score": 0.0,  # hier nicht benutzt, aber Feld gelassen
+            }
+        )
 
-    # 4) Verlauf in DB speichern
+    # Logging
     save_message("user", query)
     save_message("assistant", answer)
 
-    return answer, docs
+    return answer, docs_info
+
+
+# Alias kompatibel mit Version cũ
+def rag_answer(query: str, history: Any):
+    """Alias, để app.py có thể tiếp tục import rag_answer như trước."""
+    return agent_answer(query, history)

supabase_client.py

@@ -2,9 +2,13 @@
 import os
 from supabase import create_client
 
-# -------------------------------------------------------------------
-# Supabase Client (Service-Role, dùng cho đọc/ghi DB + Storage)
-# -------------------------------------------------------------------
+"""
+Supabase-Client (Service-Role) – dùng chung cho:
+- ingest.py (đọc Storage + ghi embeddings vào bảng documents)
+- rag_pipeline.py (tạo SupabaseVectorStore cho Agent)
+- app.py (PDF-Viewer)
+"""
+
 SUPABASE_URL = os.environ["SUPABASE_URL"]
 SUPABASE_SERVICE_ROLE = os.environ["SUPABASE_SERVICE_ROLE"]
 
@@ -13,18 +17,18 @@ supabase = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE)
 
 def load_file_bytes(bucket: str, filename: str) -> bytes:
     """
-    Tải file từ Supabase Storage mà KHÔNG ghi ra local – trả về bytes.
+    Tải file từ Supabase Storage (PDF, HTML, …) và trả về bytes.
 
     Parameters
     ----------
     bucket : str
         Tên bucket trong Supabase Storage.
     filename : str
-        Đường dẫn/tên file bên trong bucket.
+        Tên / đường dẫn file trong bucket.
 
     Returns
     -------
     bytes
-        Nội dung file ở dạng bytes.
+        Nội dung file.
     """
     return supabase.storage.from_(bucket).download(filename)