age

app.py

@@ -1,21 +1,14 @@
 # app.py
-# Flask RAG app (HF Spaces / CPU) — fixed finalization protocol for R1-style models
-# - Forces model to write answer inside <final>...</final> and stops at </final>
-# - Safer cleaning of <think> blocks
-# - Same routes, admin pages, and Postgres auth as before
-
+# Flask RAG app (HF Spaces / Static) — dataset sudah ada di Space.
 import os, json, re, time, logging
-from functools import lru_cache, wraps
+from functools import lru_cache
 from typing import Dict, List, Tuple
 from dataclasses import dataclass
 from datetime import datetime
 from zoneinfo import ZoneInfo
 from pathlib import Path
 
-from flask import (
-    Flask, render_template, request, redirect, url_for, session, jsonify, flash
-)
-
+from flask import Flask, render_template, request, redirect, url_for, session, jsonify, flash
 import numpy as np
 import faiss
 import torch
@@ -27,75 +20,68 @@ load_dotenv()
 # ========= ENV & LOGGING =========
 os.environ.setdefault("KMP_DUPLICATE_LIB_OK", "TRUE")
 os.environ.setdefault("OMP_NUM_THREADS", "1")
-# keep CPU footprint low in HF Spaces
-try:
-    torch.set_num_threads(int(os.environ.get("NUM_THREADS", "4")))
-    torch.set_num_interop_threads(1)
-except Exception:
-    pass
-
+torch.set_num_threads(1)
+torch.set_num_interop_threads(1)
 logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
 log = logging.getLogger("rag-app")
 
 # ========= IMPORT EKSTERNAL =========
-# Expect file Guardrail.py with validate_input(text:str)->bool
-# Expect file Model.py with load_model(gguf_path, n_ctx, n_gpu_layers, n_threads) and
-#   generate(llm, prompt, max_tokens, temperature, top_p, stop:list[str]) -> str
-from Guardrail import validate_input           # -> bool (lazy in file)
+from Guardrail import validate_input           # -> bool (lazy di file)
 from Model import load_model, generate         # -> llama.cpp wrapper
 
 # ========= PATH ROOT PROYEK =========
 BASE_DIR = Path(__file__).resolve().parent
 
 # ========= KONFIGURASI RAG =========
-MODEL_PATH  = str(BASE_DIR / "models" / os.getenv("GGUF_FILENAME", "DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf"))
-CTX_WINDOW  = int(os.environ.get("CTX_WINDOW", 2048))  # 2048 cukup untuk RAG singkat
-N_GPU_LAYERS = int(os.environ.get("N_GPU_LAYERS", 0))  # HF Spaces CPU only
-N_THREADS    = int(os.environ.get("NUM_THREADS", 4))
+MODEL_PATH   = str(BASE_DIR / "models" / os.getenv("GGUF_FILENAME", "DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf"))
+CTX_WINDOW   = 4096
+N_GPU_LAYERS = 0  # HF Spaces CPU only
+N_THREADS    = int(os.environ.get("NUM_THREADS", "4"))
 
-# ganti ke encoder lain jika perlu (m-e5-large cukup bagus untuk multilingual)
-ENCODER_NAME   = os.environ.get("ENCODER_NAME", "intfloat/multilingual-e5-large")
+ENCODER_NAME   = "intfloat/multilingual-e5-large"
 ENCODER_DEVICE = torch.device("cpu")
 
 # Dataset sudah ada di Space → path RELATIF
 SUBJECTS: Dict[str, Dict[str, str]] = {
     "ipas": {
-        "index": str(BASE_DIR / "Rag-Pipeline" / "Vektor Database" / "Ipas" / "IPA_index.index"),
-        "chunks": str(BASE_DIR / "Dataset" / "Ipas" / "Chunk" / "ipas_chunks.json"),
-        "embeddings": str(BASE_DIR / "Dataset" / "Ipas" / "Embedd"/ "ipas_embeddings.npy"),
-        "label": "IPAS",
-        "desc": "Ilmu Pengetahuan Alam dan Sosial"
+        "index":      str(BASE_DIR / "Rag-Pipeline" / "Vektor Database" / "Ipas" / "IPA_index.index"),
+        "chunks":     str(BASE_DIR / "Dataset"      / "Ipas"            / "Chunk" / "ipas_chunks.json"),
+        "embeddings": str(BASE_DIR / "Dataset"      / "Ipas"            / "Embedd"/ "ipas_embeddings.npy"),
+        "label":      "IPAS",
+        "desc":       "Ilmu Pengetahuan Alam dan Sosial"
     },
     "penjas": {
-        "index": str(BASE_DIR / "Rag-Pipeline" / "Vektor Database" / "Penjas" / "PENJAS_index.index"),
-        "chunks": str(BASE_DIR / "Dataset" / "Penjas" / "Chunk" / "penjas_chunks.json"),
-        "embeddings": str(BASE_DIR / "Dataset" / "Penjas" / "Embedd" / "penjas_embeddings.npy"),
-        "label": "PJOK",
-        "desc": "Pendidikan Jasmani, Olahraga, dan Kesehatan"
+        "index":      str(BASE_DIR / "Rag-Pipeline" / "Vektor Database" / "Penjas" / "PENJAS_index.index"),
+        "chunks":     str(BASE_DIR / "Dataset"      / "Penjas"          / "Chunk"  / "penjas_chunks.json"),
+        "embeddings": str(BASE_DIR / "Dataset"      / "Penjas"          / "Embedd" / "penjas_embeddings.npy"),
+        "label":      "PJOK",
+        "desc":       "Pendidikan Jasmani, Olahraga, dan Kesehatan"
     },
     "pancasila": {
-        "index": str(BASE_DIR / "Rag-Pipeline" / "Vektor Database" / "Pancasila" / "PANCASILA_index.index"),
-        "chunks": str(BASE_DIR / "Dataset" / "Pancasila" / "Chunk" / "pancasila_chunks.json"),
-        "embeddings": str(BASE_DIR / "Dataset" / "Pancasila" / "Embedd" / "pancasila_embeddings.npy"),
-        "label": "PANCASILA",
-        "desc": "Pendidikan Pancasila dan Kewarganegaraan"
+        "index":      str(BASE_DIR / "Rag-Pipeline" / "Vektor Database" / "Pancasila" / "PANCASILA_index.index"),
+        "chunks":     str(BASE_DIR / "Dataset"      / "Pancasila"       / "Chunk"     / "pancasila_chunks.json"),
+        "embeddings": str(BASE_DIR / "Dataset"      / "Pancasila"       / "Embedd"    / "pancasila_embeddings.npy"),
+        "label":      "PANCASILA",
+        "desc":       "Pendidikan Pancasila dan Kewarganegaraan"
     }
 }
 
 # Threshold dan fallback
-TOP_K_FAISS   = int(os.environ.get("TOP_K_FAISS", 24))
-TOP_K_FINAL   = int(os.environ.get("TOP_K_FINAL", 10))
-MIN_COSINE    = float(os.environ.get("MIN_COSINE", 0.84))
-MIN_HYBRID    = float(os.environ.get("MIN_HYBRID", 0.15))
-FALLBACK_TEXT = os.environ.get("FALLBACK_TEXT", "maap pengetahuan tidak ada dalam database")
-GUARDRAIL_BLOCK_TEXT = os.environ.get("GUARDRAIL_BLOCK_TEXT", "maap, pertanyaan ditolak oleh guardrail")
-ENABLE_PROFILING = os.environ.get("ENABLE_PROFILING", "false").lower() == "true"
+TOP_K_FAISS = 24
+TOP_K_FINAL = 10
+MIN_COSINE  = 0.84
+MIN_HYBRID  = 0.15
+
+FALLBACK_TEXT        = "maap pengetahuan tidak ada dalam database"
+GUARDRAIL_BLOCK_TEXT = "maap, pertanyaan ditolak oleh guardrail"
+ENABLE_PROFILING     = False
 
 # ========= APP =========
 app = Flask(__name__)
 app.secret_key = os.environ.get("FLASK_SECRET_KEY", "dev-secret-please-change")
 
 from werkzeug.middleware.proxy_fix import ProxyFix
+
 app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1)
 # supaya session tersimpan di browser saat lewat proxy/HTTPS (HF Spaces)
 app.config.update(
@@ -107,10 +93,11 @@ app.config.update(
     PREFERRED_URL_SCHEME="https",
 )
 
+
 # ========= GLOBAL MODEL =========
 ENCODER_TOKENIZER = None
-ENCODER_MODEL     = None
-LLM               = None
+ENCODER_MODEL = None
+LLM = None
 
 @dataclass(frozen=True)
 class SubjectAssets:
@@ -125,14 +112,11 @@ STOPWORDS_ID = {
     "agar","sehingga","terhadap","dapat","juga","para","diri",
 }
 TOKEN_RE = re.compile(r"[A-Za-zÀ-ÖØ-öø-ÿ]+", re.UNICODE)
-
 def tok_id(text: str) -> List[str]:
     return [t.lower() for t in TOKEN_RE.findall(text or "") if t.lower() not in STOPWORDS_ID]
-
 def lexical_overlap(query: str, sent: str) -> float:
     q = set(tok_id(query)); s = set(tok_id(sent))
-    if not q or not s:
-        return 0.0
+    if not q or not s: return 0.0
     return len(q & s) / max(1, len(q | s))
 
 QUESTION_LIKE_RE = re.compile(r"(^\s*(apa|mengapa|bagaimana|sebutkan|jelaskan)\b|[?]$)", re.IGNORECASE)
@@ -151,8 +135,7 @@ def clean_prefix(t: str) -> str:
     t = (t or "").strip()
     for _ in range(5):
         t2 = META_PREFIX_RE.sub("", t).lstrip()
-        if t2 == t:
-            break
+        if t2 == t: break
         t = t2
     return t
 
@@ -160,30 +143,23 @@ def strip_meta_sentence(s: str) -> str:
     s = clean_prefix(s or "")
     if re.match(r"^\s*(berdasarkan|menurut|merujuk|mengacu|bersumber|dari)\b", s, re.IGNORECASE):
         s = re.sub(r"^\s*[^,.;!?]*[,.;!?]\s*", "", s) or s
-    s = clean_prefix(s)
+        s = clean_prefix(s)
     return s.strip()
 
 SENT_SPLIT_RE = re.compile(r"(?<=[.!?])\s+")
-
 def split_sentences(text: str) -> List[str]:
     outs = []
     for p in SENT_SPLIT_RE.split(text or ""):
         s = clean_prefix((p or "").strip())
-        if not s:
-            continue
-        if s[-1] not in ".!?":
-            s += "."
-        if QUESTION_LIKE_RE.search(s):
-            continue
-        if INSTRUCTION_RE.search(s):
-            continue
-        if len(s.strip()) < 10:
-            continue
+        if not s: continue
+        if s[-1] not in ".!?": s += "."
+        if QUESTION_LIKE_RE.search(s):  continue
+        if INSTRUCTION_RE.search(s):    continue
+        if len(s.strip()) < 10:         continue
         outs.append(s)
     return outs
 
 # ========= MODEL WARMUP (LAZY) =========
-
 def warmup_models():
     global ENCODER_TOKENIZER, ENCODER_MODEL, LLM
     if ENCODER_TOKENIZER is None or ENCODER_MODEL is None:
@@ -195,34 +171,30 @@ def warmup_models():
         LLM = load_model(MODEL_PATH, n_ctx=CTX_WINDOW, n_gpu_layers=N_GPU_LAYERS, n_threads=N_THREADS)
 
 # ========= LOAD ASSETS PER-MAPEL =========
-
 @lru_cache(maxsize=8)
 def load_subject_assets(subject_key: str) -> SubjectAssets:
     if subject_key not in SUBJECTS:
         raise ValueError(f"Unknown subject: {subject_key}")
     cfg = SUBJECTS[subject_key]
     log.info(f"[ASSETS] Loading subject={subject_key} | index={cfg['index']}")
-    if not os.path.exists(cfg["index"]):
-        raise FileNotFoundError(cfg["index"])
-    if not os.path.exists(cfg["chunks"]):
-        raise FileNotFoundError(cfg["chunks"])
-    if not os.path.exists(cfg["embeddings"]):
-        raise FileNotFoundError(cfg["embeddings"])
+    if not os.path.exists(cfg["index"]): raise FileNotFoundError(cfg["index"])
+    if not os.path.exists(cfg["chunks"]): raise FileNotFoundError(cfg["chunks"])
+    if not os.path.exists(cfg["embeddings"]): raise FileNotFoundError(cfg["embeddings"])
+
     index = faiss.read_index(cfg["index"])
     with open(cfg["chunks"], "r", encoding="utf-8") as f:
         texts = [it["text"] for it in json.load(f)]
-    embs = np.load(cfg["embeddings"])  # shape: (N, dim)
+    embs = np.load(cfg["embeddings"])
     if index.ntotal != len(embs):
         raise RuntimeError(f"Mismatch ntotal({index.ntotal}) vs emb({len(embs)})")
+
     return SubjectAssets(index=index, texts=texts, embs=embs)
 
 # ========= ENCODER & RETRIEVAL =========
-
 @torch.inference_mode()
 def encode_query_exact(text: str) -> np.ndarray:
     toks = ENCODER_TOKENIZER(text, padding=True, truncation=True, return_tensors="pt").to(ENCODER_DEVICE)
     out = ENCODER_MODEL(**toks)
-    # simple mean pooling (CLS-less encoders)
     vec = out.last_hidden_state.mean(dim=1)
     return vec.cpu().numpy()
 
@@ -256,8 +228,7 @@ def retrieve_rerank_cosine(query: str, subject_key: str) -> List[str]:
     return top_texts
 
 def pick_best_sentences(query: str, chunks: List[str], top_k: int = 5) -> List[str]:
-    if not chunks:
-        return []
+    if not chunks: return []
     qv = encode_query_exact(query).reshape(-1)
     cands: List[Tuple[float, str]] = []
     for ch in chunks:
@@ -275,20 +246,18 @@ def pick_best_sentences(query: str, chunks: List[str], top_k: int = 5) -> List[s
 def build_prompt(user_query: str, sentences: List[str]) -> str:
     block = "\n".join(f"- {clean_prefix(s)}" for s in sentences)
     system = (
-        "Kamu asisten RAG.\n"
-        "- Jawab HANYA berdasarkan daftar kalimat fakta di bawah.\n"
-        f"- Jika tidak ada kalimat yang relevan, tulis persis: {FALLBACK_TEXT}\n"
+        "- Gunakan HANYA daftar kalimat fakta berikut sebagai sumber.\n"
+        "- Jika tidak ada kalimat yang menjawab, balas: maap pengetahuan tidak ada dalam database\n"
         "- Jawab TEPAT 1 kalimat, ringkas, Bahasa Indonesia baku.\n"
-        "- DILARANG menulis frasa meta seperti 'berdasarkan', 'menurut', 'merujuk', 'mengacu', atau 'bersumber'.\n"
-        "- Tulis jawaban final di dalam tag <final>... seperti: <final>Jawaban satu kalimat.</final>\n"
-        "- Jangan menulis apa pun setelah </final>."
-    )
-    return (
-        f"{system}\n\n"
-        f"KALIMAT SUMBER:\n{block}\n\n"
-        f"PERTANYAAN: {user_query}\n"
-        f"TULIS JAWABAN DI DALAM <final>...</final> SAJA:"
+        "- DILARANG menulis frasa meta seperti 'berdasarkan', 'menurut', 'merujuk', atau 'bersumber'."
     )
+    return f"""{system}
+KALIMAT SUMBER:
+{block}
+PERTANYAAN:
+{user_query}
+JAWAB (1 kalimat saja):
+"""
 
 @lru_cache(maxsize=512)
 def validate_input_cached(q: str) -> bool:
@@ -301,7 +270,7 @@ def validate_input_cached(q: str) -> bool:
 # ========= AUTH (POSTGRES) =========
 from werkzeug.security import generate_password_hash, check_password_hash
 from sqlalchemy import create_engine, Column, Integer, String, Text, Boolean, func, or_
-from sqlalchemy.orm import sessionmaker, scoped_session, declarative_base, Session
+from sqlalchemy.orm import sessionmaker, scoped_session, declarative_base
 
 POSTGRES_URL = os.environ.get("POSTGRES_URL")
 if not POSTGRES_URL:
@@ -313,26 +282,25 @@ Base = declarative_base()
 
 class User(Base):
     __tablename__ = "users"
-    id = Column(Integer, primary_key=True)
-    username = Column(String(50), unique=True, nullable=False, index=True)
-    email = Column(String(120), unique=True, nullable=False, index=True)
-    password = Column(Text, nullable=False)
+    id        = Column(Integer, primary_key=True)
+    username  = Column(String(50), unique=True, nullable=False, index=True)
+    email     = Column(String(120), unique=True, nullable=False, index=True)
+    password  = Column(Text, nullable=False)
     is_active = Column(Boolean, default=True, nullable=False)
     is_admin  = Column(Boolean, default=False, nullable=False)
 
 class ChatHistory(Base):
     __tablename__ = "chat_history"
-    id = Column(Integer, primary_key=True)
-    user_id = Column(Integer, nullable=False, index=True)
+    id          = Column(Integer, primary_key=True)
+    user_id     = Column(Integer, nullable=False, index=True)
     subject_key = Column(String(50), nullable=False, index=True)
-    role = Column(String(10), nullable=False)
-    message = Column(Text, nullable=False)
-    timestamp = Column(Integer, server_default=func.extract("epoch", func.now()))
+    role        = Column(String(10), nullable=False)
+    message     = Column(Text, nullable=False)
+    timestamp   = Column(Integer, server_default=func.extract("epoch", func.now()))
 
 Base.metadata.create_all(bind=engine)
 
 JKT_TZ = ZoneInfo("Asia/Jakarta")
-
 @app.template_filter("fmt_ts")
 def fmt_ts(epoch_int: int):
     try:
@@ -345,15 +313,14 @@ def db():
     return SessionLocal()
 
 def login_required(view_func):
-    @wraps(view_func)
     def wrapper(*args, **kwargs):
         if not session.get("logged_in"):
             return redirect(url_for("auth_login"))
         return view_func(*args, **kwargs)
+    wrapper.__name__ = view_func.__name__
     return wrapper
 
 def admin_required(view_func):
-    @wraps(view_func)
     def wrapper(*args, **kwargs):
         if not session.get("logged_in"):
             return redirect(url_for("auth_login"))
@@ -361,8 +328,10 @@ def admin_required(view_func):
             flash("Hanya admin yang boleh mengakses halaman itu.", "error")
             return redirect(url_for("subjects"))
         return view_func(*args, **kwargs)
+    wrapper.__name__ = view_func.__name__
     return wrapper
 
+
 # ========= ROUTES =========
 @app.route("/")
 def root():
@@ -372,7 +341,10 @@ def root():
 def auth_login():
     if request.method == "POST":
         identity = (
-            request.form.get("identity") or request.form.get("email") or request.form.get("username") or ""
+            request.form.get("identity")
+            or request.form.get("email")
+            or request.form.get("username")
+            or ""
         ).strip().lower()
         pw_input = (request.form.get("password") or "").strip()
 
@@ -384,8 +356,9 @@ def auth_login():
         try:
             user = (
                 s.query(User)
-                .filter(or_(func.lower(User.username) == identity, func.lower(User.email) == identity))
-                .first()
+                 .filter(or_(func.lower(User.username) == identity,
+                             func.lower(User.email) == identity))
+                 .first()
             )
             log.info(f"[LOGIN] identity='{identity}' found={bool(user)} active={getattr(user,'is_active',None)}")
             ok = bool(user and user.is_active and check_password_hash(user.password, pw_input))
@@ -397,12 +370,11 @@ def auth_login():
             return render_template("login.html"), 401
 
         session["logged_in"] = True
-        session["user_id"] = user.id
-        session["username"] = user.username
-        session["is_admin"] = bool(user.is_admin)
+        session["user_id"]   = user.id
+        session["username"]  = user.username
+        session["is_admin"]  = bool(user.is_admin)
         log.info(f"[LOGIN] OK user_id={user.id}; session set.")
         return redirect(url_for("subjects"))
-
     return render_template("login.html")
 
 @app.route("/whoami")
@@ -414,6 +386,7 @@ def whoami():
         "is_admin": session.get("is_admin"),
     }
 
+
 @app.route("/auth/register", methods=["GET", "POST"])
 def auth_register():
     if request.method == "POST":
@@ -421,7 +394,6 @@ def auth_register():
         email    = (request.form.get("email") or "").strip().lower()
         pw       = (request.form.get("password") or "").strip()
         confirm  = (request.form.get("confirm") or "").strip()
-
         if not username or not email or not pw:
             flash("Semua field wajib diisi.", "error")
             return render_template("register.html"), 400
@@ -431,13 +403,13 @@ def auth_register():
         if pw != confirm:
             flash("Konfirmasi password tidak cocok.", "error")
             return render_template("register.html"), 400
-
         s = db()
         try:
             existed = (
                 s.query(User)
-                .filter(or_(func.lower(User.username) == username, func.lower(User.email) == email))
-                .first()
+                 .filter(or_(func.lower(User.username) == username,
+                             func.lower(User.email) == email))
+                 .first()
             )
             if existed:
                 flash("Username/Email sudah terpakai.", "error")
@@ -446,10 +418,8 @@ def auth_register():
             s.add(u); s.commit()
         finally:
             s.close()
-
         flash("Registrasi berhasil. Silakan login.", "success")
         return redirect(url_for("auth_login"))
-
     return render_template("register.html")
 
 @app.route("/auth/logout")
@@ -461,12 +431,14 @@ def auth_logout():
 def about():
     return render_template("about.html")
 
+
 @app.route("/subjects")
 @login_required
 def subjects():
     log.info(f"[SESSION DEBUG] logged_in={session.get('logged_in')} user_id={session.get('user_id')}")
     return render_template("home.html", subjects=SUBJECTS)
 
+
 @app.route("/chat/<subject_key>")
 @login_required
 def chat_subject(subject_key: str):
@@ -480,9 +452,9 @@ def chat_subject(subject_key: str):
         uid = session.get("user_id")
         rows = (
             s.query(ChatHistory)
-            .filter_by(user_id=uid, subject_key=subject_key)
-            .order_by(ChatHistory.id.asc())
-            .all()
+             .filter_by(user_id=uid, subject_key=subject_key)
+             .order_by(ChatHistory.id.asc())
+             .all()
         )
         history = [{"role": r.role, "message": r.message} for r in rows]
     finally:
@@ -492,13 +464,7 @@ def chat_subject(subject_key: str):
 
 @app.route("/health")
 def health():
-    return jsonify({
-        "ok": True,
-        "encoder_loaded": ENCODER_MODEL is not None,
-        "llm_loaded": LLM is not None,
-        "model_path": MODEL_PATH,
-        "ctx_window": CTX_WINDOW,
-    })
+    return jsonify({"ok": True, "encoder_loaded": ENCODER_MODEL is not None, "llm_loaded": LLM is not None})
 
 @app.route("/ask/<subject_key>", methods=["POST"])
 @login_required
@@ -508,13 +474,13 @@ def ask(subject_key: str):
 
     # pastikan model siap saat request (lazy)
     warmup_models()
-    t0 = time.perf_counter()
 
-    data = request.get_json(silent=True) or {}
+    t0 = time.perf_counter()
+    data  = request.get_json(silent=True) or {}
     query = (data.get("message") or "").strip()
+
     if not query:
         return jsonify({"ok": False, "error": "empty query"}), 400
-
     if not validate_input_cached(query):
         return jsonify({"ok": True, "answer": GUARDRAIL_BLOCK_TEXT})
 
@@ -532,7 +498,6 @@ def ask(subject_key: str):
     chunks = retrieve_rerank_cosine(query, subject_key)
     if not chunks:
         return jsonify({"ok": True, "answer": FALLBACK_TEXT})
-
     sentences = pick_best_sentences(query, chunks, top_k=5)
     if not sentences:
         return jsonify({"ok": True, "answer": FALLBACK_TEXT})
@@ -540,38 +505,17 @@ def ask(subject_key: str):
     prompt = build_prompt(query, sentences)
 
     try:
-        raw_answer = generate(
-            LLM,
-            prompt,
-            max_tokens=int(os.environ.get("MAX_TOKENS", 64)),
-            temperature=float(os.environ.get("TEMP", 0.0)),  # deterministik
-            top_p=1.0,
-            stop=["</final>"]  # hentikan persis saat final ditutup
-        )
-        if raw_answer is None:
-            raw_answer = ""
-        raw_answer = raw_answer.strip()
-        log.info(f"[LLM] Raw answer repr: {repr(raw_answer)}")
-
-        # 1) Buang blok <think>...</think> kalau ada
-        text = re.sub(r"<think\b[^>]*>.*?</think>", "", raw_answer, flags=re.DOTALL | re.IGNORECASE).strip()
-        text = re.sub(r"</?think\b[^>]*>", "", text, flags=re.IGNORECASE).strip()
-
-        # 2) Ambil isi setelah <final> (kita stop di </final>, jadi biasanya tidak ada penutup di output)
-        m_final = re.search(r"<final>\s*(.+)$", text, flags=re.IGNORECASE | re.DOTALL)
-        if m_final:
-            cleaned = m_final.group(1).strip()
-        else:
-            # fallback: kalau model tidak menulis <final>, pakai sisa teks non-tag
-            cleaned = re.sub(r"<[^>]+>", "", text).strip()
-
-        answer = cleaned
-
+        answer = generate(
+            LLM, prompt,
+            max_tokens=64, temperature=0.2, top_p=1.0,
+            stop=["\n\n", "\n###", "###", "\nUser:",
+                  "Berdasarkan", "berdasarkan", "Menurut", "menurut",
+                  "Merujuk", "merujuk", "Mengacu", "mengacu", "Bersumber", "bersumber"]
+        ).strip()
     except Exception as e:
         log.exception(f"[LLM] generate error: {e}")
         return jsonify({"ok": True, "answer": FALLBACK_TEXT})
 
-    # Ambil 1 kalimat pertama (jika model mengeluarkan beberapa kalimat)
     m = re.search(r"(.+?[.!?])(\s|$)", answer)
     answer = (m.group(1) if m else answer).strip()
     answer = strip_meta_sentence(answer)
@@ -582,49 +526,40 @@ def ask(subject_key: str):
         uid = session.get("user_id")
         s.add_all([
             ChatHistory(user_id=uid, subject_key=subject_key, role="user", message=query),
-            ChatHistory(user_id=uid, subject_key=subject_key, role="bot",  message=answer),
+            ChatHistory(user_id=uid, subject_key=subject_key, role="bot", message=answer)
         ])
         s.commit()
     except Exception as e:
         log.exception(f"[DB] gagal simpan chat history: {e}")
     finally:
-        try:
-            s.close()
-        except Exception:
-            pass
+        s.close()
 
     if not answer or len(answer) < 2:
         answer = FALLBACK_TEXT
 
     if ENABLE_PROFILING:
-        log.info({
-            "latency_total": time.perf_counter() - t0,
-            "subject": subject_key,
-            "faiss_best": best,
-        })
+        log.info({"latency_total": time.perf_counter() - t0, "subject": subject_key, "faiss_best": best})
 
     return jsonify({"ok": True, "answer": answer})
 
 # ===== Admin views & delete actions (tetap) =====
-
+from sqlalchemy.orm import Session
 @app.route("/admin")
 @admin_required
 def admin_dashboard():
     s = db()
     try:
-        total_users  = s.query(func.count(User.id)).scalar() or 0
-        total_active = s.query(func.count(User.id)).filter(User.is_active.is_(True)).scalar() or 0
-        total_admins = s.query(func.count(User.id)).filter(User.is_admin.is_(True)).scalar() or 0
-        total_msgs   = s.query(func.count(ChatHistory.id)).scalar() or 0
+        total_users   = s.query(func.count(User.id)).scalar() or 0
+        total_active  = s.query(func.count(User.id)).filter(User.is_active.is_(True)).scalar() or 0
+        total_admins  = s.query(func.count(User.id)).filter(User.is_admin.is_(True)).scalar() or 0
+        total_msgs    = s.query(func.count(ChatHistory.id)).scalar() or 0
     finally:
         s.close()
-    return render_template(
-        "admin_dashboard.html",
-        total_users=total_users,
-        total_active=total_active,
-        total_admins=total_admins,
-        total_msgs=total_msgs,
-    )
+    return render_template("admin_dashboard.html",
+                           total_users=total_users,
+                           total_active=total_active,
+                           total_admins=total_admins,
+                           total_msgs=total_msgs)
 
 @app.route("/admin/users")
 @admin_required
@@ -632,46 +567,40 @@ def admin_users():
     q = (request.args.get("q") or "").strip().lower()
     page = max(int(request.args.get("page", 1)), 1)
     per_page = min(max(int(request.args.get("per_page", 20)), 5), 100)
-
     s = db()
     try:
         base = s.query(User)
         if q:
-            base = base.filter(
-                or_(
-                    func.lower(User.username).like(f"%{q}%"),
-                    func.lower(User.email).like(f"%{q}%"),
-                )
-            )
+            base = base.filter(or_(
+                func.lower(User.username).like(f"%{q}%"),
+                func.lower(User.email).like(f"%{q}%")
+            ))
         total = base.count()
-        users = (
-            base.order_by(User.id.asc())
-                .offset((page - 1) * per_page)
-                .limit(per_page)
-                .all()
-        )
+        users = (base
+                 .order_by(User.id.asc())
+                 .offset((page - 1) * per_page)
+                 .limit(per_page)
+                 .all())
         user_ids = [u.id for u in users] or [-1]
-        counts = dict(
-            s.query(ChatHistory.user_id, func.count(ChatHistory.id))
-             .filter(ChatHistory.user_id.in_(user_ids))
-             .group_by(ChatHistory.user_id)
-             .all()
-        )
+        counts = dict(s.query(ChatHistory.user_id, func.count(ChatHistory.id))
+                        .filter(ChatHistory.user_id.in_(user_ids))
+                        .group_by(ChatHistory.user_id)
+                        .all())
     finally:
         s.close()
-
-    return render_template("admin_users.html", users=users, counts=counts, q=q, page=page, per_page=per_page, total=total)
+    return render_template("admin_users.html",
+                           users=users, counts=counts,
+                           q=q, page=page, per_page=per_page, total=total)
 
 @app.route("/admin/history")
 @admin_required
 def admin_history():
-    q        = (request.args.get("q") or "").strip().lower()
-    username = (request.args.get("username") or "").strip().lower()
-    subject  = (request.args.get("subject") or "").strip().lower()
-    role     = (request.args.get("role") or "").strip().lower()
-
-    page = max(int(request.args.get("page", 1)), 1)
-    per_page = min(max(int(request.args.get("per_page", 30)), 5), 200)
+    q          = (request.args.get("q") or "").strip().lower()
+    username   = (request.args.get("username") or "").strip().lower()
+    subject    = (request.args.get("subject") or "").strip().lower()
+    role       = (request.args.get("role") or "").strip().lower()
+    page       = max(int(request.args.get("page", 1)), 1)
+    per_page   = min(max(int(request.args.get("per_page", 30)), 5), 200)
 
     s = db()
     try:
@@ -679,24 +608,19 @@ def admin_history():
         if q:
             base = base.filter(func.lower(ChatHistory.message).like(f"%{q}%"))
         if username:
-            base = base.filter(
-                or_(
-                    func.lower(User.username) == username,
-                    func.lower(User.email) == username,
-                )
-            )
+            base = base.filter(or_(
+                func.lower(User.username) == username,
+                func.lower(User.email) == username
+            ))
         if subject:
             base = base.filter(func.lower(ChatHistory.subject_key) == subject)
         if role in ("user", "bot"):
             base = base.filter(ChatHistory.role == role)
-
         total = base.count()
-        rows = (
-            base.order_by(ChatHistory.id.desc())
+        rows = (base.order_by(ChatHistory.id.desc())
                 .offset((page - 1) * per_page)
                 .limit(per_page)
-                .all()
-        )
+                .all())
     finally:
         s.close()
 
@@ -710,19 +634,10 @@ def admin_history():
         "timestamp": r.ChatHistory.timestamp,
     } for r in rows]
 
-    return render_template(
-        "admin_history.html",
-        items=items,
-        subjects=SUBJECTS,
-        q=q,
-        username=username,
-        subject=subject,
-        role=role,
-        page=page,
-        per_page=per_page,
-        total=total,
-    )
-
+    return render_template("admin_history.html",
+                           items=items, subjects=SUBJECTS,
+                           q=q, username=username, subject=subject, role=role,
+                           page=page, per_page=per_page, total=total)
 
 def _is_last_admin(s: Session) -> bool:
     return (s.query(func.count(User.id)).filter(User.is_admin.is_(True)).scalar() or 0) <= 1
@@ -793,4 +708,4 @@ def admin_delete_chat(chat_id: int):
 # ========= ENTRY =========
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 7860))
-    app.run(host="0.0.0.0", port=port, debug=False)
+    app.run(host="0.0.0.0", port=port, debug=False)