test

app.py

@@ -1,10 +1,8 @@
-# app.py (HF Spaces CPU-Optimized)
-# RAG sekolah super hemat CPU:
-# - Default model: 3B instruct (GGUF) + ctx 1024
-# - Retrieval cepat: FAISS top-12 → pilih kalimat pakai lexical overlap (tanpa encode per-kalimat)
-# - Encoder dipakai HANYA untuk query & FAISS (1x per request)
-# - Jawaban final lewat <final>...</final>, stop di </final>, retry kalau kosong/ellipsis
-# - Admin + Auth Postgres tetap sama
+# 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
 
 import os, json, re, time, logging
 from functools import lru_cache, wraps
@@ -29,8 +27,9 @@ 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", "3")))  # 3 thread cukup di CPU Spaces
+    torch.set_num_threads(int(os.environ.get("NUM_THREADS", "4")))
     torch.set_num_interop_threads(1)
 except Exception:
     pass
@@ -38,24 +37,27 @@ except Exception:
 logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
 log = logging.getLogger("rag-app")
 
-# ========= IMPORT EKSTERNAL (wrapper & guardrail) =========
-from Guardrail import validate_input           # -> bool
+# ========= 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 Model import load_model, generate         # -> llama.cpp wrapper
 
-# ========= PATH ROOT =========
+# ========= PATH ROOT PROYEK =========
 BASE_DIR = Path(__file__).resolve().parent
 
-# ========= KONFIG MODEL & RAG (di-tune untuk CPU) =========
-GGUF_DEFAULT = "DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf"  # kecil & cepat; upload ke /models
-MODEL_PATH   = str(BASE_DIR / "models" / os.getenv("GGUF_FILENAME", GGUF_DEFAULT))
-CTX_WINDOW   = int(os.environ.get("CTX_WINDOW", 1024))
-N_GPU_LAYERS = int(os.environ.get("N_GPU_LAYERS", 0))
-N_THREADS    = int(os.environ.get("NUM_THREADS", 3))
+# ========= 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))
 
+# 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_DEVICE = torch.device("cpu")
 
-# Dataset sudah ada di Space → path RELATIF (samakan dengan struktur kamu)
+# 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"),
@@ -80,11 +82,11 @@ SUBJECTS: Dict[str, Dict[str, str]] = {
     }
 }
 
-# Threshold & parameter cepat
-TOP_K_FAISS   = int(os.environ.get("TOP_K_FAISS", 12))
-TOP_K_FINAL   = int(os.environ.get("TOP_K_FINAL", 6))
-MIN_COSINE    = float(os.environ.get("MIN_COSINE", 0.80))  # lebih longgar biar jarang fallback
-MIN_LEXICAL   = float(os.environ.get("MIN_LEXICAL", 0.10))
+# 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"
@@ -95,6 +97,7 @@ 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(
     SESSION_COOKIE_NAME="session",
     SESSION_COOKIE_SAMESITE="None",
@@ -104,7 +107,7 @@ app.config.update(
     PREFERRED_URL_SCHEME="https",
 )
 
-# ========= GLOBALS =========
+# ========= GLOBAL MODEL =========
 ENCODER_TOKENIZER = None
 ENCODER_MODEL     = None
 LLM               = None
@@ -115,7 +118,7 @@ class SubjectAssets:
     texts: List[str]
     embs: np.ndarray
 
-# ========= TEKS UTIL =========
+# ========= TEKS UTILITAS =========
 STOPWORDS_ID = {
     "yang","dan","atau","pada","di","ke","dari","itu","ini","adalah","dengan",
     "untuk","serta","sebagai","oleh","dalam","akan","kamu","apa","karena",
@@ -123,12 +126,8 @@ STOPWORDS_ID = {
 }
 TOKEN_RE = re.compile(r"[A-Za-zÀ-ÖØ-öø-ÿ]+", re.UNICODE)
 
-@lru_cache(maxsize=4096)
-def _tok_cached(word: str) -> str:
-    return word.lower()
-
 def tok_id(text: str) -> List[str]:
-    return [tw for w in TOKEN_RE.findall(text or "") if (tw:=_tok_cached(w)) not in STOPWORDS_ID]
+    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))
@@ -150,7 +149,7 @@ META_PREFIX_RE = re.compile(r"^\s*(?:" + r"|".join(META_PREFIX_PATTERNS) + r")\s
 
 def clean_prefix(t: str) -> str:
     t = (t or "").strip()
-    for _ in range(3):
+    for _ in range(5):
         t2 = META_PREFIX_RE.sub("", t).lstrip()
         if t2 == t:
             break
@@ -166,8 +165,7 @@ def strip_meta_sentence(s: str) -> str:
 
 SENT_SPLIT_RE = re.compile(r"(?<=[.!?])\s+")
 
-def split_sentences_fast(text: str) -> List[str]:
-    # tanpa encoding per-kalimat
+def split_sentences(text: str) -> List[str]:
     outs = []
     for p in SENT_SPLIT_RE.split(text or ""):
         s = clean_prefix((p or "").strip())
@@ -179,12 +177,12 @@ def split_sentences_fast(text: str) -> List[str]:
             continue
         if INSTRUCTION_RE.search(s):
             continue
-        if len(s) < 12:
+        if len(s.strip()) < 10:
             continue
         outs.append(s)
     return outs
 
-# ========= MODEL WARMUP =========
+# ========= MODEL WARMUP (LAZY) =========
 
 def warmup_models():
     global ENCODER_TOKENIZER, ENCODER_MODEL, LLM
@@ -193,13 +191,13 @@ def warmup_models():
         ENCODER_TOKENIZER = AutoTokenizer.from_pretrained(ENCODER_NAME)
         ENCODER_MODEL = AutoModel.from_pretrained(ENCODER_NAME).to(ENCODER_DEVICE).eval()
     if LLM is None:
-        log.info(f"[INIT] Load LLM: {MODEL_PATH} | ctx={CTX_WINDOW} | threads={N_THREADS}")
+        log.info(f"[INIT] Load LLM: {MODEL_PATH}")
         LLM = load_model(MODEL_PATH, n_ctx=CTX_WINDOW, n_gpu_layers=N_GPU_LAYERS, n_threads=N_THREADS)
 
-# ========= ASSETS =========
+# ========= LOAD ASSETS PER-MAPEL =========
 
 @lru_cache(maxsize=8)
-def load_subject_assets(subject_key: str) -> "SubjectAssets":
+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]
@@ -212,28 +210,25 @@ def load_subject_assets(subject_key: str) -> "SubjectAssets":
         raise FileNotFoundError(cfg["embeddings"])
     index = faiss.read_index(cfg["index"])
     with open(cfg["chunks"], "r", encoding="utf-8") as f:
-        texts = [it.get("text", "") for it in json.load(f)]
-    embs = np.load(cfg["embeddings"])  # (N, dim)
+        texts = [it["text"] for it in json.load(f)]
+    embs = np.load(cfg["embeddings"])  # shape: (N, dim)
     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 =========
+# ========= ENCODER & RETRIEVAL =========
 
 @torch.inference_mode()
-@lru_cache(maxsize=1024)
 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()
 
 def cosine_sim(a: np.ndarray, b: np.ndarray) -> float:
     a = np.asarray(a).reshape(-1); b = np.asarray(b).reshape(-1)
-    denom = (np.linalg.norm(a) * np.linalg.norm(b)) + 1e-12
-    return float(np.dot(a, b) / denom)
-
-# ========= RETRIEVAL CEPAT =========
+    return float(np.dot(a, b) / ((np.linalg.norm(a) * np.linalg.norm(b)) + 1e-12))
 
 def best_cosine_from_faiss(query: str, subject_key: str) -> float:
     assets = load_subject_assets(subject_key)
@@ -246,54 +241,56 @@ def best_cosine_from_faiss(query: str, subject_key: str) -> float:
             best = max(best, cosine_sim(qv, assets.embs[i]))
     return best
 
-def retrieve_top_chunks(query: str, subject_key: str) -> List[str]:
+def retrieve_rerank_cosine(query: str, subject_key: str) -> List[str]:
     assets = load_subject_assets(subject_key)
     q = encode_query_exact(query)
-    _, idx = assets.index.search(q, TOP_K_FAISS)
+    D, idx = assets.index.search(q, TOP_K_FAISS)
     idxs = [i for i in idx[0] if 0 <= i < len(assets.texts)]
-    return [assets.texts[i] for i in idxs[:TOP_K_FINAL]]
+    if not idxs:
+        return []
+    qv = q.reshape(-1)
+    scores = [cosine_sim(qv, assets.embs[i]) for i in idxs]
+    pairs = sorted(zip(scores, idxs), reverse=True)
+    top_texts = [assets.texts[i] for _, i in pairs[:TOP_K_FINAL]]
+    log.info(f"[RETRIEVE] subject={subject_key} | top={len(top_texts)}")
+    return top_texts
 
-def pick_best_sentences_fast(query: str, chunks: List[str], top_k: int = 4) -> List[str]:
-    # Tanpa encode per kalimat — hanya lexical overlap + panjang wajar
+def pick_best_sentences(query: str, chunks: List[str], top_k: int = 5) -> List[str]:
+    if not chunks:
+        return []
+    qv = encode_query_exact(query).reshape(-1)
     cands: List[Tuple[float, str]] = []
     for ch in chunks:
-        for s in split_sentences_fast(ch):
+        for s in split_sentences(ch):
+            sv = encode_query_exact(s).reshape(-1)
+            cos = cosine_sim(qv, sv)
             ovl = lexical_overlap(query, s)
-            if ovl < MIN_LEXICAL:
-                continue
-            # bonus sedikit kalau kalimat panjang wajar (50–220 char)
-            L = len(s)
-            len_bonus = 0.05 if 50 <= L <= 220 else 0.0
-            score = ovl + len_bonus
-            cands.append((score, s))
+            penalty = 0.1 if len(s) < 50 else 0.0
+            score = 0.7 * cos + 0.3 * ovl - penalty
+            if score >= MIN_HYBRID:
+                cands.append((score, s))
     cands.sort(key=lambda x: x[0], reverse=True)
     return [s for _, s in cands[:top_k]]
 
-# ========= PROMPT =========
-
 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"
-        "- Jawab TEPAT 1 kalimat, ringkas, Bahasa Indonesia baku (≥ 6 kata).\n"
-        "- Tanpa frasa meta (berdasarkan/menurut/merujuk/mengacu/bersumber).\n"
-        "- Tulis jawaban final di dalam tag <final>Jawaban.</final> dan jangan menulis apa pun setelah </final>."
-    )
-    fewshot = (
-        "Contoh format: \n"
-        "KALIMAT SUMBER:\n- Air memuai saat dipanaskan.\n"
-        "PERTANYAAN: Apa yang terjadi pada air saat dipanaskan?\n"
-        "<final>Air akan memuai ketika dipanaskan.</final>\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{fewshot}\n"
+        f"{system}\n\n"
         f"KALIMAT SUMBER:\n{block}\n\n"
         f"PERTANYAAN: {user_query}\n"
         f"TULIS JAWABAN DI DALAM <final>...</final> SAJA:"
     )
 
-@lru_cache(maxsize=1024)
+@lru_cache(maxsize=512)
 def validate_input_cached(q: str) -> bool:
     try:
         return validate_input(q)
@@ -378,9 +375,11 @@ def auth_login():
             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()
+
         if not identity or not pw_input:
             flash("Mohon isi email/username dan password.", "error")
             return render_template("login.html"), 400
+
         s = db()
         try:
             user = (
@@ -392,15 +391,18 @@ def auth_login():
             ok = bool(user and user.is_active and check_password_hash(user.password, pw_input))
         finally:
             s.close()
+
         if not ok:
             flash("Identitas atau password salah.", "error")
             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)
         log.info(f"[LOGIN] OK user_id={user.id}; session set.")
         return redirect(url_for("subjects"))
+
     return render_template("login.html")
 
 @app.route("/whoami")
@@ -419,6 +421,7 @@ 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
@@ -428,6 +431,7 @@ def auth_register():
         if pw != confirm:
             flash("Konfirmasi password tidak cocok.", "error")
             return render_template("register.html"), 400
+
         s = db()
         try:
             existed = (
@@ -442,8 +446,10 @@ 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")
@@ -468,6 +474,7 @@ def chat_subject(subject_key: str):
         return redirect(url_for("subjects"))
     session["subject_selected"] = subject_key
     label = SUBJECTS[subject_key]["label"]
+
     s = db()
     try:
         uid = session.get("user_id")
@@ -480,6 +487,7 @@ def chat_subject(subject_key: str):
         history = [{"role": r.role, "message": r.message} for r in rows]
     finally:
         s.close()
+
     return render_template("chat.html", subject=subject_key, subject_label=label, history=history)
 
 @app.route("/health")
@@ -490,7 +498,6 @@ def health():
         "llm_loaded": LLM is not None,
         "model_path": MODEL_PATH,
         "ctx_window": CTX_WINDOW,
-        "threads": N_THREADS,
     })
 
 @app.route("/ask/<subject_key>", methods=["POST"])
@@ -498,6 +505,8 @@ def health():
 def ask(subject_key: str):
     if subject_key not in SUBJECTS:
         return jsonify({"ok": False, "error": "invalid subject"}), 400
+
+    # pastikan model siap saat request (lazy)
     warmup_models()
     t0 = time.perf_counter()
 
@@ -505,6 +514,7 @@ def ask(subject_key: str):
     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})
 
@@ -519,18 +529,18 @@ def ask(subject_key: str):
     if best < MIN_COSINE:
         return jsonify({"ok": True, "answer": FALLBACK_TEXT})
 
-    chunks = retrieve_top_chunks(query, subject_key)
+    chunks = retrieve_rerank_cosine(query, subject_key)
     if not chunks:
         return jsonify({"ok": True, "answer": FALLBACK_TEXT})
 
-    sentences = pick_best_sentences_fast(query, chunks, top_k=4)
+    sentences = pick_best_sentences(query, chunks, top_k=5)
     if not sentences:
         return jsonify({"ok": True, "answer": FALLBACK_TEXT})
 
     prompt = build_prompt(query, sentences)
 
     try:
-        # PASS-1: deterministik & singkat
+        # === 1st pass (deterministik) ===
         raw_answer = generate(
             LLM,
             prompt,
@@ -542,19 +552,38 @@ def ask(subject_key: str):
         raw_answer = raw_answer.strip()
         log.info(f"[LLM] Raw answer repr (pass1): {repr(raw_answer)}")
 
+        # Bersihkan blok <think> dan ambil isi <final>
         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()
         m_final = re.search(r"<final>\s*(.+)$", text, flags=re.IGNORECASE | re.DOTALL)
         cleaned = (m_final.group(1).strip() if m_final else re.sub(r"<[^>]+>", "", text).strip())
 
-        def _is_bad(s: str) -> bool:
-            s2 = s.strip()
-            return (len(re.sub(r"[^A-Za-zÀ-ÖØ-öø-ÿ]+", "", s2)) < 3) or (s2 in {"...", ".", "..", "…"}) or (len(s2.split()) < 6)
+        def _alpha_tokens(s: str) -> List[str]:
+            return re.findall(r"[A-Za-zÀ-ÖØ-öø-ÿ]+", s or "")
 
+        def _is_bad(s: str) -> bool:
+            s2 = (s or "").strip()
+            if not s2:
+                return True
+            # nolak placeholder/ellipsis saja
+            if s2 in {"...", ".", "..", "…"}:
+                return True
+            toks = _alpha_tokens(s2)
+            # cukup 4 token alfabetik untuk lolos (lebih toleran utk jawaban singkat)
+            if len(toks) >= 4:
+                return False
+            # pengecualian: fakta pendek dengan unit/istilah umum tetap lolos
+            if any(t.lower() in {"newton","n","kg","m","s"} for t in toks) and len(toks) >= 3:
+                return False
+            return True
+
+        # Retry hanya jika PASS-1 benar-benar buruk
         if _is_bad(cleaned):
             prompt_retry = (
                 prompt
-                + "\n\nULANGI DENGAN TAAT FORMAT: Tulis satu kalimat faktual tanpa placeholder/ellipsis, minimal 6 kata, mulai huruf kapital dan akhiri titik. Tulis hanya di dalam <final>...</final>."
+                + "
+
+ULANGI DENGAN TAAT FORMAT: Tulis satu kalimat faktual tanpa placeholder/ellipsis, mulai huruf kapital dan akhiri titik. Tulis hanya di dalam <final>...</final>."
             )
             raw_answer2 = generate(
                 LLM,
@@ -566,6 +595,7 @@ def ask(subject_key: str):
             ) or ""
             raw_answer2 = raw_answer2.strip()
             log.info(f"[LLM] Raw answer repr (pass2): {repr(raw_answer2)}")
+
             text2 = re.sub(r"<think\b[^>]*>.*?</think>", "", raw_answer2, flags=re.DOTALL | re.IGNORECASE).strip()
             text2 = re.sub(r"</?think\b[^>]*>", "", text2, flags=re.IGNORECASE).strip()
             m_final2 = re.search(r"<final>\s*(.+)$", text2, flags=re.IGNORECASE | re.DOTALL)
@@ -578,12 +608,12 @@ def ask(subject_key: str):
         log.exception(f"[LLM] generate error: {e}")
         return jsonify({"ok": True, "answer": FALLBACK_TEXT})
 
-    # Ambil 1 kalimat pertama saja
+    # 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)
 
-    # Simpan history
+    # === Simpan ke history ===
     try:
         s = db()
         uid = session.get("user_id")
@@ -612,7 +642,8 @@ def ask(subject_key: str):
 
     return jsonify({"ok": True, "answer": answer})
 
-# ===== Admin =====
+# ===== Admin views & delete actions (tetap) =====
+
 @app.route("/admin")
 @admin_required
 def admin_dashboard():
@@ -624,7 +655,13 @@ def admin_dashboard():
         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,17 +669,34 @@ 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)
 
 @app.route("/admin/history")
@@ -652,23 +706,37 @@ def admin_history():
     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:
         base = (s.query(ChatHistory, User).join(User, User.id == ChatHistory.user_id))
         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()).offset((page - 1) * per_page).limit(per_page).all()
+        rows = (
+            base.order_by(ChatHistory.id.desc())
+                .offset((page - 1) * per_page)
+                .limit(per_page)
+                .all()
+        )
     finally:
         s.close()
+
     items = [{
         "id": r.ChatHistory.id,
         "username": r.User.username,
@@ -678,7 +746,20 @@ def admin_history():
         "message": r.ChatHistory.message,
         "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