commit

load_documents.py

@@ -1,116 +1,160 @@
-# load_documents.py – Supabase + statischer HTML-Viewer
+"""
+BƯỚC 1: LOAD DOCUMENTS
+-----------------------
+Debug-full version
 
-import os
-import requests
-import tempfile
-from supabase import create_client
-from langchain_core.documents import Document
+- 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>).
+"""
+
+from huggingface_hub import hf_hub_download, list_repo_files
 from langchain_community.document_loaders import PyPDFLoader
+from langchain_core.documents import Document
+from bs4 import BeautifulSoup
 
-# ---------------------------------------------------------
-# ENV Variablen aus HuggingFace Space
-# ---------------------------------------------------------
-SUPABASE_URL = os.getenv("SUPABASE_URL")
-SUPABASE_ANON_KEY = os.getenv("SUPABASE_ANON_KEY")
+DATASET = "Nguyen5/docs"
+PDF_FILE = "f10_bpo_ifb_tei_mif_wii_2021-01-04.pdf"
+HTML_FILE = "Hochschulgesetz_NRW.html"  # konsistent mit hg_nrw.py
 
-if not SUPABASE_URL or not SUPABASE_ANON_KEY:
-    raise RuntimeError("Missing SUPABASE_URL / SUPABASE_ANON_KEY in environment.")
+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()
 
-supabase = create_client(SUPABASE_URL, SUPABASE_ANON_KEY)
+    soup = BeautifulSoup(html, "html.parser")
+    docs = []
 
-# ---------------------------------------------------------
-# Prüfungsordnung PDF – liegt in Supabase Storage (public)
-# ---------------------------------------------------------
-PDF_FILE = "f10_bpo_ifb_tei_mif_wii_2021-01-04.pdf"
-PDF_URL = f"{SUPABASE_URL}/storage/v1/object/public/File%20PDF/{PDF_FILE}"
+    for p in soup.find_all("p"):
+        text = p.get_text(" ", strip=True)
+        if not text:
+            continue
 
-# ---------------------------------------------------------
-# Statischer Paragraph-Viewer in HuggingFace Space
-# -> hg_clean.html liegt als Datei im Repo!
-# -> in der App: iframe src="file=hg_clean.html"
-# -> für Links: "file=hg_clean.html#para_123"
-# ---------------------------------------------------------
-HG_HTML_URL = "file=hg_clean.html"   # WICHTIG: nicht absolut, Space kümmert sich
+        pid = p.get("id")
 
-def load_hg_nrw():
-    """
-    Holt alle Paragraphen aus Tabelle public.hg_nrw und baut
-    LangChain-Dokumente. Jeder Paragraph:
-      - title  : z.B. "§ 64 (Fn 35) Prüfungsordnungen"
-      - content: Volltext inkl. Fußnoten
-      - abs_id : para_1, para_2, ...
-    """
-    print(">>> Lade Hochschulgesetz NRW (§) aus Supabase…")
+        metadata = {
+            "source": "Hochschulgesetz NRW (HTML)",
+            "filename": HTML_FILE,
+        }
+        if pid:
+            metadata["paragraph_id"] = pid
 
-    rows = (
-        supabase.table("hg_nrw")
-        .select("*")
-        .order("order_index")
-        .execute()
-    ).data or []
+        docs.append(Document(page_content=text, metadata=metadata))
 
-    print(f"   - {len(rows)} Paragraphen geladen.")
+    print(f"Loaded {len(docs)} paragraph Documents from HG-HTML.\n")
+    return docs
+
+def load_documents():
+    print("=== START: load_documents() ===\n")
+
+    # -------------------------
+    # 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")
 
     docs = []
-    for r in rows:
-        abs_id = r["abs_id"]      # z.B. "para_64"
-        title = r.get("title", "")
-        content = r.get("content", "")
-
-        # Anker im Viewer – IDs in hg_clean.html sind identisch (id="para_64")
-        viewer_url = f"{HG_HTML_URL}#{abs_id}"
-
-        docs.append(
-            Document(
-                page_content=f"{title}\n{content}",
-                metadata={
-                    "source": "Hochschulgesetz NRW",
-                    "paragraph": title,
-                    "abs_id": abs_id,
-                    "url": viewer_url,
-                },
-            )
+
+    # -------------------------
+    # Load PDF
+    # -------------------------
+    print(">>> Step 1: Download PDF from HuggingFace...")
+    try:
+        pdf_path = hf_hub_download(
+            repo_id=DATASET,
+            filename=PDF_FILE,
+            repo_type="dataset",
         )
+        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
 
+    docs.extend(html_docs)
+
+    print("=== DONE: load_documents() ===\n")
     return docs
 
-def load_pdf():
-    """
-    Lädt Prüfungsordnung aus Supabase Storage, speichert temporär,
-    splitten erfolgt später in split_documents.py.
-    """
-    print(">>> Lade Prüfungsordnung PDF …")
+if __name__ == "__main__":
+    print("\n=== Running load_documents.py directly ===\n")
+    docs = load_documents()
+    print(f"\n>>> TOTAL documents loaded: {len(docs)}")
 
-    resp = requests.get(PDF_URL)
-    resp.raise_for_status()
+    if len(docs):
+        print("\nExample metadata from 1st document:")
+        print(docs[0].metadata)
 
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
-        tmp.write(resp.content)
-        path = tmp.name
 
-    pages = PyPDFLoader(path).load()
+- split_documents.py: 
+# split_documents.py – v2
 
-    for i, p in enumerate(pages):
-        p.metadata["source"] = "Prüfungsordnung (PDF)"
-        p.metadata["page"] = i           # 0-basiert
-        p.metadata["pdf_url"] = PDF_URL
+from langchain_text_splitters import RecursiveCharacterTextSplitter
 
-    print(f"   - {len(pages)} PDF-Seiten geladen.")
-    return pages
+CHUNK_SIZE = 1500
+CHUNK_OVERLAP = 200
 
-def load_documents():
-    """
-    Master-Funktion:
-      - Hochschulgesetz NRW (Supabase Tabelle hg_nrw)
-      - Prüfungsordnung (PDF)
-    """
-    docs = []
-    docs.extend(load_hg_nrw())
-    docs.extend(load_pdf())
-    print(f"✔ DOCUMENTS LOADED: {len(docs)}")
-    return docs
+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()
-    print(docs[0])
-    print("Total:", len(docs))
+    chunks = split_documents(docs)
+    print("Docs:", len(docs), "Chunks:", len(chunks))
+    print(chunks[0].page_content[:300], chunks[0].metadata)

rag_pipeline.py

@@ -1,98 +1,163 @@
-# rag_pipeline.py – OpenAI RAG mit Supabase-Dokumenten
+"""
+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
+
+# -------------------------------------------------------------------
+# 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_bes_text?"
+    "print=1&anw_nr=2&gld_nr=2&ugl_nr=221&val=28364&ver=0&"
+    "aufgehoben=N&keyword=&bes_id=28364&show_preview=1"
+)
 
 MAX_CHARS = 900
 
-# ------------------------------------------------------
-# Quellen-Metadaten
-# ------------------------------------------------------
+# -----------------------------
+# Quellen formatieren
+# -----------------------------
 
 def build_sources_metadata(docs: List) -> List[Dict[str, Any]]:
     """
-    Gibt für jeden verwendeten Chunk eine strukturierte Quelle zurück:
-    - id
-    - source (Dokument)
-    - page (bei PDF)
-    - url (PDF-Seite oder hg_clean.html#para_x)
-    - snippet (Kurzvorschau)
+    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):
         meta = d.metadata
-        src = meta.get("source")
+        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}"
+        # 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_url
-
-        elif src == "Hochschulgesetz NRW":
-            url = meta.get("url")
-            page = None
+                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,
-            "snippet": snippet,
-        })
-
+        srcs.append(
+            {
+                "id": i + 1,
+                "source": src,
+                "page": page + 1 if isinstance(page, int) else None,
+                "url": url,
+                "snippet": snippet,
+            }
+        )
     return srcs
 
-# ------------------------------------------------------
-# Kontextformatierung
-# ------------------------------------------------------
+# -----------------------------
+# Kontext formatieren
+# -----------------------------
 
 def format_context(docs):
     if not docs:
-        return "(Kein relevanter Kontext gefunden.)"
+        return "(Kein relevanter Kontext im Dokument gefunden.)"
 
-    out_lines = []
+    out = []
     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):
+        if "Prüfungsordnung" in (src or "") and isinstance(page, int):
             src_str = f"{src}, Seite {page + 1}"
         else:
             src_str = src
 
-        out_lines.append(f"[KONTEXT {i+1}] ({src_str})\n{txt}")
+        out.append(f"[KONTEXT {i+1}] ({src_str})\n{txt}")
 
-    return "\n\n".join(out_lines)
+    return "\n\n".join(out)
+
+# -----------------------------
+# Systemprompt — verschärft
+# -----------------------------
 
 SYSTEM_PROMPT = """
-Du bist ein juristisch präziser Chatbot für Prüfungsrecht.
-Du nutzt ausschließlich:
+Du bist ein hochpräziser juristischer Chatbot für Prüfungsrecht
+mit Zugriff nur auf:
+
+- die Prüfungsordnung (als PDF) und
+- das Hochschulgesetz NRW (als HTML aus der offiziellen Druckversion).
+
+Strenge Regeln:
 
-- die Prüfungsordnung (PDF) und
-- das Hochschulgesetz NRW (Paragraphen aus der Datenbank / hg_clean.html)
+1. Antworte ausschließlich anhand des bereitgestellten Kontextes
+   (KONTEXT-Abschnitte). Wenn die Information nicht im Kontext steht,
+   sage ausdrücklich, dass dies aus den vorliegenden Dokumenten nicht
+   hervorgeht und du dazu nichts Sicheres sagen kannst.
 
-Regeln:
+2. 
+   Keine Spekulationen, keine Vermutungen.
 
-1. Antworte nur auf Basis des gelieferten Kontextes.
-2. Wenn der Kontext keine sichere Antwort erlaubt, sage das klar.
-3. Antworte in gut verständlichem Deutsch, in ganzen Sätzen.
-4. Nenne, soweit möglich:
-   - Paragraphen oder Überschriften,
+3. Antworte in zusammenhängenden, ganzen Sätzen. Verwende keine Mischung aus Deutsch und Englisch.
+
+4. Nenne, soweit aus dem Kontext erkennbar,
+   - die rechtliche Grundlage (z.B. Paragraph, Artikel),
    - das Dokument (Prüfungsordnung / Hochschulgesetz NRW),
-   - Seitenzahl (bei der Prüfungsordnung).
+   - die Seite (bei der Prüfungsordnung), wenn im Kontext vorhanden.
+
+5. Füge KEINE externen Informationen hinzu, z.B. aus anderen Gesetzen,
+   Webseiten oder allgemeinem Wissen. Nur das, was im Kontext steht,
+   darf in der Antwort verwendet werden.
+
+Wenn der Kontext keine eindeutige Antwort zulässt, erkläre klar,
+warum keine sichere Antwort möglich ist und welche Informationen
+im Dokument fehlen.
 """
 
+# -----------------------------
+# Hauptfunktion
+# -----------------------------
+
 def answer(question: str, retriever, chat_model) -> Tuple[str, List[Dict[str, Any]]]:
-    # 1. Chunks holen
+    """
+    Haupt-RAG-Funktion:
+
+    - ruft retriever.invoke(question) auf,
+    - baut einen präzisen Prompt mit KONTEXT,
+    - ruft LLM auf,
+    - gibt Antworttext + Quellenliste zurück.
+    """
+    # 1. Dokumente holen
     docs = retriever.invoke(question)
     context_str = format_context(docs)
 
@@ -105,9 +170,13 @@ NUTZE AUSSCHLIESSLICH DIESEN KONTEXT:
 {context_str}
 
 AUFGABE:
-Erstelle eine juristisch korrekte Antwort ausschließlich auf Basis
-des obigen Kontextes. Wenn der Kontext keine sichere Antwort zulässt,
-sage das ausdrücklich und verzichte auf Spekulationen.
+Formuliere eine juristisch korrekte, gut verständliche Antwort
+ausschließlich anhand des obigen Kontextes.
+
+- Wenn der Kontext aus den Dokumenten eine klare Antwort erlaubt,
+  erläutere diese strukturiert und in vollständigen Sätzen.
+- Wenn der Kontext KEINE klare Antwort erlaubt oder wichtige Informationen
+  fehlen, erkläre das offen und formuliere KEINE Vermutung.
 """
 
     msgs = [
@@ -119,7 +188,7 @@ sage das ausdrücklich und verzichte auf Spekulationen.
     result = chat_model.invoke(msgs)
     answer_text = result.content.strip()
 
-    # 4. Quellenliste
+    # 4. Quellenliste bauen
     sources = build_sources_metadata(docs)
 
     return answer_text, sources