Upload 7 files

Guardrail.py

@@ -0,0 +1,35 @@
+# Guardrail.py
+import warnings
+warnings.filterwarnings("ignore")
+from functools import lru_cache
+
+from transformers import logging as hf_logging
+hf_logging.set_verbosity_error()
+from transformers import pipeline
+
+SAFE_LABELS   = ["pertanyaan sejarah", "pertanyaan olahraga", "pertanyaan alam"]
+UNSAFE_LABELS = ["kasar", "penghinaan", "berbahaya"]
+
+@lru_cache(maxsize=1)
+def _clf():
+    # device=-1 => CPU, model otomatis pakai cache dari prepare_assets.py
+    return pipeline("zero-shot-classification",
+                    model="joeddav/xlm-roberta-large-xnli",
+                    device=-1)
+
+def classify_text(text: str):
+    clf = _clf()
+    labels = SAFE_LABELS + UNSAFE_LABELS
+    res = clf(text, candidate_labels=labels)
+    scores = dict(zip(res["labels"], res["scores"]))
+    return res["labels"][0], res["scores"][0], scores
+
+def validate_input(text: str, threshold: float = 0.2) -> bool:
+    text = (text or "").strip()
+    if not text:
+        return False
+    top_label, top_score, _ = classify_text(text)
+    return bool(top_label in SAFE_LABELS and top_score > threshold)
+
+if __name__ == "__main__":
+    print(validate_input("kapan belanda menjajah indonesia?"))

Model.py

@@ -0,0 +1,13 @@
+# Model.py
+import os
+from llama_cpp import Llama
+
+def load_model(path, n_ctx=2048, n_gpu_layers=0, n_threads=None):
+    if n_threads is None:
+        n_threads = int(os.environ.get("NUM_THREADS", "4"))
+    return Llama(model_path=path, n_ctx=n_ctx, n_gpu_layers=n_gpu_layers, n_threads=n_threads)
+
+def generate(llm, prompt, max_tokens=384, temperature=0.2, top_p=0.9, stop=None):
+    stop = stop or []
+    out = llm(prompt, max_tokens=max_tokens, temperature=temperature, top_p=top_p, stop=stop)
+    return out["choices"][0]["text"].strip()

app.py

@@ -0,0 +1,676 @@
+# app.py
+# Flask RAG app (HF Spaces / Static) — dataset sudah ada di Space.
+import os, json, re, time, logging
+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
+import numpy as np
+import faiss
+import torch
+from transformers import AutoTokenizer, AutoModel
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# ========= ENV & LOGGING =========
+os.environ.setdefault("KMP_DUPLICATE_LIB_OK", "TRUE")
+os.environ.setdefault("OMP_NUM_THREADS", "1")
+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 =========
+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-0528-Qwen3-8B-Q4_K_M.gguf"))
+CTX_WINDOW   = 4096
+N_GPU_LAYERS = 0  # HF Spaces CPU only
+N_THREADS    = int(os.environ.get("NUM_THREADS", "4"))
+
+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"
+    },
+    "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"
+    },
+    "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"
+    }
+}
+
+# Threshold dan fallback
+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")
+
+# ========= GLOBAL MODEL =========
+ENCODER_TOKENIZER = None
+ENCODER_MODEL = None
+LLM = None
+
+@dataclass(frozen=True)
+class SubjectAssets:
+    index: faiss.Index
+    texts: List[str]
+    embs: np.ndarray
+
+# ========= TEKS UTILITAS =========
+STOPWORDS_ID = {
+    "yang","dan","atau","pada","di","ke","dari","itu","ini","adalah","dengan",
+    "untuk","serta","sebagai","oleh","dalam","akan","kamu","apa","karena",
+    "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
+    return len(q & s) / max(1, len(q | s))
+
+QUESTION_LIKE_RE = re.compile(r"(^\s*(apa|mengapa|bagaimana|sebutkan|jelaskan)\b|[?]$)", re.IGNORECASE)
+INSTRUCTION_RE   = re.compile(r"\b(jelaskan|sebutkan|uraikan|kerjakan|diskusikan|tugas|latihan|menurut\s+pendapatmu)\b", re.IGNORECASE)
+META_PREFIX_PATTERNS = [
+    r"berdasarkan\s+(?:kalimat|sumber|teks|konten|informasi)(?:\s+(?:di\s+atas|tersebut))?",
+    r"menurut\s+(?:sumber|teks|konten)",
+    r"merujuk\s+pada",
+    r"mengacu\s+pada",
+    r"bersumber\s+dari",
+    r"dari\s+(?:kalimat|sumber|teks|konten)"
+]
+META_PREFIX_RE = re.compile(r"^\s*(?:" + r"|".join(META_PREFIX_PATTERNS) + r")\s*[:\-–—,]?\s*", re.IGNORECASE)
+
+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
+        t = t2
+    return t
+
+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)
+    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
+        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:
+        log.info(f"[INIT] Load encoder: {ENCODER_NAME} (CPU)")
+        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}")
+        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"])
+
+    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"])
+    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)
+    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)
+    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)
+    q = encode_query_exact(query)
+    _, I = assets.index.search(q, TOP_K_FAISS)
+    qv = q.reshape(-1)
+    best = -1.0
+    for i in I[0]:
+        if 0 <= i < len(assets.texts):
+            best = max(best, cosine_sim(qv, assets.embs[i]))
+    return best
+
+def retrieve_rerank_cosine(query: str, subject_key: str) -> List[str]:
+    assets = load_subject_assets(subject_key)
+    q = encode_query_exact(query)
+    D, idx = assets.index.search(q, TOP_K_FAISS)
+    idxs = [i for i in idx[0] if 0 <= i < len(assets.texts)]
+    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(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(ch):
+            sv = encode_query_exact(s).reshape(-1)
+            cos = cosine_sim(qv, sv)
+            ovl = lexical_overlap(query, 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]]
+
+def build_prompt(user_query: str, sentences: List[str]) -> str:
+    block = "\n".join(f"- {clean_prefix(s)}" for s in sentences)
+    system = (
+        "- 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', 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:
+    try:
+        return validate_input(q)
+    except Exception as e:
+        log.exception(f"[GUARDRAIL] error: {e}")
+        return False
+
+# ========= 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
+
+POSTGRES_URL = os.environ.get("POSTGRES_URL")
+if not POSTGRES_URL:
+    raise RuntimeError("POSTGRES_URL tidak ditemukan. Set di Settings → Variables.")
+
+engine = create_engine(POSTGRES_URL, pool_pre_ping=True, future=True, echo=False)
+SessionLocal = scoped_session(sessionmaker(bind=engine, autoflush=False, autocommit=False, future=True))
+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)
+    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)
+    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()))
+
+Base.metadata.create_all(bind=engine)
+
+JKT_TZ = ZoneInfo("Asia/Jakarta")
+@app.template_filter("fmt_ts")
+def fmt_ts(epoch_int: int):
+    try:
+        dt = datetime.fromtimestamp(int(epoch_int), tz=JKT_TZ)
+        return dt.strftime("%d %b %Y %H:%M")
+    except Exception:
+        return "-"
+
+def db():
+    return SessionLocal()
+
+def login_required(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):
+    def wrapper(*args, **kwargs):
+        if not session.get("logged_in"):
+            return redirect(url_for("auth_login"))
+        if not session.get("is_admin"):
+            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():
+    return redirect(url_for("auth_login"))
+
+@app.route("/auth/login", methods=["GET", "POST"])
+def auth_login():
+    if request.method == "POST":
+        identity = (request.form.get("identity") 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 = (
+                s.query(User)
+                 .filter(or_(func.lower(User.username) == identity,
+                             func.lower(User.email) == identity))
+                 .first()
+            )
+            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)
+        return redirect(url_for("subjects"))
+    return render_template("login.html")
+
+@app.route("/auth/register", methods=["GET", "POST"])
+def auth_register():
+    if request.method == "POST":
+        username = (request.form.get("username") or "").strip().lower()
+        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
+        if len(pw) < 6:
+            flash("Password minimal 6 karakter.", "error")
+            return render_template("register.html"), 400
+        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()
+            )
+            if existed:
+                flash("Username/Email sudah terpakai.", "error")
+                return render_template("register.html"), 409
+            u = User(username=username, email=email, password=generate_password_hash(pw), is_active=True)
+            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")
+def auth_logout():
+    session.clear()
+    return redirect(url_for("auth_login"))
+
+@app.route("/about")
+def about():
+    return render_template("about.html")
+
+@app.route("/subjects")
+@login_required
+def subjects():
+    return render_template("home.html", subjects=SUBJECTS)
+
+@app.route("/chat/<subject_key>")
+@login_required
+def chat_subject(subject_key: str):
+    if subject_key not in SUBJECTS:
+        return redirect(url_for("subjects"))
+    session["subject_selected"] = subject_key
+    label = SUBJECTS[subject_key]["label"]
+
+    s = db()
+    try:
+        uid = session.get("user_id")
+        rows = (
+            s.query(ChatHistory)
+             .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:
+        s.close()
+
+    return render_template("chat.html", subject=subject_key, subject_label=label, history=history)
+
+@app.route("/health")
+def health():
+    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
+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()
+    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})
+
+    try:
+        _ = load_subject_assets(subject_key)
+    except Exception as e:
+        log.exception(f"[ASSETS] error: {e}")
+        return jsonify({"ok": False, "error": f"subject assets error: {e}"}), 500
+
+    best = best_cosine_from_faiss(query, subject_key)
+    log.info(f"[RAG] Subject={subject_key.upper()} | Best cosine={best:.3f}")
+    if best < MIN_COSINE:
+        return jsonify({"ok": True, "answer": FALLBACK_TEXT})
+
+    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})
+
+    prompt = build_prompt(query, sentences)
+
+    try:
+        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})
+
+    m = re.search(r"(.+?[.!?])(\s|$)", answer)
+    answer = (m.group(1) if m else answer).strip()
+    answer = strip_meta_sentence(answer)
+
+    # === Simpan ke history ===
+    try:
+        s = db()
+        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)
+        ])
+        s.commit()
+    except Exception as e:
+        log.exception(f"[DB] gagal simpan chat history: {e}")
+    finally:
+        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})
+
+    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
+    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)
+
+@app.route("/admin/users")
+@admin_required
+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}%")
+            ))
+        total = base.count()
+        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())
+    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")
+@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)
+
+    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
+            ))
+        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())
+    finally:
+        s.close()
+
+    items = [{
+        "id": r.ChatHistory.id,
+        "username": r.User.username,
+        "email": r.User.email,
+        "subject": r.ChatHistory.subject_key,
+        "role": r.ChatHistory.role,
+        "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)
+
+def _is_last_admin(s: Session) -> bool:
+    return (s.query(func.count(User.id)).filter(User.is_admin.is_(True)).scalar() or 0) <= 1
+
+@app.route("/admin/users/<int:user_id>/delete", methods=["POST"])
+@admin_required
+def admin_delete_user(user_id: int):
+    s = db()
+    try:
+        me_id = session.get("user_id")
+        user = s.query(User).filter_by(id=user_id).first()
+        if not user:
+            flash("User tidak ditemukan.", "error")
+            return redirect(request.referrer or url_for("admin_users"))
+        if user.id == me_id:
+            flash("Tidak bisa menghapus akun yang sedang login.", "error")
+            return redirect(request.referrer or url_for("admin_users"))
+        if user.is_admin and _is_last_admin(s):
+            flash("Tidak bisa menghapus admin terakhir.", "error")
+            return redirect(request.referrer or url_for("admin_users"))
+        s.query(ChatHistory).filter(ChatHistory.user_id == user.id).delete(synchronize_session=False)
+        s.delete(user); s.commit()
+        flash(f"User #{user_id} beserta seluruh riwayatnya telah dihapus.", "success")
+    except Exception as e:
+        s.rollback(); log.exception(f"[ADMIN] delete user error: {e}")
+        flash("Gagal menghapus user.", "error")
+    finally:
+        s.close()
+    return redirect(request.referrer or url_for("admin_users"))
+
+@app.route("/admin/users/<int:user_id>/history/clear", methods=["POST"])
+@admin_required
+def admin_clear_user_history(user_id: int):
+    s = db()
+    try:
+        exists = s.query(User.id).filter_by(id=user_id).first()
+        if not exists:
+            flash("User tidak ditemukan.", "error")
+            return redirect(request.referrer or url_for("admin_history"))
+        deleted = s.query(ChatHistory).filter(ChatHistory.user_id == user_id).delete(synchronize_session=False)
+        s.commit()
+        flash(f"Riwayat chat user #{user_id} dihapus ({deleted} baris).", "success")
+    except Exception as e:
+        s.rollback(); log.exception(f"[ADMIN] clear history error: {e}")
+        flash("Gagal menghapus riwayat.", "error")
+    finally:
+        s.close()
+    return redirect(request.referrer or url_for("admin_history"))
+
+@app.route("/admin/history/<int:chat_id>/delete", methods=["POST"])
+@admin_required
+def admin_delete_chat(chat_id: int):
+    s = db()
+    try:
+        row = s.query(ChatHistory).filter_by(id=chat_id).first()
+        if not row:
+            flash("Baris riwayat tidak ditemukan.", "error")
+            return redirect(request.referrer or url_for("admin_history"))
+        s.delete(row); s.commit()
+        flash(f"Riwayat chat #{chat_id} dihapus.", "success")
+    except Exception as e:
+        s.rollback(); log.exception(f"[ADMIN] delete chat error: {e}")
+        flash("Gagal menghapus riwayat.", "error")
+    finally:
+        s.close()
+    return redirect(request.referrer or url_for("admin_history"))
+
+# ========= ENTRY =========
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port, debug=False)

app.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -e
+python prepare_assets.py
+exec gunicorn app:app --workers 1 --threads 8 --timeout 180 --bind 0.0.0.0:$PORT

prepare_assets.py

@@ -0,0 +1,40 @@
+# prepare_assets.py
+# Download ONLY: GGUF (llama.cpp) + prefetch guardrail XNLI
+import os, shutil
+from pathlib import Path
+from huggingface_hub import hf_hub_download, snapshot_download
+
+BASE = Path(__file__).resolve().parent
+os.environ.setdefault("HF_HOME", str(BASE / ".hf-cache"))  # cache lokal biar cepat restart
+
+GGUF_REPO_ID  = os.getenv("GGUF_REPO_ID",  "unsloth/DeepSeek-R1-0528-Qwen3-8B-GGUF")
+GGUF_FILENAME = os.getenv("GGUF_FILENAME", "DeepSeek-R1-0528-Qwen3-8B-Q4_K_M.gguf")
+XNLI_REPO_ID  = os.getenv("XNLI_REPO_ID",  "joeddav/xlm-roberta-large-xnli")
+
+def ensure_dir(p: Path):
+    p.parent.mkdir(parents=True, exist_ok=True)
+
+def main():
+    print("=== PREPARE_ASSETS start ===")
+
+    # 1) Download GGUF -> models/
+    try:
+        target = BASE / "models" / GGUF_FILENAME
+        ensure_dir(target)
+        local = hf_hub_download(repo_id=GGUF_REPO_ID, filename=GGUF_FILENAME, repo_type="model")
+        shutil.copy(local, target)
+        print(f"[OK] GGUF -> {target}")
+    except Exception as e:
+        print(f"[WARN] GGUF download gagal: {e}")
+
+    # 2) Prefetch guardrail model ke cache (biar pipeline cepat)
+    try:
+        snapshot_download(repo_id=XNLI_REPO_ID)  # hanya ke cache
+        print(f"[OK] Prefetch guardrail: {XNLI_REPO_ID}")
+    except Exception as e:
+        print(f"[WARN] Prefetch XNLI gagal: {e}")
+
+    print("=== PREPARE_ASSETS done ===")
+
+if __name__ == "__main__":
+    main()

requerments.txt

@@ -0,0 +1,18 @@
+flask==3.0.3
+jinja2==3.1.4
+werkzeug==3.0.3
+python-dotenv==1.0.1
+
+sqlalchemy==2.0.36
+psycopg2-binary==2.9.9
+
+numpy==1.26.4
+faiss-cpu==1.8.0
+scikit-learn==1.5.2
+
+torch==2.4.1
+transformers==4.44.2
+huggingface_hub==0.26.2
+
+llama-cpp-python==0.3.4
+gunicorn==21.2.0

runtime.txt

@@ -0,0 +1 @@
+python-3.11