commit

app.py

@@ -5,70 +5,59 @@ import gradio as gr
 from gradio_pdf import PDF
 from huggingface_hub import hf_hub_download
 
-from load_documents import load_documents, DATASET, PDF_FILE, HTML_FILE
+# from load_documents import load_documents, DATASET, PDF_FILE, HTML_FILE
+# from split_documents import split_documents
+# from vectorstore import build_vectorstore
+# from retriever import get_retriever
+# from llm import load_llm
+# from rag_pipeline import answer, PDF_BASE_URL, LAW_URL
+
+# from speech_io import transcribe_audio, synthesize_speech
+
+from load_documents import load_all_documents
 from split_documents import split_documents
 from vectorstore import build_vectorstore
 from retriever import get_retriever
 from llm import load_llm
-from rag_pipeline import answer, PDF_BASE_URL, LAW_URL
-
+from rag_pipeline import answer
 from speech_io import transcribe_audio, synthesize_speech
 
 # =====================================================
 # INITIALISIERUNG (global)
 # =====================================================
 
-print("🔹 Lade Dokumente ...")
-_docs = load_documents()
+print("📚 Lade Dokumente…")
+docs = load_all_documents()
 
-print("🔹 Splitte Dokumente ...")
-_chunks = split_documents(_docs)
+print("🔪 Splitte Dokumente…")
+chunks = split_documents(docs)
 
-print("🔹 Baue VectorStore (FAISS) ...")
-_vs = build_vectorstore(_chunks)
+print("🔍 Erstelle VectorStore…")
+vs = build_vectorstore(chunks)
 
-print("🔹 Erzeuge Retriever ...")
-_retriever = get_retriever(_vs)
+print("🔎 Erzeuge Retriever…")
+retriever = get_retriever(vs)
 
-print("🔹 Lade LLM ...")
-_llm = load_llm()
-
-print("🔹 Lade Dateien für Viewer …")
-_pdf_path = hf_hub_download(DATASET, PDF_FILE, repo_type="dataset")
-_html_path = hf_hub_download(DATASET, HTML_FILE, repo_type="dataset")
+print("🤖 Lade LLM…")
+llm = load_llm()
 
 # =====================================================
 # Quellen formatieren – Markdown für Chat
 # =====================================================
 
-def format_sources_markdown(sources):
-    if not sources:
+def format_sources(src):
+    if not src:
         return ""
 
-    lines = ["", "**📚 Quellen (genutzte Dokumentstellen):**"]
-    for s in sources:
-        sid = s["id"]
-        src = s["source"]
-        page = s["page"]
-        url = s["url"]
-        snippet = s["snippet"]
-
-        title = f"Quelle {sid} – {src}"
-
-        if url:
-            base = f"- [{title}]({url})"
-        else:
-            base = f"- {title}"
+    out = ["", "## 📚 Quellen"]
 
-        if page and "Prüfungsordnung" in src:
-            base += f", Seite {page}"
+    for s in src:
+        line = f"- [{s['source']}]({s['url']})"
+        if s.get("page"):
+            line += f" (Seite {s['page']})"
+        out.append(line)
 
-        lines.append(base)
-
-        if snippet:
-            lines.append(f"  > {snippet}")
-
-    return "\n".join(lines)
+    return "\n".join(out)
 
 # =====================================================
 # TEXT CHATBOT
@@ -197,15 +186,31 @@ with gr.Blocks(title="Prüfungsrechts-Chatbot (RAG + Sprache)") as demo:
         # RECHTE SPALTE: Viewer
         # =====================
 
+        # with gr.Column(scale=1):
+        #     gr.Markdown("### 📄 Prüfungsordnung (PDF)")
+        #     PDF(_pdf_path, height=350)
+
+        #     gr.Markdown("### 📘 Hochschulgesetz NRW (Website)")
+        #     gr.HTML(
+        #         f'<iframe src="{LAW_URL}" style="width:100%;height:350px;border:none;"></iframe>'
+        #     )
+
         with gr.Column(scale=1):
             gr.Markdown("### 📄 Prüfungsordnung (PDF)")
-            PDF(_pdf_path, height=350)
+            # PDF đã được load_documents cung cấp pdf_url — dùng metadata trực tiếp
+            pdf_meta = next(d.metadata for d in docs if d.metadata["type"] == "pdf")
+            PDF(pdf_meta["pdf_url"], height=350)
+
+            gr.Markdown("### 📘 Hochschulgesetz NRW")
+            hg_meta = next(d.metadata for d in docs if d.metadata["type"] == "hg")
+            hg_view_url = hg_meta["viewer_url"].split("#")[0]
 
-            gr.Markdown("### 📘 Hochschulgesetz NRW (Website)")
             gr.HTML(
-                f'<iframe src="{LAW_URL}" style="width:100%;height:350px;border:none;"></iframe>'
+                f'<iframe src="{hg_view_url}" '
+                'style="width:100%;height:350px;border:none;"></iframe>'
             )
 
+
 if __name__ == "__main__":
     demo.queue().launch(ssr_mode=False, show_error=True)
 

build_hg_viewer.py

@@ -13,7 +13,7 @@ if not SUPABASE_URL or not SUPABASE_SERVICE_ROLE:
 
 supabase = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE)
 
-from upload_weblink_to_supabase import extract_paragraphs
+#from upload_weblink_to_supabase import extract_paragraphs
 
 # ======== HTML TEMPLATE ========
 VIEW_TEMPLATE = """
@@ -240,9 +240,15 @@ function scrollToTop() {
 # 2. BUILD VIEWER
 # -------------------------------------------------------------------
 
-def build_html():
-    print(">>> Lade Paragraphs aus Supabase...")
-    paras = extract_paragraphs()
+def build_html_from_db():
+    """
+    Liest alle Paragraphen aus hg_nrw und baut daraus HTML.
+    """
+    print(">>> Lade Paragraphen aus Supabase (hg_nrw) …")
+    #paras = extract_paragraphs()
+    # 5.12_2:13
+    res = supabase.table("hg_nrw").select("*").order("order_index").execute()
+    rows = res.data or []
 
     sidebar_links = ""
     content_html = ""
@@ -296,7 +302,7 @@ def build_html():
 # -------------------------------------------------------------------
 
 def upload_html():
-    html = build_html()
+    html = build_html_from_db()
 
     supabase.storage.from_("hg_viewer").update(
         "hg_clean.html",

llm.py

@@ -14,9 +14,19 @@ def load_llm():
 
     print(f">>> Lade OpenAI Chatmodell: {CHAT_MODEL}")
 
+    # llm = ChatOpenAI(
+    #     model=CHAT_MODEL,
+    #     temperature=0.0,   # deterministisch, wenig Halluzination
+    #     api_key=api_key,
+    # )
+    # return llm
+    # 5.12_2:13
     llm = ChatOpenAI(
         model=CHAT_MODEL,
-        temperature=0.0,   # deterministisch, wenig Halluzination
+        temperature=0.0,
+        top_p=1.0,
+        presence_penalty=0.0,
+        frequency_penalty=0.0,
         api_key=api_key,
     )
     return llm

load_documents.py

@@ -1,130 +1,121 @@
 """
-BƯỚC 1: LOAD DOCUMENTS
------------------------
-Debug-full version
+LOAD_DOCUMENTS – SINGLE SOURCE OF TRUTH
 
-- Lädt Prüfungsordnung (PDF) seitenweise.
-- Lädt Hochschulgesetz NRW aus dem im Dataset gespeicherten HTML,
-  und zerlegt es in einzelne Absätze (Document pro <p>).
+Nhiệm vụ:
+1) Lade Prüfungsordnung PDF direkt aus Supabase-Storage.
+2) Lade Hochschulgesetz NRW aus Supabase-Tabelle hg_nrw.
+3) Cung cấp metadata đầy đủ để các file khác KHÔNG PHẢI tính lại URL.
 """
 
-from huggingface_hub import hf_hub_download, list_repo_files
+import os
+import tempfile
+from dotenv import load_dotenv
 from langchain_community.document_loaders import PyPDFLoader
 from langchain_core.documents import Document
-from bs4 import BeautifulSoup
+from supabase import create_client
 
-DATASET = "Nguyen5/docs"
+load_dotenv()
+
+# ===== Supabase config =====
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_SERVICE_ROLE = os.getenv("SUPABASE_SERVICE_ROLE")
+
+supabase = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE)
+
+# ===== Storage Config =====
+PDF_BUCKET = "File PDF"
 PDF_FILE = "f10_bpo_ifb_tei_mif_wii_2021-01-04.pdf"
-HTML_FILE = "Hochschulgesetz_NRW.html"  # konsistent mit hg_nrw.py
-
-def _load_hg_paragraph_documents(html_path: str):
-    """
-    Liest das generierte Hochschulgesetz-HTML ein und erzeugt
-    pro <p>-Element einen LangChain-Document mit:
-      - page_content = Text des Absatzes
-      - metadata:
-          source       = "Hochschulgesetz NRW (HTML)"
-          filename     = HTML_FILE
-          paragraph_id = id-Attribut (z.B. 'hg_abs_12'), falls vorhanden
-    """
-    with open(html_path, "r", encoding="utf-8") as f:
-        html = f.read()
-
-    soup = BeautifulSoup(html, "html.parser")
-    docs = []
 
-    for p in soup.find_all("p"):
-        text = p.get_text(" ", strip=True)
-        if not text:
-            continue
+PDF_URL = f"{SUPABASE_URL}/storage/v1/object/public/{PDF_BUCKET}/{PDF_FILE}"
+
+# ===== Viewer URL =====
+HG_VIEWER_URL = (
+    f"{SUPABASE_URL}/storage/v1/object/public/hg_viewer/hg_clean.html"
+)
+
+
+# ============================================================
+# 1) PDF aus Supabase laden
+# ============================================================
+
+def load_pdf_from_supabase() -> list[Document]:
+    print("📥 Lade Prüfungsordnung PDF aus Supabase...")
+
+    response = supabase.storage.from_(PDF_BUCKET).download(PDF_FILE)
+    if response is None:
+        raise ValueError("❌ Konnte PDF nicht laden!")
 
-        pid = p.get("id")
+    # Temporäre Datei
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+        tmp.write(response)
+        temp_pdf_path = tmp.name
 
-        metadata = {
-            "source": "Hochschulgesetz NRW (HTML)",
-            "filename": HTML_FILE,
+    pages = PyPDFLoader(temp_pdf_path).load()
+
+    for i, p in enumerate(pages):
+        p.metadata = {
+            "type": "pdf",
+            "source": "Prüfungsordnung",
+            "page": i,
+            "pdf_url": f"{PDF_URL}#page={i+1}",
+            "filename": PDF_FILE,
         }
-        if pid:
-            metadata["paragraph_id"] = pid
 
-        docs.append(Document(page_content=text, metadata=metadata))
+    print(f"✔ {len(pages)} PDF-Seiten geladen.")
+    return pages
 
-    print(f"Loaded {len(docs)} paragraph Documents from HG-HTML.\n")
-    return docs
 
-def load_documents():
-    print("=== START: load_documents() ===\n")
+# ============================================================
+# 2) HG aus Tabelle laden
+# ============================================================
 
-    # -------------------------
-    # Check files in dataset
-    # -------------------------
-    print(">>> Checking dataset file list from HuggingFace...")
-    files = list_repo_files(DATASET, repo_type="dataset")
-    print("Files in dataset:", files, "\n")
+def load_hg_from_supabase() -> list[Document]:
+    print("📥 Lade Hochschulgesetz NRW aus Tabelle hg_nrw...")
 
+    res = (
+        supabase.table("hg_nrw")
+        .select("*")
+        .order("order_index", desc=False)
+        .execute()
+    )
+    rows = res.data or []
     docs = []
 
-    # -------------------------
-    # Load PDF
-    # -------------------------
-    print(">>> Step 1: Download PDF from HuggingFace...")
-    try:
-        pdf_path = hf_hub_download(
-            repo_id=DATASET,
-            filename=PDF_FILE,
-            repo_type="dataset",
+    for row in rows:
+        abs_id = row["abs_id"]
+        title = row["title"]
+        content = row["content"]
+
+        viewer_url = f"{HG_VIEWER_URL}#{abs_id}"
+
+        docs.append(
+            Document(
+                page_content=content,
+                metadata={
+                    "type": "hg",
+                    "source": "Hochschulgesetz NRW",
+                    "abs_id": abs_id,
+                    "title": title,
+                    "viewer_url": viewer_url,
+                },
+            )
         )
-        print(f"Downloaded PDF to local cache:\n{pdf_path}\n")
-    except Exception as e:
-        print("ERROR downloading PDF:", e)
-        return []
-
-    print(">>> Step 1.1: Loading PDF pages...")
-    try:
-        pdf_docs = PyPDFLoader(pdf_path).load()
-        print(f"Loaded {len(pdf_docs)} PDF pages.\n")
-    except Exception as e:
-        print("ERROR loading PDF:", e)
-        return []
-
-    for d in pdf_docs:
-        d.metadata["source"] = "Prüfungsordnung (PDF)"
-        d.metadata["filename"] = PDF_FILE
-
-    docs.extend(pdf_docs)
-
-    # -------------------------
-    # Load HTML (Hochschulgesetz NRW)
-    # -------------------------
-    print(">>> Step 2: Download HTML from HuggingFace...")
-    try:
-        html_path = hf_hub_download(
-            repo_id=DATASET,
-            filename=HTML_FILE,
-            repo_type="dataset",
-        )
-        print(f"Downloaded HTML to local cache:\n{html_path}\n")
-    except Exception as e:
-        print("ERROR downloading HTML:", e)
-        return docs
 
-    print(">>> Step 2.1: Loading HG-HTML and splitting into paragraphs...")
-    try:
-        html_docs = _load_hg_paragraph_documents(html_path)
-    except Exception as e:
-        print("ERROR loading / parsing HTML:", e)
-        return docs
+    print(f"✔ {len(docs)} HG-Absätze geladen.")
+    return docs
+
 
-    docs.extend(html_docs)
+# ============================================================
+# 3) ALLES LADEN
+# ============================================================
 
-    print("=== DONE: load_documents() ===\n")
-    return docs
+def load_all_documents():
+    pdf_docs = load_pdf_from_supabase()
+    hg_docs = load_hg_from_supabase()
+    return pdf_docs + hg_docs
 
-if __name__ == "__main__":
-    print("\n=== Running load_documents.py directly ===\n")
-    docs = load_documents()
-    print(f"\n>>> TOTAL documents loaded: {len(docs)}")
 
-    if len(docs):
-        print("\nExample metadata from 1st document:")
-        print(docs[0].metadata)
+if __name__ == "__main__":
+    docs = load_all_documents()
+    print("📚 Gesamt:", len(docs))
+    print("🔎 Beispiel metadata:", docs[0].metadata)

rag_pipeline.py

@@ -2,108 +2,78 @@
 RAG PIPELINE – Version 26.11 (ohne Modi, stabil, juristisch korrekt)
 """
 
+# from typing import List, Dict, Any, Tuple
+# from langchain_core.messages import SystemMessage, HumanMessage
+# from load_documents import DATASET, PDF_FILE, HTML_FILE
+# 5.12_2:13
 from typing import List, Dict, Any, Tuple
+import os
 from langchain_core.messages import SystemMessage, HumanMessage
-from load_documents import DATASET, PDF_FILE, HTML_FILE
+from load_documents import DATASET, PDF_FILE
 
-# -------------------------------------------------------------------
-# URLs für Quellen
-# -------------------------------------------------------------------
-
-# Direktes PDF im Dataset (für #page)
-PDF_BASE_URL = f"https://huggingface.co/datasets/{DATASET}/resolve/main/{PDF_FILE}"
-
-# Hochschulgesetz-HTML im Dataset (enthält <p id="hg_abs_X"> …)
-LAW_DATASET_URL = f"https://huggingface.co/datasets/{DATASET}/resolve/main/{HTML_FILE}"
-
-# Offizielle Recht.NRW-Druckversion (für Viewer im Frontend)
-LAW_URL = (
-    "https://recht.nrw.de/lmi/owa/br_text_anzeigen?v_id=10000000000000000654"
-)
 
 MAX_CHARS = 900
 
-# -----------------------------
-# Quellen formatieren
-# -----------------------------
+# ============================================================
+# Quellenaufbereitung – NUR metadata verwenden!
+# ============================================================
 
 def build_sources_metadata(docs: List) -> List[Dict[str, Any]]:
-    """
-    Erzeugt eine Liste strukturierter Quellen-Infos:
-
-    [
-      {
-        "id": 1,
-        "source": "Prüfungsordnung (PDF)" / "Hochschulgesetz NRW (HTML)",
-        "page": 3,          # nur bei PDF
-        "url": "...",       # direkter Klick-Link
-        "snippet": "Erste 300 Zeichen des Chunks..."
-      },
-      ...
-    ]
-    """
-    srcs = []
-    for i, d in enumerate(docs):
+    sources = []
+
+    for idx, d in enumerate(docs):
         meta = d.metadata
-        src = meta.get("source", "")
-        page = meta.get("page")
         snippet = d.page_content[:300].replace("\n", " ")
 
-        # PDF-Link
-        if "Prüfungsordnung" in src:
-            if isinstance(page, int):
-                # PyPDFLoader: page ist 0-basiert, Anzeige 1-basiert
-                url = f"{PDF_BASE_URL}#page={page + 1}"
-            else:
-                url = PDF_BASE_URL
-
-        # NRW-Gesetz (HTML im Dataset mit Absatz-IDs)
-        elif "Hochschulgesetz" in src:
-            para_id = meta.get("paragraph_id")
-            if para_id:
-                # Klick führt direkt zum Absatz im Dataset-HTML
-                url = f"{LAW_DATASET_URL}#{para_id}"
-            else:
-                # Fallback: offizielle Druckversion (ohne Absatz-Anker)
-                url = LAW_URL
-            page = None  # keine Seitenangabe für Gesetz-HTML
-
-        else:
-            url = None
-
-        srcs.append(
-            {
-                "id": i + 1,
-                "source": src,
-                "page": page + 1 if isinstance(page, int) else None,
-                "url": url,
+        # PDF
+        if meta.get("type") == "pdf":
+            sources.append({
+                "id": idx + 1,
+                "source": "Prüfungsordnung (PDF)",
+                "page": meta.get("page"),
+                "url": meta.get("pdf_url"),   # KHÔNG tạo lại!
                 "snippet": snippet,
-            }
-        )
-    return srcs
+            })
+            continue
+
+        # Hochschulgesetz NRW
+        if meta.get("type") == "hg":
+            sources.append({
+                "id": idx + 1,
+                "source": "Hochschulgesetz NRW",
+                "page": None,
+                "url": meta.get("viewer_url"),  # KHÔNG tạo lại!
+                "snippet": snippet,
+            })
+            continue
 
-# -----------------------------
-# Kontext formatieren
-# -----------------------------
+    return sources
+
+# ============================================================
+# Kontextaufbereitung
+# ============================================================
 
-def format_context(docs):
+def format_context(docs: List) -> str:
     if not docs:
-        return "(Kein relevanter Kontext im Dokument gefunden.)"
+        return "(Kein relevanter Kontext gefunden.)"
+
+    blocks = []
 
-    out = []
     for i, d in enumerate(docs):
-        txt = d.page_content[:MAX_CHARS]
-        src = d.metadata.get("source")
-        page = d.metadata.get("page")
+        meta = d.metadata
+        doc_type = meta.get("type")
 
-        if "Prüfungsordnung" in (src or "") and isinstance(page, int):
-            src_str = f"{src}, Seite {page + 1}"
-        else:
-            src_str = src
+        label = "Prüfungsordnung" if doc_type == "pdf" else "Hochschulgesetz NRW"
 
-        out.append(f"[KONTEXT {i+1}] ({src_str})\n{txt}")
+        if doc_type == "pdf":
+            page = meta.get("page")
+            label += f", Seite {page+1}" if isinstance(page, int) else ""
+
+        blocks.append(
+            f"[KONTEXT {i+1}] ({label})\n{d.page_content[:MAX_CHARS]}"
+        )
 
-    return "\n\n".join(out)
+    return "\n\n".join(blocks)
 
 # -----------------------------
 # Systemprompt — verschärft
@@ -160,7 +130,7 @@ def answer(question: str, retriever, chat_model) -> Tuple[str, List[Dict[str, An
     context_str = format_context(docs)
 
     # 2. Prompt bauen
-    human = f"""
+    user_prompt = f"""
 FRAGE:
 {question}
 
@@ -179,7 +149,7 @@ ausschließlich anhand des obigen Kontextes.
 
     msgs = [
         SystemMessage(content=SYSTEM_PROMPT),
-        HumanMessage(content=human),
+        HumanMessage(content=user_prompt),
     ]
 
     # 3. LLM aufrufen

requirements.txt

@@ -33,5 +33,6 @@ numpy
 torchaudio
 torch
 
-# OpenAI offizielle Bibliothek (kommt i.d.R. mit langchain-openai, zur Sicherheit explizit)
+# === OpenAI + HF Hub ===
 openai
+huggingface_hub

upload_weblink_to_supabase.py

@@ -11,13 +11,34 @@ SUPABASE_SERVICE_ROLE = os.environ["SUPABASE_SERVICE_ROLE"]
 
 supabase = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE)
 
+# URL CHÍNH THỨC – không dùng Druckversion
 LAW_URL = "https://recht.nrw.de/lmi/owa/br_text_anzeigen?v_id=10000000000000000654"
 
 def extract_paragraphs():
-    print(">>> Lade Hochschulgesetz NRW …")
+    """
+    Lädt die aktuelle Fassung des Hochschulgesetzes NRW
+    von recht.nrw.de (br_text_anzeigen) und extrahiert Paragraphen.
+
+    Ergebnis: Liste von Dicts mit:
+      - abs_id:    para_1, para_2, ...
+      - title:     "§ 1 ...", "§ 2 ..."
+      - content:   gesamter Text des Paragraphen
+      - order_index: laufende Nummer
+    """
+    print(">>> Lade offizielles Hochschulgesetz NRW von recht.nrw.de …")
+
+
+    # html = requests.get(LAW_URL, timeout=30).text
+    # soup = BeautifulSoup(html, "html.parser")
+    # 5.12_2:13
+    resp = requests.get(LAW_URL, timeout=30)
+    resp.raise_for_status()
+    soup = BeautifulSoup(resp.text, "html.parser")
+
+    # 5.12_2:13
+    # Paragraph-Überschriften: häufig in <p>, <b> oder <strong>
+    candidates = soup.find_all(["p", "b", "strong"])
 
-    html = requests.get(LAW_URL, timeout=30).text
-    soup = BeautifulSoup(html, "html.parser")
 
     # Tất cả tiêu đề Paragraph xuất hiện trong <h2> hoặc <h3>
     headers = soup.find_all(["h2", "h3"])
@@ -25,45 +46,79 @@ def extract_paragraphs():
     paragraphs = []
     order = 1
 
-    for header in headers:
-        title = header.get_text(" ", strip=True)
+    # for header in headers:
+    #     title = header.get_text(" ", strip=True)
 
-        if not title.startswith("§"):
-            continue  # bỏ các h2/h3 không phải Paragraph
+    #     if not title.startswith("§"):
+    #         continue  # bỏ các h2/h3 không phải Paragraph
 
-        # Gom toàn bộ nội dung từ header đến trước h2/h3 tiếp theo
-        content_parts = []
-        sibling = header.find_next_sibling()
+    #     # Gom toàn bộ nội dung từ header đến trước h2/h3 tiếp theo
+    #     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()
+    #     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()
+    #     full_content = "\n".join(content_parts).strip()
 
-        para_id = f"para_{order}"
+    #     para_id = f"para_{order}"
 
-        paragraphs.append({
-            "abs_id": para_id,
-            "title": title,
-            "content": full_content,
-            "order_index": order
-        })
+    #     paragraphs.append({
+    #         "abs_id": para_id,
+    #         "title": title,
+    #         "content": full_content,
+    #         "order_index": order
+    #     })
 
+    #     order += 1
+
+    # print(f"✔ Extracted {len(paragraphs)} paragraphs (§).")
+    # return paragraphs
+    # 5.12_2:13
+    for tag in candidates:
+        text = tag.get_text(" ", strip=True)
+        if not text.startswith("§"):
+            continue
+
+        title = text
+        content_parts = []
+        sibling = tag.find_next_sibling()
+
+        while sibling and not (
+            (sibling.name in ["p", "b", "strong"])
+            and sibling.get_text(" ", strip=True).startswith("§")
+        ):
+            txt = sibling.get_text(" ", strip=True)
+            if txt:
+                content_parts.append(txt)
+            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,
+            }
+        )
         order += 1
 
-    print(f"✔ Extracted {len(paragraphs)} paragraphs (§).")
+    print(f"✔ {len(paragraphs)} Paragraphen extrahiert.")
     return paragraphs
 
 def upload_to_supabase():
     paras = extract_paragraphs()
 
-    print(">>> Clear table hg_nrw …")
+    print(">>> Leere Tabelle hg_nrw …")
     supabase.table("hg_nrw").delete().neq("abs_id", "").execute()
 
-    print(">>> Upload begin …")
+    print(">>> Upload nach Supabase …")
     BATCH = 100
     for i in range(0, len(paras), BATCH):
         batch = paras[i:i+BATCH]