commit

app.py

@@ -1,131 +1,69 @@
 # app.py
+import gradio as gr
+from openai import OpenAI
 import os
-from typing import List, 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 ChatOpenAI, OpenAIEmbeddings
-
-from load_documents import load_documents
-from speech_io import transcribe_audio, synthesize_speech
-
-
-# ========== 1. Lade Dokumente ==========
-print("🔹 Lade Dokumente aus Supabase …")
-docs: List[Document] = load_documents()
-print("✔ DOCUMENTS LOADED:", len(docs))
-
-print("🔹 Splitte Dokumente …")
-text_splitter = RecursiveCharacterTextSplitter(
-    chunk_size=800,
-    chunk_overlap=200,
-)
-chunks = text_splitter.split_documents(docs)
-print(f"   - {len(chunks)} Chunks erzeugt.")
-
-print("🔹 Erzeuge VectorStore …")
-embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
-vectorstore = FAISS.from_documents(chunks, embeddings)
-retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
-print(">>> Retriever ready.")
-
-print("🔹 Lade OpenAI LLM …")
-llm = ChatOpenAI(
-    model="gpt-4o-mini",
-    temperature=0.1,
-)
-
-
-# ========== 2. RAG ==========
-def build_context(docs: List[Document]) -> str:
-    parts = []
-    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(query: str, mode: str):
-    retrieved = retriever.invoke(query)
-    ctx = build_context(retrieved)
-
-    modes = {
-        "Kurz": "Antworte sehr kurz (max. 3 Sätze).",
-        "Standard": "Antworte ausführlich und verständlich.",
-        "Juristisch Präzise": "Formuliere juristisch präzise.",
-    }
-
-    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]}"
-        }
-    ]
-
-    resp = llm.invoke(messages)
-    return resp.content, retrieved
-
-
-# ========== 3. Chatbot Funktionen (GRADIO 4.x – TUPLES) ==========
-def chatbot_text(user_input: str, history: List[Tuple[str, str]], mode: str):
-    answer, _ = rag_answer(user_input, mode)
-    history = history + [(user_input, answer)]
-    return history, history
-
-
-def chatbot_voice(audio_file: str, history: List[Tuple[str, str]], mode: str, language_hint: str):
-    user_text = transcribe_audio(audio_file, language_hint or None)
-    answer, _ = rag_answer(user_text, mode)
-    audio_out = synthesize_speech(answer)
-
-    history = history + [(user_text, answer)]
-    return history, audio_out, user_text, history
-
-
-# ========== 4. UI ==========
-with gr.Blocks(title="Prüfungsrechts-Chatbot") as demo:
-
-    with gr.Tab("💬 Text-Chat"):
-        mode = gr.Radio(["Kurz", "Standard", "Juristisch Präzise"], value="Standard")
-        chat = gr.Chatbot()
-        state = gr.State([])
-        inp = gr.Textbox(label="Frage eingeben")
-        send = gr.Button("Senden")
-
-        send.click(chatbot_text, [inp, state, mode], [chat, state])
-
-    with gr.Tab("🎙️ Sprach-Chat"):
-        mode_v = gr.Radio(["Kurz", "Standard", "Juristisch Präzise"], value="Standard")
-        chat_v = gr.Chatbot()
-        state_v = gr.State([])
-
-        mic = gr.Audio(sources=["microphone"], type="filepath")
-        lang = gr.Textbox(label="Sprache (optional: de/en/vi)")
-        out_audio = gr.Audio()
-        transcript = gr.Textbox(label="Transkript")
-
-        btn = gr.Button("Sprechen")
-        btn.click(
-            chatbot_voice,
-            [mic, state_v, mode_v, lang],
-            [chat_v, out_audio, transcript, state_v]
-        )
+from rag_pipeline import rag_answer
+
+client = OpenAI()
 
-if __name__ == "__main__":
-    demo.launch()
+PDF_URL = os.environ["PDF_URL"]
+HG_URL = os.environ["HG_URL"]
+
+def transcribe(audio_path):
+    if audio_path is None:
+        return ""
+
+    with open(audio_path, "rb") as f:
+        result = client.audio.transcriptions.create(
+            model="whisper-1",
+            file=f,
+        )
+    return result.text
+
+def chat_fn(text, audio, history):
+    # Microphone input → text
+    spoken_text = transcribe(audio)
+
+    if text and spoken_text:
+        question = f"{text}\n(Gesprochen: {spoken_text})"
+    elif spoken_text:
+        question = spoken_text
+    else:
+        question = text or ""
+
+    if not question:
+        return history, "<p>Bitte Text oder Mikrofon benutzen.</p>"
+
+    answer, docs = rag_answer(question, history or [])
+
+    # Prepare sources
+    html = "<ol>"
+    for i, d in enumerate(docs):
+        src = d.metadata.get("source", "?")
+        page = d.metadata.get("page", "")
+        url = PDF_URL if "Prüfungsordnung" in src else HG_URL
+        html += f"<li><a target='_blank' href='{url}'>{src} {page}</a><br>{d.page_content[:200]}...</li>"
+    html += "</ol>"
+
+    history.append((question, answer))
+    return history, html
+
+with gr.Blocks() as demo:
+    gr.Markdown("# ⚖️ Sprachbasierter Chatbot für Prüfungsrecht")
+
+    with gr.Row():
+        with gr.Column(scale=3):
+            chat = gr.Chatbot()
+            text = gr.Textbox(label="Text Eingabe")
+            audio = gr.Audio(source="microphone", type="filepath")
+            send = gr.Button("Senden")
+
+        with gr.Column(scale=2):
+            gr.HTML(f"<iframe src='{PDF_URL}' width='100%' height='250'></iframe>")
+            gr.HTML(f"<iframe src='{HG_URL}' width='100%' height='250'></iframe>")
+            sources = gr.HTML()
+
+    send.click(chat_fn, inputs=[text, audio, chat], outputs=[chat, sources])
+
+demo.launch()

chat_history.py

@@ -1,70 +0,0 @@
-# chat_history.py – Supabase chat history (messages-format für Gradio)
-
-import uuid
-import os
-from supabase import create_client
-
-SUPABASE_URL = os.environ["SUPABASE_URL"]
-SUPABASE_SERVICE_ROLE = os.environ["SUPABASE_SERVICE_ROLE"]
-
-supabase = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE)
-
-
-# ------------------------------------------------------
-# Session anlegen
-# ------------------------------------------------------
-
-def create_session() -> str:
-    session_id = str(uuid.uuid4())
-
-    supabase.table("chat_sessions").insert({
-        "id": session_id
-    }).execute()
-
-    return session_id
-
-
-# ------------------------------------------------------
-# Message speichern
-# ------------------------------------------------------
-
-def save_message(session_id: str, role: str, content: str):
-    if not session_id or session_id == "None":
-        print("⚠ WARN: invalid session_id, skip save_message")
-        return
-
-    supabase.table("chat_messages").insert({
-        "session_id": session_id,
-        "role": role,
-        "content": content,
-    }).execute()
-
-
-# ------------------------------------------------------
-# History laden – Format: [{role: ..., content: ...}, ...]
-# ------------------------------------------------------
-
-def load_history(session_id: str):
-    if not session_id or session_id == "None":
-        return []
-
-    res = (
-        supabase.table("chat_messages")
-        .select("*")
-        .eq("session_id", session_id)
-        .order("created_at")
-        .execute()
-    )
-
-    rows = res.data or []
-
-    history = []
-    for r in rows:
-        history.append(
-            {
-                "role": r["role"],
-                "content": r["content"],
-            }
-        )
-
-    return history

embeddings.py

@@ -1,24 +0,0 @@
-# embeddings.py – OpenAI Version (text-embedding-3-small)
-
-import os
-from langchain_openai import OpenAIEmbeddings
-
-EMBED_MODEL = "text-embedding-3-small"
-
-def get_embeddings():
-    api_key = os.environ.get("OPENAI_API_KEY")
-    if not api_key:
-        raise RuntimeError(
-            "OPENAI_API_KEY fehlt. Bitte als Secret im HuggingFace Space setzen."
-        )
-
-    print(f">>> Lade OpenAI Embedding Model: {EMBED_MODEL}")
-    emb = OpenAIEmbeddings(
-        model=EMBED_MODEL,
-        api_key=api_key,
-    )
-    return emb
-
-if __name__ == "__main__":
-    e = get_embeddings()
-    print(e.embed_query("Test"))

hg_nrw_supabase.py

@@ -1,99 +0,0 @@
-"""
-hg_nrw_supabase.py
-
-Lädt das Hochschulgesetz NRW von recht.nrw.de,
-extrahiert alle Paragraphen (§ …) und schreibt sie in
-die Supabase-Tabelle public.hg_nrw.
-
-Erwartete Spalten in hg_nrw:
-- abs_id      text   (z.B. 'para_64')
-- title       text   (z.B. '§ 64 Prüfungsordnungen')
-- content     text   (Volltext)
-- order_index int4   (Sortierreihenfolge)
-- source_url  text   (immer die Original-URL von recht.nrw.de)
-"""
-
-import os
-import requests
-from bs4 import BeautifulSoup
-from supabase import create_client
-from dotenv import load_dotenv
-
-load_dotenv()
-
-SUPABASE_URL = os.environ["SUPABASE_URL"]
-SUPABASE_SERVICE_ROLE = os.environ["SUPABASE_SERVICE_ROLE"]
-
-supabase = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE)
-
-# Nur DIESE URL, keine Druckversion:
-LAW_URL = "https://recht.nrw.de/lmi/owa/br_text_anzeigen?v_id=10000000000000000654"
-
-
-def extract_paragraphs():
-    print(">>> Lade Hochschulgesetz NRW von recht.nrw.de …")
-
-    html = requests.get(LAW_URL, timeout=30).text
-    soup = BeautifulSoup(html, "html.parser")
-
-    # Alle Überschriften <h2>/<h3>, viele davon sind §§
-    headers = soup.find_all(["h2", "h3"])
-
-    paragraphs = []
-    order = 1
-
-    for header in headers:
-        title = header.get_text(" ", strip=True)
-
-        # Nur Überschriften, die mit "§" anfangen
-        if not title.startswith("§"):
-            continue
-
-        # Inhalte ab dieser Überschrift bis vor die nächste h2/h3
-        content_parts = []
-        sibling = header.find_next_sibling()
-
-        while sibling and sibling.name not in ["h2", "h3"]:
-            text = sibling.get_text(" ", strip=True)
-            if text:
-                content_parts.append(text)
-            sibling = sibling.find_next_sibling()
-
-        full_content = "\n".join(content_parts).strip()
-        abs_id = f"para_{order}"
-
-        paragraphs.append(
-            {
-                "abs_id": abs_id,
-                "title": title,
-                "content": full_content,
-                "order_index": order,
-                # dùng trực tiếp web link gốc, không thêm anchor
-                "source_url": LAW_URL,
-            }
-        )
-
-        order += 1
-
-    print(f"✔ Extracted {len(paragraphs)} paragraphs (§).")
-    return paragraphs
-
-
-def upload_to_supabase():
-    paras = extract_paragraphs()
-
-    print(">>> Clear table hg_nrw …")
-    supabase.table("hg_nrw").delete().neq("abs_id", "").execute()
-
-    print(">>> Upload begin …")
-    BATCH = 100
-    for i in range(0, len(paras), BATCH):
-        batch = paras[i : i + BATCH]
-        print(f"   - Upload batch {i} – {i + len(batch) - 1}")
-        supabase.table("hg_nrw").upsert(batch).execute()
-
-    print("✔ DONE uploading complete NRW law.")
-
-
-if __name__ == "__main__":
-    upload_to_supabase()

ingest.py

@@ -0,0 +1,73 @@
+# 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_community.vectorstores import SupabaseVectorStore
+from langchain_core.documents import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+BUCKET = os.environ["SUPABASE_BUCKET"]
+
+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},
+            )
+        )
+    return docs
+
+def load_html_docs():
+    html_bytes = load_file_bytes(BUCKET, "hochschulgesetz.html")
+    html_str = html_bytes.decode("utf-8", errors="ignore")
+    soup = BeautifulSoup(html_str, "html.parser")
+    text = soup.get_text(separator="\n")
+
+    return [
+        Document(
+            page_content=text,
+            metadata={"source": "Hochschulgesetz NRW"},
+        )
+    ]
+
+def chunk_docs(docs):
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1000, 
+        chunk_overlap=150
+    )
+    return splitter.split_documents(docs)
+
+def main():
+    pdf_docs = load_pdf_docs()
+    html_docs = load_html_docs()
+    all_docs = pdf_docs + html_docs
+
+    chunks = chunk_docs(all_docs)
+
+    embeddings = OpenAIEmbeddings(
+        model="text-embedding-3-small"
+    )
+
+    SupabaseVectorStore.from_documents(
+        chunks,
+        embeddings,
+        client=supabase,
+        table_name="documents",
+        query_name="match_documents",
+        chunk_size=200,
+    )
+
+    print("Ingest OK (no local files).")
+
+if __name__ == "__main__":
+    main()

llm.py

@@ -1,27 +0,0 @@
-# llm.py – OpenAI Chatmodell für RAG
-
-import os
-from langchain_openai import ChatOpenAI
-
-CHAT_MODEL = "gpt-4o-mini"  # günstig & stark
-
-def load_llm():
-    api_key = os.environ.get("OPENAI_API_KEY")
-    if not api_key:
-        raise RuntimeError(
-            "OPENAI_API_KEY fehlt. Bitte als Secret im HuggingFace Space setzen."
-        )
-
-    print(f">>> Lade OpenAI Chatmodell: {CHAT_MODEL}")
-
-    llm = ChatOpenAI(
-        model=CHAT_MODEL,
-        temperature=0.0,   # deterministisch, wenig Halluzination
-        api_key=api_key,
-    )
-    return llm
-
-if __name__ == "__main__":
-    llm = load_llm()
-    print(llm.invoke("Sag einen Satz zum Prüfungsrecht.").content)
-

load_documents.py

@@ -1,104 +0,0 @@
-# load_documents.py
-
-import os
-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
-
-load_dotenv()
-
-
-# ============== 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.")
-
-    return create_client(url, key)
-
-
-# ============== HG NRW Paragraphen ==============
-def load_hg_paragraphs(supabase: Client) -> List[Document]:
-    print(">>> Lade Hochschulgesetz NRW (§) aus Supabase…")
-
-    table = os.getenv("HG_TABLE_NAME", "hg_nrw")
-    rows = supabase.table(table).select("*").order("order_index").execute().data or []
-
-    docs = []
-    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
-
-
-# ============== Prüfungsordnung PDF ==============
-def load_pruefungsordnung_from_storage(supabase: Client) -> List[Document]:
-    bucket = os.getenv("PRUEF_BUCKET")
-    pdf_path = os.getenv("PRUEF_PDF_PATH")
-
-    if not bucket or not pdf_path:
-        print(">>> Keine Prüfungsordnung-PDF definiert.")
-        return []
-
-    print(">>> Lade Prüfungsordnung PDF …")
-
-    try:
-        data = supabase.storage.from_(bucket).download(pdf_path)
-    except Exception as e:
-        print("   Fehler beim PDF Download:", e)
-        return []
-
-    reader = PdfReader(BytesIO(data))
-    docs = []
-
-    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
-
-
-# ============== Main Loader ==============
-def load_documents() -> List[Document]:
-    supabase = get_supabase_client()
-    docs = []
-
-    docs += load_hg_paragraphs(supabase)
-    docs += load_pruefungsordnung_from_storage(supabase)
-
-    print(f"✔ DOCUMENTS LOADED: {len(docs)}")
-    return docs

rag_pipeline.py

@@ -1,100 +1,66 @@
-# rag_pipeline.py – OpenAI RAG mit Supabase-Dokumenten
-
-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.get("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.get("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 = []
+# rag_pipeline.py
+import os
+from datetime import date
+from supabase_client import supabase
+
+from langchain_community.vectorstores import SupabaseVectorStore
+from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+
+def get_vectorstore():
+    embeddings = OpenAIEmbeddings(
+        model="text-embedding-3-small"
+    )
+    return SupabaseVectorStore(
+        embedding=embeddings,
+        client=supabase,
+        table_name="documents",
+        query_name="match_documents",
+    )
+
+def save_message(role, message):
+    supabase.table("chat_history").insert({
+        "session_date": date.today().isoformat(),
+        "role": role,
+        "message": message
+    }).execute()
+
+def rag_answer(question, history):
+    retriever = get_vectorstore().as_retriever(search_kwargs={"k": 4})
+    docs = retriever.get_relevant_documents(question)
+
+    # Build context
+    context = ""
     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.append(f"[KONTEXT {i+1}] ({src_str})\n{txt}")
-
-    return "\n\n".join(out)
-
-
-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.
-
-Regeln:
-1. Antworte nur auf Basis des gelieferten Kontextes.
-2. Wenn der Kontext keine sichere Antwort erlaubt, sage das klar.
-3. Antworte in verständlichem, korrektem Deutsch.
-4. Nenne Paragraphen, Dokumente und Seitenzahlen (bei PDF), wo möglich.
-"""
-
-
-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 basierend
-auf diesem Kontext. Falls der Kontext unzureichend ist, sage das klar.
-"""
-
-    msgs = [
-        SystemMessage(content=SYSTEM_PROMPT),
-        HumanMessage(content=human),
+        src = d.metadata.get("source", "?")
+        pg = d.metadata.get("page", "")
+        pg = f"(Seite {pg})" if pg else ""
+        context += f"[Quelle {i+1}] {src} {pg}\n{d.page_content}\n\n"
+
+    # Build history text
+    hist = ""
+    for u, b in history:
+        hist += f"User: {u}\nAssistant: {b}\n"
+
+    system_prompt = (
+        "Du bist ein Sprachbasierter Chatbot für Prüfungsrecht. "
+        "Nutze NUR die bereitgestellten Dokumente."
+        "Zitiere immer [Quelle X]."
+    )
+
+    llm = ChatOpenAI(model="gpt-4.1-mini", temperature=0.1)
+
+    msg = [
+        ("system", system_prompt),
+        ("user",
+            f"Frage: {question}\n\n"
+            f"Vorheriger Chatverlauf:\n{hist}\n\n"
+            f"Dokumente:\n{context}"
+        ),
     ]
 
-    result = chat_model.invoke(msgs)
-    answer_text = result.content.strip()
+    answer = llm.invoke(msg).content
+
+    save_message("user", question)
+    save_message("assistant", answer)
 
-    sources = build_sources_metadata(docs)
-    return answer_text, sources
+    return answer, docs

requirements.txt

@@ -1,21 +1,9 @@
-# === UI ===
-gradio
-gradio_pdf
-
-# === Core RAG + LangChain ===
 langchain
 langchain-community
-langchain-text-splitters
 langchain-openai
-
-# === OpenAI SDK (LLM, Embeddings, Audio) ===
-openai>=1.35.0
-
-# === VectorStore ===
-faiss-cpu
-
-# === Supabase + Dokumente laden ===
+openai
 supabase
+gradio
 pypdf
-requests
+beautifulsoup4
 python-dotenv

retriever.py

@@ -1,48 +0,0 @@
-"""
-BƯỚC 5: RETRIEVER
------------------
-Tạo LangChain Retriever từ FAISS VectorStore.
-
-Retriever sẽ dùng trong bước RAG sau này:
-- retriever.get_relevant_documents(query)
-"""
-
-from langchain_community.vectorstores import FAISS
-
-# số chunk sẽ lấy cho mỗi câu hỏi
-RETRIEVER_K = 4
-
-def get_retriever(vectorstore: FAISS, k: int = RETRIEVER_K):
-    """
-    Tạo retriever từ FAISS VectorStore.
-    """
-    print(f">>> Creating retriever with k={k} ...")
-    retriever = vectorstore.as_retriever(search_kwargs={"k": k})
-    print(">>> Retriever ready.\n")
-    return retriever
-
-if __name__ == "__main__":
-    # Test: load -> split -> FAISS -> retriever.get_relevant_documents()
-    from load_documents import load_documents
-    from split_documents import split_documents
-    from vectorstore import build_vectorstore
-
-    print("=== TEST: retriever.get_relevant_documents ===\n")
-
-    docs = load_documents()
-    chunks = split_documents(docs)
-    vs = build_vectorstore(chunks)
-    retriever = get_retriever(vs, k=4)
-
-    query = "Wie lange habe ich Zeit, eine Prüfungsleistung zu wiederholen?"
-    print("Test query:")
-    print(" ", query, "\n")
-
-    retrieved_docs = retriever.invoke(query)
-
-    print(f"Retriever returned {len(retrieved_docs)} documents.")
-    for i, d in enumerate(retrieved_docs, start=1):
-        print(f"\n=== DOC {i} ===")
-        print(d.page_content[:400], "...")
-        print("Metadata:", d.metadata)
-

speech_io.py

@@ -1,52 +0,0 @@
-# speech_io.py
-import os
-from tempfile import NamedTemporaryFile
-from typing import Optional
-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,
-        )
-
-    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 …")
-
-    response = client.audio.speech.create(
-        model="gpt-4o-mini-tts",
-        voice=voice,
-        input=text,
-    )
-
-    # HF Spaces + OpenAI SDK v2.x → raw bytes
-    audio_bytes = response.read()
-
-    tmp = NamedTemporaryFile(delete=False, suffix=".mp3")
-    tmp.write(audio_bytes)
-    tmp.close()
-
-    return tmp.name

split_documents.py

@@ -1,28 +0,0 @@
-# split_documents.py – v2
-
-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)
-

supabase_client.py

@@ -0,0 +1,12 @@
+# supabase_client.py
+import os
+from supabase import create_client
+
+SUPABASE_URL = os.environ["SUPABASE_URL"]
+SUPABASE_SERVICE_KEY = os.environ["SUPABASE_SERVICE_KEY"]
+
+supabase = create_client(SUPABASE_URL, SUPABASE_SERVICE_KEY)
+
+def load_file_bytes(bucket: str, filename: str) -> bytes:
+    """Tải file từ Supabase Storage nhưng KHÔNG ghi ra local – trả về bytes."""
+    return supabase.storage.from_(bucket).download(filename)

vectorstore.py

@@ -1,55 +0,0 @@
-"""
-BƯỚC 4: VECTORSTORE (FAISS in-memory)
--------------------------------------
-Tạo FAISS index từ các CHUNK văn bản.
-
-- Không ghi file .faiss nào, tất cả nằm trong RAM.
-- Embeddings được lấy từ get_embeddings() (Bước 3).
-"""
-
-from langchain_community.vectorstores import FAISS
-from embeddings import get_embeddings
-
-def build_vectorstore(chunks):
-    """
-    Nhận danh sách Document (đã split) và trả về FAISS VectorStore.
-    """
-    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__":
-    # Test toàn pipeline: load -> split -> FAISS -> similarity_search
-    from load_documents import load_documents
-    from split_documents import split_documents
-
-    print("=== TEST: load_documents -> split_documents -> FAISS.similarity_search ===\n")
-
-    # 1) Load tài liệu (PDF + HTML) từ HuggingFace
-    docs = load_documents()
-
-    # 2) Split thành chunks
-    from pprint import pprint
-    print(f"Loaded {len(docs)} raw documents.")
-    chunks = split_documents(docs)
-    print(f"Split into {len(chunks)} chunks.\n")
-
-    # 3) Xây FAISS vectorstore
-    vectorstore = build_vectorstore(chunks)
-
-    # 4) Test similarity_search
-    query = "Fristen für die Prüfungsanmeldung im Bachelorstudium"
-    print("Test query:")
-    print(" ", query, "\n")
-
-    results = vectorstore.similarity_search(query, k=3)
-
-    print("Top-3 ähnliche Chunks aus dem VectorStore:")
-    for i, doc in enumerate(results, start=1):
-        print(f"\n=== RESULT {i} ===")
-        print(doc.page_content[:400], "...")
-        print("Metadata:", doc.metadata)

viewer.py

@@ -1,76 +0,0 @@
-# viewer.py – Dynamischer HTML-Viewer für Hochschulgesetz NRW
-
-import os
-from supabase import create_client
-
-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)
-
-
-def generate_hg_viewer() -> str:
-    """
-    Tạo HTML full law, mỗi Paragraph có id="para_xx",
-    để /hg_view#para_xx có thể scroll đúng đoạn.
-    """
-    rows = (
-        supabase
-        .table("hg_nrw")
-        .select("*")
-        .order("order_index")
-        .execute()
-    ).data or []
-
-    html_parts = [
-        """
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <meta charset="utf-8">
-            <title>Hochschulgesetz NRW</title>
-            <style>
-                body {
-                    font-family: -apple-system, BlinkMacSystemFont, sans-serif;
-                    padding: 20px;
-                    line-height: 1.6;
-                }
-                h1 { margin-bottom: 10px; }
-                h2 {
-                    margin-top: 30px;
-                    scroll-margin-top: 20px;
-                }
-                .para-block {
-                    margin-bottom: 20px;
-                    padding-bottom: 10px;
-                    border-bottom: 1px solid #eee;
-                }
-                .subtitle {
-                    color: #555;
-                    font-size: 14px;
-                }
-            </style>
-        </head>
-        <body>
-            <h1>Hochschulgesetz NRW</h1>
-            <p class="subtitle">Dynamisch geladen aus Supabase (Tabelle hg_nrw)</p>
-        """
-    ]
-
-    for row in rows:
-        abs_id = row["abs_id"]
-        title = row["title"]
-        content = row["content"]
-
-        html_parts.append(f"""
-            <div class="para-block" id="{abs_id}">
-                <h2>{title}</h2>
-                <p>{content}</p>
-            </div>
-        """)
-
-    html_parts.append("</body></html>")
-    return "\n".join(html_parts)