Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py — RAG + Deterministic QA + Local LLM (CPU-friendly)
+# app.py — IPLM Chatbot (UI sederhana ala GPT)
 import os, re, json, pickle, hashlib
 from pathlib import Path
 import gradio as gr
@@ -6,23 +6,20 @@ import numpy as np
 from sklearn.neighbors import NearestNeighbors
 from sentence_transformers import SentenceTransformer
 
-# =================== Konfigurasi ===================
+# =================== Konfigurasi lewat ENV ===================
 DATA_PATH  = Path(os.getenv("DATA_PATH", "IPLM_QnA_Chatbot.jsonl"))
-CACHE_EMB  = Path("embeddings.pkl")
-CACHE_META = Path("meta.json")
-
-EMB_MODEL   = os.getenv("EMB_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
-LOCAL_MODEL = os.getenv("LOCAL_MODEL", "microsoft/phi-2")  # jalan di CPU
-
-TOP_K_DEFAULT       = int(os.getenv("TOP_K_DEFAULT", "4"))
-TEMPERATURE_DEFAULT = float(os.getenv("TEMPERATURE_DEFAULT", "0.2"))
-MAX_TOKENS          = int(os.getenv("MAX_TOKENS", "256"))
-SCORE_THRESHOLD     = float(os.getenv("SCORE_THRESHOLD", "0.60"))  # 0..1
+EMB_MODEL  = os.getenv("EMB_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+LOCAL_MODEL= os.getenv("LOCAL_MODEL", "microsoft/phi-2")  # model lokal (CPU)
+TOP_K      = int(os.getenv("TOP_K", "4"))
+TEMPERATURE= float(os.getenv("TEMPERATURE", "0.2"))
+MAX_TOKENS = int(os.getenv("MAX_TOKENS", "256"))
+THRESHOLD  = float(os.getenv("THRESHOLD", "0.60"))  # ambil jawaban langsung jika skor >= threshold
+SHOW_SOURCES = os.getenv("SHOW_SOURCES", "false").lower() == "true"  # set true jika ingin tampilkan sumber terdekat
 
 SYSTEM_PROMPT = (
     "You are an Indonesian librarian assistant. Jawab singkat, akurat, dan sopan. "
-    "Jawab HANYA berdasarkan konteks yang diberikan. "
-    "Jika tidak ada jawabannya di konteks, balas persis: Data tidak tersedia."
+    "Jawab HANYA berdasarkan konteks yang diberikan. Jika tidak ada jawabannya, "
+    "balas persis: Data tidak tersedia."
 )
 
 # =================== Utilitas ===================
@@ -42,8 +39,7 @@ def load_jsonl(path: Path):
     rows = []
     with path.open("r", encoding="utf-8") as f:
         for line in f:
-            line = line.strip()
-            if not line: continue
+            if not line.strip(): continue
             obj = json.loads(line)
             q = obj.get("question") or obj.get("pertanyaan") or obj.get("q")
             a = obj.get("answer")   or obj.get("jawaban")    or obj.get("a")
@@ -57,29 +53,31 @@ def load_jsonl(path: Path):
         seen.add(r["question"]); uniq.append(r)
     return uniq
 
-# =================== Retriever (k-NN atas embedding pertanyaan) ===================
+# =================== Retriever ===================
 class FAQIndex:
     def __init__(self):
         self.rows=None; self.model=None; self.emb=None; self.nn=None
 
     def build(self, rows, force=False):
+        cache_emb  = Path("embeddings.pkl")
+        cache_meta = Path("meta.json")
         self.rows = rows
-        if not force and CACHE_EMB.exists() and CACHE_META.exists():
+        if not force and cache_emb.exists() and cache_meta.exists():
             try:
-                meta = json.loads(CACHE_META.read_text(encoding="utf-8"))
+                meta = json.loads(cache_meta.read_text(encoding="utf-8"))
                 if meta.get("hash")==dataset_hash(rows) and meta.get("emb_model")==EMB_MODEL:
-                    cached = pickle.loads(CACHE_EMB.read_bytes())
+                    cached = pickle.loads(cache_emb.read_bytes())
                     self.emb, self.nn = cached["emb"], cached["nn"]
                     if self.model is None: self.model = SentenceTransformer(EMB_MODEL)
                     return
             except Exception:
                 pass
         self.model = SentenceTransformer(EMB_MODEL)
-        qs = [r["question"] for r in rows]  # embed pertanyaan saja
+        qs = [r["question"] for r in rows]
         self.emb = self.model.encode(qs, normalize_embeddings=True, convert_to_numpy=True, show_progress_bar=False)
         self.nn  = NearestNeighbors(n_neighbors=min(10, len(qs)), metric="cosine").fit(self.emb)
-        CACHE_EMB.write_bytes(pickle.dumps({"emb": self.emb, "nn": self.nn}))
-        CACHE_META.write_text(json.dumps({"hash": dataset_hash(rows), "emb_model": EMB_MODEL}, ensure_ascii=False))
+        cache_emb.write_bytes(pickle.dumps({"emb": self.emb, "nn": self.nn}))
+        cache_meta.write_text(json.dumps({"hash": dataset_hash(rows), "emb_model": EMB_MODEL}, ensure_ascii=False))
 
     def retrieve(self, query: str, top_k: int):
         if not query.strip(): return []
@@ -92,9 +90,9 @@ class FAQIndex:
             out.append({"question": r["question"], "answer": r["answer"], "score": float(sim)})
         return out
 
-# =================== Local LLM (transformers pipeline di CPU) ===================
+# =================== Local LLM (CPU) ===================
 _local_pipe = None
-def call_local(prompt: str, temperature=TEMPERATURE_DEFAULT, max_tokens=MAX_TOKENS):
+def generate_with_local(prompt: str, temperature=TEMPERATURE, max_tokens=MAX_TOKENS):
     global _local_pipe
     try:
         if _local_pipe is None:
@@ -102,41 +100,33 @@ def call_local(prompt: str, temperature=TEMPERATURE_DEFAULT, max_tokens=MAX_TOKE
             from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
             tok   = AutoTokenizer.from_pretrained(LOCAL_MODEL)
             model = AutoModelForCausalLM.from_pretrained(LOCAL_MODEL, torch_dtype=torch.float32)
-            _local_pipe = pipeline(
-                "text-generation",
-                model=model,
-                tokenizer=tok,
-                device=-1,  # CPU
-            )
-        outs = _local_pipe(
-            prompt,
-            do_sample=True,
-            temperature=float(temperature),
-            max_new_tokens=int(max_tokens),
-            return_full_text=False,
-        )
+            _local_pipe = pipeline("text-generation", model=model, tokenizer=tok, device=-1)  # CPU
+        outs = _local_pipe(prompt, do_sample=True, temperature=float(temperature),
+                           max_new_tokens=int(max_tokens), return_full_text=False)
         if isinstance(outs, list) and outs and "generated_text" in outs[0]:
             return outs[0]["generated_text"]
         return str(outs)
     except Exception as e:
         return f"❌ Gagal menjalankan model lokal: {e}"
 
-# =================== RAG Orchestrator (dengan deterministic QA) ===================
+# =================== RAG (deterministic → generatif bila perlu) ===================
 def build_context(hits):
-    return "\n\n".join([f"[DOC {i} | {h['score']:.2f}] {h['answer']}" for i, h in enumerate(hits, 1)])
+    return "\n\n".join([f"[DOC {i}] {h['answer']}" for i, h in enumerate(hits, 1)])
 
-def rag_answer(user_msg, top_k=TOP_K_DEFAULT, temperature=TEMPERATURE_DEFAULT, threshold=SCORE_THRESHOLD):
-    hits = faq.retrieve(user_msg, top_k=int(top_k))
+def answer_query(user_msg: str) -> str:
+    hits = faq.retrieve(user_msg, top_k=TOP_K)
     if not hits:
-        return "Maaf, saya tidak menemukan referensi di basis pengetahuan Anda."
-    top = hits[0]
+        return "Data tidak tersedia."
 
-    # 1) Jika yakin → langsung pakai jawaban sumber (tanpa LLM)
-    if top["score"] >= float(threshold):
-        bullets = "\n".join([f"- ({h['score']:.2f}) {h['question']}" for h in hits])
-        return f"{top['answer']}\n\n**Sumber terdekat (deterministik):**\n{bullets}"
+    # Deterministic: kalau yakin → pakai jawaban sumber
+    if hits[0]["score"] >= THRESHOLD:
+        result = hits[0]['answer']
+        if SHOW_SOURCES:
+            bullets = "\n".join([f"- ({h['score']:.2f}) {h['question']}" for h in hits])
+            result += f"\n\n**Sumber terdekat:**\n{bullets}"
+        return result
 
-    # 2) Kurang yakin → minta LLM merangkum beberapa jawaban
+    # Jika kurang yakin → rangkum dengan LLM lokal
     context = build_context(hits)
     prompt = (
         f"SISTEM: {SYSTEM_PROMPT}\n\n"
@@ -145,52 +135,31 @@ def rag_answer(user_msg, top_k=TOP_K_DEFAULT, temperature=TEMPERATURE_DEFAULT, t
         "Instruksi: Jawab singkat dan HANYA berdasarkan KONTEKS di atas. "
         "Jika tidak ada jawabannya, balas persis: Data tidak tersedia."
     )
-    llm_out = call_local(prompt, temperature=float(temperature), max_tokens=MAX_TOKENS)
-    bullets = "\n".join([f"- ({h['score']:.2f}) {h['question']}" for h in hits])
-    return f"{llm_out}\n\n**Sumber terdekat (lokal):**\n{bullets}"
+    result = generate_with_local(prompt, temperature=TEMPERATURE, max_tokens=MAX_TOKENS)
+    if SHOW_SOURCES:
+        bullets = "\n".join([f"- ({h['score']:.2f}) {h['question']}" for h in hits])
+        result += f"\n\n**Sumber terdekat (lokal):**\n{bullets}"
+    return result
 
-# =================== Load & Upload ===================
+# =================== Load data & index ===================
 faq = FAQIndex()
-rows = load_jsonl(DATA_PATH)
-faq.build(rows, force=False)
-
-def upload_jsonl(file_obj):
-    if file_obj is None: return gr.update(value="Tidak ada file.")
-    Path(file_obj.name).replace(DATA_PATH)
-    if CACHE_EMB.exists(): CACHE_EMB.unlink()
-    if CACHE_META.exists(): CACHE_META.unlink()
-    global rows, faq
-    rows = load_jsonl(DATA_PATH)
-    faq = FAQIndex(); faq.build(rows, force=True)
-    return f"✅ Basis pengetahuan diperbarui. Total Q&A: {len(rows)}."
-
-# =================== UI ===================
-with gr.Blocks(title="RAG + LLM — Local Model") as demo:
-    gr.Markdown("## 📚 RAG + LLM — Local Model\nMasukkan pertanyaan → retrieve Q&A → model lokal merangkum bila perlu.")
-    with gr.Row():
-        with gr.Column(scale=2):
-            gr.ChatInterface(
-                fn=lambda msg, hist, k, t, th: rag_answer(msg, top_k=int(k), temperature=float(t), threshold=float(th)),
-                additional_inputs=[
-                    gr.Slider(1, 10, value=TOP_K_DEFAULT, step=1, label="Top-K dokumen"),
-                    gr.Slider(0.0, 1.0, value=TEMPERATURE_DEFAULT, step=0.05, label="Temperatur"),
-                    gr.Slider(0.0, 1.0, value=SCORE_THRESHOLD, step=0.01, label="Ambil langsung jika skor ≥"),
-                ],
-                title="Asisten Perpustakaan (RAG)",
-                description="Jawab *berdasarkan konteks* dari dokumen JSONL Anda.",
-                examples=[
-                    ["Apa itu IPLM?", TOP_K_DEFAULT, TEMPERATURE_DEFAULT, SCORE_THRESHOLD],
-                    ["Bagaimana menghitung IPLM?", TOP_K_DEFAULT, TEMPERATURE_DEFAULT, SCORE_THRESHOLD],
-                    ["Apa saja dimensi IPLM?", TOP_K_DEFAULT, TEMPERATURE_DEFAULT, SCORE_THRESHOLD],
-                ],
-                cache_examples=False,
-            )
-        with gr.Column(scale=1):
-            gr.Markdown("### 🔄 Perbarui Basis Data")
-            uploader = gr.File(label="Upload JSONL Q&A (keys: question, answer)")
-            status = gr.Textbox(label="Status", interactive=False)
-            uploader.change(fn=upload_jsonl, inputs=uploader, outputs=status)
-            gr.Markdown("_Model berjalan lokal (CPU). Anda dapat mengganti `LOCAL_MODEL` via Settings → Variables._")
+_rows = load_jsonl(DATA_PATH)
+faq.build(_rows, force=False)
+
+# =================== UI minimal ===================
+def chat_fn(message, history):
+    return answer_query(message)
+
+with gr.Blocks(title="IPLM Chatbot") as demo:
+    gr.Markdown("### 📚 IPLM Chatbot\nTanya apa saja tentang **IPLM**. (UI sengaja disederhanakan)")
+    gr.ChatInterface(
+        fn=chat_fn,
+        title="",
+        description="",
+        examples=["Apa itu IPLM?", "Bagaimana menghitung IPLM?", "Apa saja dimensi IPLM?"],
+        cache_examples=False,
+        autofocus=True,
+    )
 
 if __name__ == "__main__":
     demo.launch()