commit

app.py

@@ -2,16 +2,16 @@
 import os
 import re
 import base64
+import io
+import soundfile as sf
 
 import gradio as gr
 from openai import OpenAI
 
 from supabase_client import load_file_bytes
-from rag_pipeline import rag_answer  # agent_answer alias
+from rag_pipeline import rag_answer
+
 
-# -------------------------------------------------------------------
-# OpenAI client cho Whisper (Speech-to-Text)
-# -------------------------------------------------------------------
 client = OpenAI()
 
 BUCKET = os.environ["SUPABASE_BUCKET"]
@@ -21,183 +21,94 @@ PDF_URL = f"{SUPABASE_URL}/storage/v1/object/public/{BUCKET}/pruefungsordnung.pd
 HG_URL = "https://recht.nrw.de/lmi/owa/br_text_anzeigen?v_id=10000000000000000654"
 
 
-# -------------------------------------------------------------------
-# PDF Viewer (Base64 iframe)
-# -------------------------------------------------------------------
-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}"
-
-
-# -------------------------------------------------------------------
-# Speech-to-Text (Whisper) + cleaning
-# -------------------------------------------------------------------
-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{re.escape(f)}\b", "", t)
-    t = re.sub(r"[^a-zA-ZäöüÄÖÜß0-9,.? ]+", " ", t)
-    t = re.sub(r"\s+", " ", t).strip()
-    if len(t) > 1:
-        t = t[0].upper() + t[1:]
-    return t
-
-
-def transcribe(audio_path: str) -> str:
-    if audio_path is None:
+def encode_pdf_src():
+    b = load_file_bytes(BUCKET, "pruefungsordnung.pdf")
+    return f"data:application/pdf;base64,{base64.b64encode(b).decode()}"
+
+
+# Whisper cleanup
+def clean_text(t):
+    t = t.lower()
+    t = re.sub(r"[^\wäöüß ,.?-]+", " ", t)
+    return t.strip().capitalize()
+
+
+def transcribe(audio):
+    if audio is None:
         return ""
-    with open(audio_path, "rb") as f:
-        result = client.audio.transcriptions.create(
-            model="whisper-1",
-            file=f,
-            language="de",
-            temperature=0.0,
-        )
-    raw = (result.text or "").strip()
-    cleaned = clean_transcript(raw)
-    return cleaned if len(cleaned) >= 3 else ""
-
-
-# -------------------------------------------------------------------
-# Hàm CHAT chính – gọi Agent (rag_answer)
-# -------------------------------------------------------------------
+    audio_data, sr = audio
+    buf = io.BytesIO()
+    sf.write(buf, audio_data, sr, format="WAV")
+    buf.seek(0)
+
+    result = client.audio.transcriptions.create(
+        model="whisper-1", file=buf, filename="audio.wav", language="de"
+    )
+    return clean_text(result.text or "")
+
+
 def chat_fn(mode, text, audio, history):
     history = history or []
 
-    # 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()
-    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,
-            )
+        q = text.strip()
+    else:
+        q = transcribe(audio)
 
-    # 2) Gọi Agent (RAG + Tools)
-    answer, docs = rag_answer(question, history)
+    if not q:
+        return history, "Keine gültige Eingabe erkannt.", None
 
-    # 3) Xây block Quellen (UI-friendly)
-    quellen_md_lines = ["", "### 📚 Verwendete Quellen"]
+    answer, docs = rag_answer(q, history)
 
+    quellen = ["", "### 📚 Verwendete Quellen"]
     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
+        src = d["source"]
+        pg = d["page"]
+
+        if src.startswith("Prüfungsordnung"):
+            url = f"{PDF_URL}#page={pg}"
         else:
             url = HG_URL
-            title = f"Quelle {i+1}: Hochschulgesetz NRW"
 
-        snippet = (d.get("content") or "").strip().replace("\n", " ")
-        snippet = snippet[:200] + ("…" if len(snippet) > 200 else "")
+        snippet = d["snippet"][:200]
+        quellen.append(f"- **{src}** (Seite {pg}) → [{url}]({url})  \n  „{snippet}…”")
 
-        quellen_md_lines.append(
-            f"- [{title}]({url})\n"
-            f"  - **Ausschnitt:** „{snippet}“"
-        )
+    bot = answer + "\n\n" + "\n".join(quellen)
 
-    quellen_md = "\n".join(quellen_md_lines)
+    return history + [
+        {"role": "user", "content": q},
+        {"role": "assistant", "content": bot},
+    ], bot, gr.update(value=None)
 
-    bot_msg = answer + "\n\n" + quellen_md
 
-    new_history = history + [
-        {"role": "user", "content": question},
-        {"role": "assistant", "content": bot_msg},
-    ]
-
-    return new_history, bot_msg, gr.update(value=None)
-
-
-# -------------------------------------------------------------------
-# Giao diện Gradio – UI thân thiện
-# -------------------------------------------------------------------
 with gr.Blocks() as demo:
-    gr.Markdown(
-        """
-# ⚖️ Prüfungsrechts-Assistent (NRW)
-
-Willkommen!  
-Ich beantworte Ihre Fragen auf Basis der **offiziellen Dokumente**:
-
-- 📘 *Prüfungsordnung Ihrer Hochschule*  
-- 📗 *Hochschulgesetz NRW (recht.nrw.de)*  
-
-Wählen Sie unten: **Text** oder **Sprache**.
-"""
-    )
+    gr.Markdown("# ⚖️ Prüfungsrechts-Assistent NRW")
 
     with gr.Row():
-        # LEFT: Chat
         with gr.Column(scale=3):
-            chatbot = gr.Chatbot(label="Chatverlauf")
+            chatbot = gr.Chatbot()
 
-            mode_select = gr.Radio(
-                ["text", "audio"],
-                value="text",
-                label="Eingabemodus",
-                info="Wähle zwischen Text oder Sprache",
-            )
+            mode = gr.Radio(["text", "audio"], value="text", label="Eingabemodus")
+            text = gr.Textbox(label="Text eingeben")
 
-            text_input = gr.Textbox(label="Text eingeben")
-            audio_input = gr.Audio(
-                type="filepath", label="Spracheingabe (Mikrofon)"
+            audio = gr.Audio(
+                sources=["microphone"],
+                type="numpy",
+                format="wav",
+                label="Spracheingabe (Mikrofon)",
             )
 
-            send_btn = gr.Button("Senden")
-            answer_preview = gr.Markdown("")
+            send = gr.Button("Senden")
+            preview = gr.Markdown()
 
-        # 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>"
-            )
+            gr.HTML(f"<iframe src='{encode_pdf_src()}' width='100%' height='260'></iframe>")
 
-            gr.Markdown("### 📘 Hochschulgesetz NRW (offizielle Seite)")
-            gr.HTML(
-                f"<iframe src='{HG_URL}' width='100%' height='250' style='border:none;'></iframe>"
-            )
+            gr.Markdown("### 📘 Hochschulgesetz NRW")
+            gr.HTML(f"<iframe src='{HG_URL}' width='100%' height='260'></iframe>")
 
-    send_btn.click(
-        chat_fn,
-        inputs=[mode_select, text_input, audio_input, chatbot],
-        outputs=[chatbot, answer_preview, audio_input],
-    )
+    send.click(chat_fn, [mode, text, audio, chatbot], [chatbot, preview, audio])
 
 if __name__ == "__main__":
-    demo.queue().launch(ssr_mode=False)
+    demo.queue().launch()

ingest.py

@@ -1,53 +1,37 @@
 # ingest.py
 import os
 from io import BytesIO
-
 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
-# -------------------------------------------------------------------
 BUCKET = os.environ["SUPABASE_BUCKET"]
 SUPABASE_URL = os.environ["SUPABASE_URL"]
 
 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"
-
 OFFICIAL_HG_URL = (
     "https://recht.nrw.de/lmi/owa/br_text_anzeigen?v_id=10000000000000000654"
 )
 
 
-# -------------------------------------------------------------------
-# Loader PDF Prüfungsordnung
-# -------------------------------------------------------------------
+# ---------------- Loaders ----------------
 def load_pdf_docs():
-    """
-    Đọ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))
 
     docs = []
-    for i, page in enumerate(reader.pages):
-        text = page.extract_text() or ""
-        page_num = i + 1
-
+    for i, p in enumerate(reader.pages):
+        text = p.extract_text() or ""
         docs.append(
             Document(
                 page_content=text,
                 metadata={
                     "source": "Prüfungsordnung (PDF)",
-                    "page": page_num,
+                    "page": i + 1,
                     "pdf_url": PDF_URL,
                 },
             )
@@ -55,103 +39,55 @@ def load_pdf_docs():
     return docs
 
 
-# -------------------------------------------------------------------
-# Loader HTML Hochschulgesetz
-# -------------------------------------------------------------------
 def load_html_docs():
-    """
-    Đọ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")
-
-    soup = BeautifulSoup(html, "html.parser")
-    text = soup.get_text(separator="\n")
+    soup = BeautifulSoup(html_bytes.decode("utf-8", "ignore"), "html.parser")
 
     return [
         Document(
-            page_content=text,
-            metadata={
-                "source": "Hochschulgesetz NRW",
-                "official_url": OFFICIAL_HG_URL,
-            },
+            page_content=soup.get_text("\n"),
+            metadata={"source": "Hochschulgesetz NRW", "url": OFFICIAL_HG_URL},
         )
     ]
 
 
-# -------------------------------------------------------------------
-# Chunking – RecursiveCharacterTextSplitter
-# -------------------------------------------------------------------
 def chunk_docs(docs):
-    splitter = RecursiveCharacterTextSplitter(
-        chunk_size=900,
-        chunk_overlap=100,
-    )
+    splitter = RecursiveCharacterTextSplitter(chunk_size=900, chunk_overlap=80)
     return splitter.split_documents(docs)
 
 
-# -------------------------------------------------------------------
-# 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' ...")
+# ---------------- Delete old data ----------------
+def delete_old_documents():
+    print("🗑️ Lösche alte Daten…")
     supabase.table("documents").delete().gte(
         "id", "00000000-0000-0000-0000-000000000000"
     ).execute()
-    print("✔ Alte Daten in 'documents' gelöscht.")
 
 
-# -------------------------------------------------------------------
-# Ingest chính
-# -------------------------------------------------------------------
+# ---------------- Ingest ----------------
 def ingest():
-    print("🚀 Starte Ingest (PDF + Hochschulgesetz) ...")
+    delete_old_documents()
 
-    # 1) Xoá data cũ
-    delete_old_data()
-
-    # 2) Load nguồn
     pdf_docs = load_pdf_docs()
-    hg_docs = load_html_docs()
+    html_docs = load_html_docs()
 
-    # 3) Chunk
-    chunks = chunk_docs(pdf_docs + hg_docs)
+    chunks = chunk_docs(pdf_docs + html_docs)
 
-    # 4) Gắn anchor_id & URL meta
-    po_idx = 1
-    hg_idx = 1
-    for d in chunks:
-        src = d.metadata.get("source")
+    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
 
-        if src == "Prüfungsordnung (PDF)":
-            d.metadata["anchor_id"] = f"po_{po_idx}"
-            po_idx += 1
-        else:
-            d.metadata["anchor_id"] = f"hg_{hg_idx}"
-            hg_idx += 1
-            d.metadata["url"] = OFFICIAL_HG_URL
+    print("📥 Speichere neue Dokumente…")
+    for d in chunks:
+        emb = embeddings.embed_query(d.page_content)
 
-    # 5) Embeddings + SupabaseVectorStore
-    embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
+        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("🎉 Ingest fertig – 'documents' ist frisch aufgebaut.")
+    print("✅ Ingest abgeschlossen!")
 
 
 if __name__ == "__main__":

rag_pipeline.py

@@ -1,110 +1,72 @@
 # rag_pipeline.py
-from typing import Any, List, Dict
+from typing import Any
 from datetime import date
 
-from supabase_client import supabase
+from supabase_client import supabase, match_documents
 
 from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-from langchain_community.vectorstores import SupabaseVectorStore
 from langchain_core.messages import (
+    SystemMessage,
     HumanMessage,
     AIMessage,
-    SystemMessage,
 )
 
-# ================================================================
-# INITIALIZATION
-# ================================================================
-_embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
+emb = OpenAIEmbeddings(model="text-embedding-3-small")
+llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.0)
 
-_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 (LEGAL GUARDRAILS)
-# ================================================================
 SYSTEM_PROMPT = """
 Du bist ein hochpräziser juristischer Assistent für Prüfungsrecht in NRW.
-
-DEINE REGELN:
-1) Nutze AUSSCHLIESSLICH Inhalte aus den Dokumenten, die über das Tool
-   'suche_pruefungsrecht_dokumente' geliefert werden.
-2) Keine Spekulation – wenn im Kontext nicht vorhanden, antworte:
-   „Dazu liegen im bereitgestellten Dokumentenkontext keine Informationen vor.“
-3) Antworte strukturiert:
-   (a) Einordnung
-   (b) Rechtsgrundlage (sinngemäß)
-   (c) Bedingungen / Ausnahmen
-   (d) Konsequenz für Studierende
-4) Keine eigenen Quellenlinks – nur Sachverhalt erklären.
+- Nutze AUSSCHLIESSLICH Dokumente, die über das Tool geliefert werden.
+- Keine Spekulation.
+- Antwort strukturiert + verständlich.
 """
 
-# ================================================================
-# DEFINE TOOL (OPENAI FUNCTION-CALLING)
-# ================================================================
-def tool_suche_dokumente(query: str) -> Dict:
-    """
-    Tool thực hiện RAG retrieval.
-    Trả về list các docs + metadata.
-    """
-    docs = _retriever.invoke(query)
-
-    out_docs = []
+
+# ---------------- TOOL: Suche Dokumente ----------------
+def tool_suche_dokumente(query: str):
+    vec = emb.embed_query(query)
+    docs = match_documents(vec, k=4)
+
+    results = []
     for i, d in enumerate(docs):
-        meta = d.metadata or {}
-        snippet = d.page_content.replace("\n", " ").strip()
-        snippet = snippet[:500]
+        meta = d["metadata"] or {}
+        snippet = d["content"].replace("\n", " ")[:400]
 
-        out_docs.append(
+        results.append(
             {
                 "index": i + 1,
-                "source": meta.get("source", "?"),
+                "source": meta.get("source"),
                 "page": meta.get("page"),
                 "snippet": snippet,
+                "content": d["content"],
                 "metadata": meta,
-                "content": d.page_content,
             }
         )
 
-    return {"results": out_docs}
+    return {"results": results}
 
 
-# OpenAI tools definition
 TOOLS = [
     {
         "type": "function",
         "function": {
             "name": "suche_pruefungsrecht_dokumente",
-            "description": "Sucht relevante Stellen in Prüfungsordnung und Hochschulgesetz NRW.",
+            "description": "Sucht relevante Stellen im Prüfungsrecht.",
             "parameters": {
                 "type": "object",
-                "properties": {
-                    "query": {"type": "string"}
-                },
+                "properties": {"query": {"type": "string"}},
                 "required": ["query"],
             },
         },
     }
 ]
 
-# Bind tools to LLM
-llm_with_tools = _llm.bind_tools(TOOLS)
+llm_tools = llm.bind_tools(TOOLS)
 
-# ================================================================
-# HISTORY LOGGING (optional)
-# ================================================================
-def save_message(role: str, content: str) -> None:
+
+# ---------------- HISTORY LOG ----------------
+def save_message(role: str, content: str):
     supabase.table("chat_history").insert(
         {
             "session_date": date.today().isoformat(),
@@ -113,91 +75,57 @@ def save_message(role: str, content: str) -> None:
         }
     ).execute()
 
-# ================================================================
-# CONVERT HISTORY
-# ================================================================
-def _convert_history(history):
+
+def convert_history(hist):
     msgs = []
-    if not isinstance(history, list):
-        return msgs
-
-    for h in history[-8:]:
-        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))
+    for h in hist[-6:]:
+        if h["role"] == "user":
+            msgs.append(HumanMessage(content=h["content"]))
+        else:
+            msgs.append(AIMessage(content=h["content"]))
     return msgs
 
 
-# ================================================================
-# MAIN — AGENT ANSWER
-# ================================================================
+# ---------------- AGENT ANSWER ----------------
 def agent_answer(query: str, history: Any):
-    """
-    1. Gửi prompt + query vào model.
-    2. Nếu model đòi gọi tool → thực thi tool → lấy kết quả → gửi lại vào LLM.
-    3. Trích nguồn để UI hiển thị trong phần Quellen.
-    """
-
-    chat_history_msgs = _convert_history(history)
-
-    # -------- 1) Gửi câu hỏi lần đầu ----------
     messages = [
         SystemMessage(content=SYSTEM_PROMPT),
-        *chat_history_msgs,
+        *convert_history(history),
         HumanMessage(content=query),
     ]
 
-    first_response = llm_with_tools.invoke(messages)
-
-    # Nếu model muốn call tool
-    if first_response.tool_calls:
-        tc = first_response.tool_calls[0]
-        if tc["name"] == "suche_pruefungsrecht_dokumente":
-            tool_result = tool_suche_dokumente(tc["args"]["query"])
-
-            # Gửi tool result vào LLM để trả lời cuối cùng
-            messages.append(first_response)
-            messages.append(
-                AIMessage(
-                    content=str(tool_result),
-                    name="suche_pruefungsrecht_dokumente"
-                )
+    first = llm_tools.invoke(messages)
+
+    if first.tool_calls:
+        call = first.tool_calls[0]
+        if call["name"] == "suche_pruefungsrecht_dokumente":
+            tool_res = tool_suche_dokumente(call["args"]["query"])
+
+            messages.extend(
+                [
+                    first,
+                    AIMessage(
+                        content=str(tool_res),
+                        name="suche_pruefungsrecht_dokumente",
+                    ),
+                ]
             )
 
-            final_response = _llm.invoke(messages)
-            answer = final_response.content
-
-            # CREATE docs_info FOR UI
-            docs_info = tool_result["results"]
-
+            final = llm.invoke(messages)
+            answer = final.content
+            docs = tool_res["results"]
         else:
             answer = "Tool nicht unterstützt."
-            docs_info = []
-
+            docs = []
     else:
-        answer = first_response.content
-        docs_info = []
-
-    # Safety Hinweis
-    if "keine informationen" in answer.lower():
-        answer = (
-            "⚠️ **Hinweis:** Die Frage kann anhand des bereitgestellten Dokumentenkontextes "
-            "nur eingeschränkt beantwortet werden.\n\n"
-            + answer
-        )
+        answer = first.content
+        docs = []
 
     save_message("user", query)
     save_message("assistant", answer)
 
-    return answer, docs_info
+    return answer, docs
 
 
-# Alias để app.py dùng như cũ
 def rag_answer(query: str, history: Any):
     return agent_answer(query, history)

supabase_client.py

@@ -2,13 +2,6 @@
 import os
 from supabase import create_client
 
-"""
-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"]
 
@@ -16,19 +9,17 @@ supabase = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE)
 
 
 def load_file_bytes(bucket: str, filename: str) -> bytes:
-    """
-    Tải file từ Supabase Storage (PDF, HTML, …) và trả về bytes.
+    return supabase.storage.from_(bucket).download(filename)
 
-    Parameters
-    ----------
-    bucket : str
-        Tên bucket trong Supabase Storage.
-    filename : str
-        Tên / đường dẫn file trong bucket.
 
-    Returns
-    -------
-    bytes
-        Nội dung file.
+def match_documents(embedding: list, k: int = 4):
     """
-    return supabase.storage.from_(bucket).download(filename)
+    Gọi trực tiếp RPC match_documents trong Supabase.
+    Trả về list các rows: {content, metadata, embedding?}
+    """
+    resp = supabase.rpc(
+        "match_documents",
+        {"query_embedding": embedding, "match_count": k}
+    ).execute()
+
+    return resp.data or []