Update app.py

app.py

@@ -5,10 +5,9 @@
 # - Predictor: safe model caching + safe feature alignment
 # - Stable categoricals ("NA"); no over-strict completeness gate
 # - Fixed [[PAGE=...]] regex
-# - NEW: Lightweight instrumentation (JSONL logs per RAG turn)
-# - UPDATED THEME: Dark-blue tabs + Evaluate tab + k-slider styling
-# - PATCH: Per-question/aggregate File + JSON outputs now dark-themed via elem_id hooks
-# - NEW: APA-like inline citations via CITATION_MAP + format_citation()
+# - Lightweight instrumentation (JSONL logs per RAG turn)
+# - Dark-blue theme + Evaluate tab + k-slider styling
+# - APA-style citations via paper_citations.csv
 # ================================================================
 
 # ---------------------- Runtime flags (HF-safe) ----------------------
@@ -18,7 +17,15 @@ os.environ["TRANSFORMERS_NO_FLAX"] = "1"
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 
 # ------------------------------- Imports ------------------------------
-import re, joblib, warnings, json, traceback, time, uuid, subprocess, sys
+import re
+import joblib
+import warnings
+import json
+import traceback
+import time
+import uuid
+import subprocess
+import sys
 from pathlib import Path
 from typing import List, Dict, Any, Optional
 
@@ -43,7 +50,7 @@ except Exception:
 
 # Optional OpenAI (for LLM paraphrase)
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-OPENAI_MODEL   = os.getenv("OPENAI_MODEL", "gpt-5")
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-5")
 try:
     from openai import OpenAI
 except Exception:
@@ -56,36 +63,10 @@ LLM_AVAILABLE = (
     and OpenAI is not None
 )
 
-# ========================= APA-style citation helpers =========================
-
-# Map PDF basenames → short APA-style in-text citations.
-# IMPORTANT: edit these entries to match your actual filenames + desired citations.
-CITATION_MAP: Dict[str, str] = {
-    # "filename.pdf": "Author et al., YEAR",
-    # Examples (you can edit/remove these):
-    "S92-Research-on-the-self-sensing-and-mechanical-properties-of_2021_Cement-and-Co.pdf": "Omar et al., 2021",
-    "S60-Study-on-self-sensing-capabilities-of-smart-cements-filled-with-graphene-oxide-under-dynamic-cyclic-loading.pdf": "Zhang et al., 2019",
-    "S59-Modifying self-sensing cement-based composites through multiscale composition.pdf": "Li et al., 2020",
-}
-
-def format_citation(doc_name: str, page: Any) -> str:
-    """
-    Convert a doc filename + page into an APA-like inline citation.
-    Fallback: use filename if doc not in CITATION_MAP.
-    """
-    base = Path(doc_name).name
-    short = CITATION_MAP.get(base, base)
-    if page is None:
-        return short
-    page_str = str(page).strip()
-    if page_str == "" or page_str == "?":
-        return short
-    return f"{short}, p. {page_str}"
-
 # ========================= Predictor (kept) =========================
-CF_COL     = "Conductive Filler Conc. (wt%)"
+CF_COL = "Conductive Filler Conc. (wt%)"
 TARGET_COL = "Stress GF (MPa-1)"
-CANON_NA   = "NA"  # canonical placeholder for categoricals
+CANON_NA = "NA"  # canonical placeholder for categoricals
 
 MAIN_VARIABLES = [
     "Filler 1 Type",
@@ -110,7 +91,7 @@ MAIN_VARIABLES = [
     "Loading Rate (MPa/s)",
     "Modulus of Elasticity (GPa)",
     "Current Type",
-    "Applied Voltage (V)"
+    "Applied Voltage (V)",
 ]
 
 NUMERIC_COLS = {
@@ -129,7 +110,7 @@ NUMERIC_COLS = {
     "Drying Duration (hr)",
     "Loading Rate (MPa/s)",
     "Modulus of Elasticity (GPa)",
-    "Applied Voltage (V)"
+    "Applied Voltage (V)",
 }
 
 CATEGORICAL_COLS = {
@@ -139,23 +120,24 @@ CATEGORICAL_COLS = {
     "Filler 2 Dimensionality",
     "Probe Material",
     "Curing Condition",
-    "Current Type"
+    "Current Type",
 }
 
-DIM_CHOICES     = ["0D", "1D", "2D", "3D", CANON_NA]
+DIM_CHOICES = ["0D", "1D", "2D", "3D", CANON_NA]
 CURRENT_CHOICES = ["DC", "AC", CANON_NA]
 
 MODEL_CANDIDATES = [
     "stress_gf_xgb.joblib",
     "models/stress_gf_xgb.joblib",
     "/home/user/app/stress_gf_xgb.joblib",
-    os.getenv("MODEL_PATH", "")
+    os.getenv("MODEL_PATH", ""),
 ]
 
 # ---------- Model caching + status ----------
 MODEL = None
 MODEL_STATUS = "🔴 Model not loaded"
 
+
 def _try_load_model():
     global MODEL, MODEL_STATUS
     for p in [x for x in MODEL_CANDIDATES if x]:
@@ -171,12 +153,15 @@ def _try_load_model():
                 MODEL = None
     if MODEL is None:
         MODEL_STATUS = (
-            "🔴 Model not found (place stress_gf_xgb.joblib at repo root or models/, or set MODEL_PATH)"
+            "🔴 Model not found (place stress_gf_xgb.joblib at repo root or models/, "
+            "or set MODEL_PATH)"
         )
         print("[ModelLoad]", MODEL_STATUS)
 
+
 _try_load_model()  # load at import time
 
+
 def _canon_cat(v: Any) -> str:
     """Stable, canonical category placeholder normalization."""
     if v is None:
@@ -186,6 +171,7 @@ def _canon_cat(v: Any) -> str:
         return CANON_NA
     return s
 
+
 def _to_float_or_nan(v):
     if v in ("", None):
         return np.nan
@@ -194,6 +180,7 @@ def _to_float_or_nan(v):
     except Exception:
         return np.nan
 
+
 def _coerce_to_row(form_dict: dict) -> pd.DataFrame:
     row = {}
     for col in MAIN_VARIABLES:
@@ -207,6 +194,7 @@ def _coerce_to_row(form_dict: dict) -> pd.DataFrame:
             row[col] = s if s else CANON_NA
     return pd.DataFrame([row], columns=MAIN_VARIABLES)
 
+
 def _align_columns_to_model(df: pd.DataFrame, mdl) -> pd.DataFrame:
     """
     SAFE alignment:
@@ -248,6 +236,7 @@ def _align_columns_to_model(df: pd.DataFrame, mdl) -> pd.DataFrame:
         traceback.print_exc()
         return df
 
+
 def predict_fn(**kwargs):
     """
     Always attempt prediction.
@@ -272,6 +261,7 @@ def predict_fn(**kwargs):
         traceback.print_exc()
         return 0.0
 
+
 EXAMPLE = {
     "Filler 1 Type": "CNT",
     "Filler 1 Dimensionality": "1D",
@@ -298,9 +288,11 @@ EXAMPLE = {
     "Applied Voltage (V)": 5.0,
 }
 
+
 def _fill_example():
     return [EXAMPLE.get(k, None) for k in MAIN_VARIABLES]
 
+
 def _clear_all():
     cleared = []
     for col in MAIN_VARIABLES:
@@ -314,32 +306,41 @@ def _clear_all():
             cleared.append("")
     return cleared
 
+
 # ========================= Hybrid RAG =========================
-ARTIFACT_DIR    = Path("rag_artifacts"); ARTIFACT_DIR.mkdir(exist_ok=True)
+ARTIFACT_DIR = Path("rag_artifacts")
+ARTIFACT_DIR.mkdir(exist_ok=True)
 TFIDF_VECT_PATH = ARTIFACT_DIR / "tfidf_vectorizer.joblib"
-TFIDF_MAT_PATH  = ARTIFACT_DIR / "tfidf_matrix.joblib"
-BM25_TOK_PATH   = ARTIFACT_DIR / "bm25_tokens.joblib"
-EMB_NPY_PATH    = ARTIFACT_DIR / "chunk_embeddings.npy"
-RAG_META_PATH   = ARTIFACT_DIR / "chunks.parquet"
+TFIDF_MAT_PATH = ARTIFACT_DIR / "tfidf_matrix.joblib"
+BM25_TOK_PATH = ARTIFACT_DIR / "bm25_tokens.joblib"
+EMB_NPY_PATH = ARTIFACT_DIR / "chunk_embeddings.npy"
+RAG_META_PATH = ARTIFACT_DIR / "chunks.parquet"
 
-LOCAL_PDF_DIR = Path("papers"); LOCAL_PDF_DIR.mkdir(exist_ok=True)
+LOCAL_PDF_DIR = Path("papers")
+LOCAL_PDF_DIR.mkdir(exist_ok=True)
 USE_ONLINE_SOURCES = os.getenv("USE_ONLINE_SOURCES", "false").lower() == "true"
 
 W_TFIDF_DEFAULT = 0.50 if not USE_DENSE else 0.30
-W_BM25_DEFAULT  = 0.50 if not USE_DENSE else 0.30
-W_EMB_DEFAULT   = 0.00 if USE_DENSE is False else 0.40
+W_BM25_DEFAULT = 0.50 if not USE_DENSE else 0.30
+W_EMB_DEFAULT = 0.00 if USE_DENSE is False else 0.40
 
 _SENT_SPLIT_RE = re.compile(r"(?<=[.!?])\s+|\n+")
-TOKEN_RE       = re.compile(r"[A-Za-z0-9_#+\-/\.%]+")
+TOKEN_RE = re.compile(r"[A-Za-z0-9_#+\-/\.%]+")
+
+
 def sent_split(text: str) -> List[str]:
     sents = [s.strip() for s in _SENT_SPLIT_RE.split(text) if s.strip()]
     return [s for s in sents if len(s.split()) >= 5]
+
+
 def tokenize(text: str) -> List[str]:
     return [t.lower() for t in TOKEN_RE.findall(text)]
 
+
 def _extract_pdf_text(pdf_path: Path) -> str:
     try:
         import fitz
+
         doc = fitz.open(pdf_path)
         out = []
         for i, page in enumerate(doc):
@@ -348,6 +349,7 @@ def _extract_pdf_text(pdf_path: Path) -> str:
     except Exception:
         try:
             from pypdf import PdfReader
+
             reader = PdfReader(str(pdf_path))
             out = []
             for i, p in enumerate(reader.pages):
@@ -358,16 +360,18 @@ def _extract_pdf_text(pdf_path: Path) -> str:
             print(f"PDF read error ({pdf_path}): {e}")
             return ""
 
+
 def chunk_by_sentence_windows(text: str, win_size=8, overlap=2) -> List[str]:
     sents = sent_split(text)
     chunks, step = [], max(1, win_size - overlap)
     for i in range(0, len(sents), step):
-        window = sents[i:i+win_size]
+        window = sents[i : i + win_size]
         if not window:
             break
         chunks.append(" ".join(window))
     return chunks
 
+
 def _safe_init_st_model(name: str):
     global USE_DENSE
     if not USE_DENSE:
@@ -379,20 +383,26 @@ def _safe_init_st_model(name: str):
         USE_DENSE = False
         return None
 
+
 def build_or_load_hybrid(pdf_dir: Path):
     # Build or load the hybrid retriever cache
     have_cache = (
-        TFIDF_VECT_PATH.exists() and TFIDF_MAT_PATH.exists()
+        TFIDF_VECT_PATH.exists()
+        and TFIDF_MAT_PATH.exists()
         and RAG_META_PATH.exists()
         and (BM25_TOK_PATH.exists() or BM25Okapi is None)
         and (EMB_NPY_PATH.exists() or not USE_DENSE)
     )
     if have_cache:
         vectorizer = joblib.load(TFIDF_VECT_PATH)
-        X_tfidf    = joblib.load(TFIDF_MAT_PATH)
-        meta       = pd.read_parquet(RAG_META_PATH)
-        bm25_toks  = joblib.load(BM25_TOK_PATH) if BM25Okapi is not None else None
-        emb        = np.load(EMB_NPY_PATH) if (USE_DENSE and EMB_NPY_PATH.exists()) else None
+        X_tfidf = joblib.load(TFIDF_MAT_PATH)
+        meta = pd.read_parquet(RAG_META_PATH)
+        bm25_toks = joblib.load(BM25_TOK_PATH) if BM25Okapi is not None else None
+        emb = (
+            np.load(EMB_NPY_PATH)
+            if (USE_DENSE and EMB_NPY_PATH.exists())
+            else None
+        )
         return vectorizer, X_tfidf, meta, bm25_toks, emb
 
     rows, all_tokens = [], []
@@ -402,22 +412,30 @@ def build_or_load_hybrid(pdf_dir: Path):
         raw = _extract_pdf_text(pdf)
         if not raw.strip():
             continue
-        for i, ch in enumerate(chunk_by_sentence_windows(raw, win_size=8, overlap=2)):
+        for i, ch in enumerate(
+            chunk_by_sentence_windows(raw, win_size=8, overlap=2)
+        ):
             rows.append({"doc_path": str(pdf), "chunk_id": i, "text": ch})
             all_tokens.append(tokenize(ch))
     if not rows:
         meta = pd.DataFrame(columns=["doc_path", "chunk_id", "text"])
-        vectorizer = None; X_tfidf = None; emb = None; all_tokens = None
+        vectorizer = None
+        X_tfidf = None
+        emb = None
+        all_tokens = None
         return vectorizer, X_tfidf, meta, all_tokens, emb
 
     meta = pd.DataFrame(rows)
     from sklearn.feature_extraction.text import TfidfVectorizer
+
     vectorizer = TfidfVectorizer(
         ngram_range=(1, 2),
-        min_df=1, max_df=0.95,
-        sublinear_tf=True, smooth_idf=True,
+        min_df=1,
+        max_df=0.95,
+        sublinear_tf=True,
+        smooth_idf=True,
         lowercase=True,
-        token_pattern=r"(?u)\b\w[\w\-\./%+#]*\b"
+        token_pattern=r"(?u)\b\w[\w\-\./%+#]*\b",
     )
     X_tfidf = vectorizer.fit_transform(meta["text"].tolist())
 
@@ -425,15 +443,18 @@ def build_or_load_hybrid(pdf_dir: Path):
     if USE_DENSE:
         try:
             st_model = _safe_init_st_model(
-                os.getenv("EMB_MODEL_NAME", "sentence-transformers/all-MiniLM-L6-v2")
+                os.getenv(
+                    "EMB_MODEL_NAME", "sentence-transformers/all-MiniLM-L6-v2"
+                )
             )
             if st_model is not None:
                 from sklearn.preprocessing import normalize as sk_normalize
+
                 em = st_model.encode(
                     meta["text"].tolist(),
                     batch_size=64,
                     show_progress_bar=False,
-                    convert_to_numpy=True
+                    convert_to_numpy=True,
                 )
                 emb = sk_normalize(em)
                 np.save(EMB_NPY_PATH, emb)
@@ -448,19 +469,33 @@ def build_or_load_hybrid(pdf_dir: Path):
     meta.to_parquet(RAG_META_PATH, index=False)
     return vectorizer, X_tfidf, meta, all_tokens, emb
 
-tfidf_vectorizer, tfidf_matrix, rag_meta, bm25_tokens, emb_matrix = build_or_load_hybrid(LOCAL_PDF_DIR)
-bm25 = BM25Okapi(bm25_tokens) if (BM25Okapi is not None and bm25_tokens is not None) else None
-st_query_model = _safe_init_st_model(os.getenv("EMB_MODEL_NAME", "sentence-transformers/all-MiniLM-L6-v2"))
+
+tfidf_vectorizer, tfidf_matrix, rag_meta, bm25_tokens, emb_matrix = build_or_load_hybrid(
+    LOCAL_PDF_DIR
+)
+bm25 = (
+    BM25Okapi(bm25_tokens)
+    if (BM25Okapi is not None and bm25_tokens is not None)
+    else None
+)
+st_query_model = _safe_init_st_model(
+    os.getenv("EMB_MODEL_NAME", "sentence-transformers/all-MiniLM-L6-v2")
+)
+
 
 def _extract_page(text_chunk: str) -> str:
     # Correct: [[PAGE=123]]
     m = list(re.finditer(r"\[\[PAGE=(\d+)\]\]", text_chunk or ""))
-    return (m[-1].group(1) if m else "?")
+    return m[-1].group(1) if m else "?"
+
 
-def hybrid_search(query: str, k=8,
-                  w_tfidf=W_TFIDF_DEFAULT,
-                  w_bm25=W_BM25_DEFAULT,
-                  w_emb=W_EMB_DEFAULT):
+def hybrid_search(
+    query: str,
+    k: int = 8,
+    w_tfidf: float = W_TFIDF_DEFAULT,
+    w_bm25: float = W_BM25_DEFAULT,
+    w_emb: float = W_EMB_DEFAULT,
+):
     if rag_meta is None or rag_meta.empty:
         return pd.DataFrame()
 
@@ -468,28 +503,35 @@ def hybrid_search(query: str, k=8,
     if USE_DENSE and st_query_model is not None and emb_matrix is not None and w_emb > 0:
         try:
             from sklearn.preprocessing import normalize as sk_normalize
+
             q_emb = st_query_model.encode([query], convert_to_numpy=True)
             q_emb = sk_normalize(q_emb)[0]
             dense_scores = emb_matrix @ q_emb
         except Exception as e:
             print("Dense query encoding failed:", e)
-            dense_scores = np.zeros(len(rag_meta), dtype=float); w_emb = 0.0
+            dense_scores = np.zeros(len(rag_meta), dtype=float)
+            w_emb = 0.0
     else:
-        dense_scores = np.zeros(len(rag_meta), dtype=float); w_emb = 0.0
+        dense_scores = np.zeros(len(rag_meta), dtype=float)
+        w_emb = 0.0
 
     # TF-IDF scores
     if tfidf_vectorizer is not None and tfidf_matrix is not None:
         q_vec = tfidf_vectorizer.transform([query])
         tfidf_scores = (tfidf_matrix @ q_vec.T).toarray().ravel()
     else:
-        tfidf_scores = np.zeros(len(rag_meta), dtype=float); w_tfidf = 0.0
+        tfidf_scores = np.zeros(len(rag_meta), dtype=float)
+        w_tfidf = 0.0
 
     # BM25 scores
     if bm25 is not None:
-        q_tokens = [t.lower() for t in re.findall(r"[A-Za-z0-9_#+\-\/\.%]+", query)]
+        q_tokens = [
+            t.lower() for t in re.findall(r"[A-Za-z0-9_#+\-\/\.%]+", query)
+        ]
         bm25_scores = np.array(bm25.get_scores(q_tokens), dtype=float)
     else:
-        bm25_scores = np.zeros(len(rag_meta), dtype=float); w_bm25 = 0.0
+        bm25_scores = np.zeros(len(rag_meta), dtype=float)
+        w_bm25 = 0.0
 
     def _norm(x):
         x = np.asarray(x, dtype=float)
@@ -499,26 +541,37 @@ def hybrid_search(query: str, k=8,
 
     s_dense = _norm(dense_scores)
     s_tfidf = _norm(tfidf_scores)
-    s_bm25  = _norm(bm25_scores)
+    s_bm25 = _norm(bm25_scores)
 
     total_w = (w_tfidf + w_bm25 + w_emb) or 1.0
-    w_tfidf, w_bm25, w_emb = w_tfidf/total_w, w_bm25/total_w, w_emb/total_w
+    w_tfidf, w_bm25, w_emb = (
+        w_tfidf / total_w,
+        w_bm25 / total_w,
+        w_emb / total_w,
+    )
 
     combo = w_emb * s_dense + w_tfidf * s_tfidf + w_bm25 * s_bm25
     idx = np.argsort(-combo)[:k]
     hits = rag_meta.iloc[idx].copy()
     hits["score_dense"] = s_dense[idx]
     hits["score_tfidf"] = s_tfidf[idx]
-    hits["score_bm25"]  = s_bm25[idx]
-    hits["score"]       = combo[idx]
+    hits["score_bm25"] = s_bm25[idx]
+    hits["score"] = combo[idx]
     return hits.reset_index(drop=True)
 
+
 def split_sentences(text: str) -> List[str]:
     sents = sent_split(text)
     return [s for s in sents if 6 <= len(s.split()) <= 60]
 
-def mmr_select_sentences(question: str, hits: pd.DataFrame,
-                         top_n=4, pool_per_chunk=6, lambda_div=0.7):
+
+def mmr_select_sentences(
+    question: str,
+    hits: pd.DataFrame,
+    top_n: int = 4,
+    pool_per_chunk: int = 6,
+    lambda_div: float = 0.7,
+):
     """
     Robust MMR sentence picker:
     - Handles empty pools
@@ -528,12 +581,12 @@ def mmr_select_sentences(question: str, hits: pd.DataFrame,
     # Build pool
     pool = []
     for _, row in hits.iterrows():
-        doc  = Path(row["doc_path"]).name
+        doc = Path(row["doc_path"]).name
         page = _extract_page(row["text"])
         sents = split_sentences(row["text"])
         if not sents:
             continue
-        for s in sents[:max(1, int(pool_per_chunk))]:
+        for s in sents[: max(1, int(pool_per_chunk))]:
             pool.append({"sent": s, "doc": doc, "page": page})
 
     if not pool:
@@ -545,23 +598,39 @@ def mmr_select_sentences(question: str, hits: pd.DataFrame,
     try:
         if use_dense:
             from sklearn.preprocessing import normalize as sk_normalize
-            enc = st_query_model.encode([question] + sent_texts, convert_to_numpy=True)
+
+            enc = st_query_model.encode(
+                [question] + sent_texts, convert_to_numpy=True
+            )
             q_vec = sk_normalize(enc[:1])[0]
-            S     = sk_normalize(enc[1:])
-            rel   = (S @ q_vec)
-            def sim_fn(i, j): return float(S[i] @ S[j])
+            S = sk_normalize(enc[1:])
+            rel = S @ q_vec
+
+            def sim_fn(i, j):
+                return float(S[i] @ S[j])
+
         else:
             from sklearn.feature_extraction.text import TfidfVectorizer
+
             vect = TfidfVectorizer().fit(sent_texts + [question])
-            Q = vect.transform([question]); S = vect.transform(sent_texts)
+            Q = vect.transform([question])
+            S = vect.transform(sent_texts)
             rel = (S @ Q.T).toarray().ravel()
+
             def sim_fn(i, j):
-                num = (S[i] @ S[j].T)
-                return float(num.toarray()[0, 0]) if hasattr(num, "toarray") else float(num)
+                num = S[i] @ S[j].T
+                return (
+                    float(num.toarray()[0, 0])
+                    if hasattr(num, "toarray")
+                    else float(num)
+                )
+
     except Exception:
         # Fallback: uniform relevance if vectorization fails
         rel = np.ones(len(sent_texts), dtype=float)
-        def sim_fn(i, j): return 0.0
+
+        def sim_fn(i, j):
+            return 0.0
 
     # Normalize lambda_div
     lambda_div = float(np.clip(lambda_div, 0.0, 1.0))
@@ -572,7 +641,7 @@ def mmr_select_sentences(question: str, hits: pd.DataFrame,
         return []
     first = int(np.argmax(rel))
     selected_idx = [first]
-    selected     = [pool[first]]
+    selected = [pool[first]]
     remain.remove(first)
 
     # Clamp top_n
@@ -593,10 +662,63 @@ def mmr_select_sentences(question: str, hits: pd.DataFrame,
 
     return selected
 
+
+# ========================= APA-style citation helpers =========================
+CITATION_CSV = Path("paper_citations.csv")
+
+
+def _load_citation_map() -> Dict[str, str]:
+    """
+    Load a mapping from PDF basename -> APA-style in-text citation
+    from paper_citations.csv (columns: doc, citation).
+    """
+    if not CITATION_CSV.exists():
+        print(
+            "[Citations] paper_citations.csv not found; "
+            "will fall back to raw filenames."
+        )
+        return {}
+    try:
+        df = pd.read_csv(CITATION_CSV)
+        if not {"doc", "citation"}.issubset(df.columns):
+            print(
+                "[Citations] paper_citations.csv must have columns: 'doc', 'citation'."
+            )
+            return {}
+        cmap: Dict[str, str] = {}
+        for _, row in df.iterrows():
+            doc = str(row["doc"]).strip()
+            cit = str(row["citation"]).strip()
+            if doc and cit:
+                cmap[doc] = cit
+        print(
+            f"[Citations] Loaded {len(cmap)} citation entries from paper_citations.csv"
+        )
+        return cmap
+    except Exception as e:
+        print("[Citations] Failed to load paper_citations.csv:", e)
+        return {}
+
+
+CITATION_MAP: Dict[str, str] = _load_citation_map()
+
+
+def format_citation(doc_name: str, page: Any) -> str:
+    """
+    Convert a doc filename + page into an APA-like inline citation.
+    Fallback: use basename without .pdf if there's no mapping.
+    """
+    base = Path(doc_name).name
+    short = CITATION_MAP.get(base, Path(base).stem)
+    page_str = str(page).strip() if page is not None else ""
+    if not page_str or page_str == "?":
+        return short
+    return f"{short}, p. {page_str}"
+
+
 def compose_extractive(selected: List[Dict[str, Any]]) -> str:
     """
     Build an extractive answer with APA-style inline citations.
-    Each sentence ends with (Author et al., YEAR, p. X) when mapped in CITATION_MAP.
     """
     if not selected:
         return ""
@@ -606,11 +728,13 @@ def compose_extractive(selected: List[Dict[str, Any]]) -> str:
         parts.append(f"{s['sent']} ({cite})")
     return " ".join(parts)
 
+
 # ========================= NEW: Instrumentation helpers =========================
 LOG_PATH = ARTIFACT_DIR / "rag_logs.jsonl"
-OPENAI_IN_COST_PER_1K  = float(os.getenv("OPENAI_COST_IN_PER_1K", "0"))
+OPENAI_IN_COST_PER_1K = float(os.getenv("OPENAI_COST_IN_PER_1K", "0"))
 OPENAI_OUT_COST_PER_1K = float(os.getenv("OPENAI_COST_OUT_PER_1K", "0"))
 
+
 def _safe_write_jsonl(path: Path, record: dict):
     try:
         with open(path, "a", encoding="utf-8") as f:
@@ -618,14 +742,23 @@ def _safe_write_jsonl(path: Path, record: dict):
     except Exception as e:
         print("[Log] write failed:", e)
 
+
 def _calc_cost_usd(prompt_toks, completion_toks):
     if prompt_toks is None or completion_toks is None:
         return None
-    return (prompt_toks / 1000.0) * OPENAI_IN_COST_PER_1K + (completion_toks / 1000.0) * OPENAI_OUT_COST_PER_1K
+    return (
+        (prompt_toks / 1000.0) * OPENAI_IN_COST_PER_1K
+        + (completion_toks / 1000.0) * OPENAI_OUT_COST_PER_1K
+    )
+
 
 # ----------------- Modified to return (text, usage_dict) -----------------
-def synthesize_with_llm(question: str, sentence_lines: List[str],
-                        model: str = None, temperature: float = 0.2):
+def synthesize_with_llm(
+    question: str,
+    sentence_lines: List[str],
+    model: str = None,
+    temperature: float = 0.2,
+):
     if not LLM_AVAILABLE:
         return None, None
     client = OpenAI(api_key=OPENAI_API_KEY)
@@ -634,12 +767,12 @@ def synthesize_with_llm(question: str, sentence_lines: List[str],
         "You are a scientific assistant for self-sensing cementitious materials.\n"
         "Answer STRICTLY using the provided sentences.\n"
         "Do not invent facts. Keep it concise (3–6 sentences).\n"
-        "Retain inline citations exactly as given (e.g., Omar et al., 2021, p. X).\n"
+        "Retain inline citations exactly as given."
     )
     user_prompt = (
         f"Question: {question}\n\n"
-        f"Use ONLY these sentences to answer; keep their inline citations:\n" +
-        "\n".join(f"- {s}" for s in sentence_lines)
+        f"Use ONLY these sentences to answer; keep their inline citations:\n"
+        + "\n".join(f"- {s}" for s in sentence_lines)
     )
     try:
         resp = client.responses.create(
@@ -655,8 +788,16 @@ def synthesize_with_llm(question: str, sentence_lines: List[str],
         try:
             u = getattr(resp, "usage", None)
             if u:
-                pt = getattr(u, "prompt_tokens", None) if hasattr(u, "prompt_tokens") else u.get("prompt_tokens", None)
-                ct = getattr(u, "completion_tokens", None) if hasattr(u, "completion_tokens") else u.get("completion_tokens", None)
+                pt = (
+                    getattr(u, "prompt_tokens", None)
+                    if hasattr(u, "prompt_tokens")
+                    else u.get("prompt_tokens", None)
+                )
+                ct = (
+                    getattr(u, "completion_tokens", None)
+                    if hasattr(u, "completion_tokens")
+                    else u.get("completion_tokens", None)
+                )
                 usage = {"prompt_tokens": pt, "completion_tokens": ct}
         except Exception:
             usage = None
@@ -664,6 +805,7 @@ def synthesize_with_llm(question: str, sentence_lines: List[str],
     except Exception:
         return None, None
 
+
 def rag_reply(
     question: str,
     k: int = 8,
@@ -674,102 +816,119 @@ def rag_reply(
     temperature: float = 0.2,
     strict_quotes_only: bool = False,
     w_tfidf: float = W_TFIDF_DEFAULT,
-    w_bm25: float  = W_BM25_DEFAULT,
-    w_emb: float   = W_EMB_DEFAULT
+    w_bm25: float = W_BM25_DEFAULT,
+    w_emb: float = W_EMB_DEFAULT,
 ) -> str:
     run_id = str(uuid.uuid4())
     t0_total = time.time()
-    t0_retr  = time.time()
+    t0_retr = time.time()
 
     # --- Retrieval ---
     hits = hybrid_search(
-        question, k=k,
-        w_tfidf=w_tfidf, w_bm25=w_bm25, w_emb=w_emb
+        question,
+        k=k,
+        w_tfidf=w_tfidf,
+        w_bm25=w_bm25,
+        w_emb=w_emb,
     )
     t1_retr = time.time()
     latency_ms_retriever = int((t1_retr - t0_retr) * 1000)
 
     if hits is None or hits.empty:
-        final = "No indexed PDFs found. Upload PDFs to the 'papers/' folder and reload the Space."
+        final = (
+            "No indexed PDFs found. Upload PDFs to the 'papers/' folder and reload the Space."
+        )
         record = {
             "run_id": run_id,
-            "ts": int(time.time()*1000),
+            "ts": int(time.time() * 1000),
             "inputs": {
-                "question": question, "top_k": int(k), "n_sentences": int(n_sentences),
-                "w_tfidf": float(w_tfidf), "w_bm25": float(w_bm25), "w_emb": float(w_emb),
-                "use_llm": bool(use_llm), "model": model, "temperature": float(temperature)
+                "question": question,
+                "top_k": int(k),
+                "n_sentences": int(n_sentences),
+                "w_tfidf": float(w_tfidf),
+                "w_bm25": float(w_bm25),
+                "w_emb": float(w_emb),
+                "use_llm": bool(use_llm),
+                "model": model,
+                "temperature": float(temperature),
             },
             "retrieval": {"hits": [], "latency_ms_retriever": latency_ms_retriever},
             "output": {"final_answer": final, "used_sentences": []},
-            "latency_ms_total": int((time.time()-t0_total)*1000),
-            "openai": None
+            "latency_ms_total": int((time.time() - t0_total) * 1000),
+            "openai": None,
         }
         _safe_write_jsonl(LOG_PATH, record)
         return final
 
     # Select sentences
     selected = mmr_select_sentences(
-        question, hits,
+        question,
+        hits,
         top_n=int(n_sentences),
         pool_per_chunk=6,
-        lambda_div=0.7
+        lambda_div=0.7,
     )
-
-    # APA-style header citations: e.g., "Omar et al., 2021, p. 5; Zhang et al., 2019, p. 12"
+    # Header citations: APA-style
     header_cites = "; ".join(
         format_citation(
             Path(r["doc_path"]).name,
-            _extract_page(r["text"])
+            _extract_page(r["text"]),
         )
         for _, r in hits.head(6).iterrows()
     )
     srcs = {Path(r["doc_path"]).name for _, r in hits.iterrows()}
-    coverage_note = "" if len(srcs) >= 3 else (
-        f"\n\n> Note: Only {len(srcs)} unique source(s) contributed. "
-        f"Add more PDFs or increase Top-K."
+    coverage_note = (
+        "" if len(srcs) >= 3 else
+        f"\n\n> Note: Only {len(srcs)} unique source(s) contributed. Add more PDFs or increase Top-K."
     )
 
     # Prepare retrieval list for logging
     retr_list = []
     for _, r in hits.iterrows():
-        retr_list.append({
-            "doc": Path(r["doc_path"]).name,
-            "page": _extract_page(r["text"]),
-            "score_tfidf": float(r.get("score_tfidf", 0.0)),
-            "score_bm25": float(r.get("score_bm25", 0.0)),
-            "score_dense": float(r.get("score_dense", 0.0)),
-            "combo_score": float(r.get("score", 0.0)),
-        })
+        retr_list.append(
+            {
+                "doc": Path(r["doc_path"]).name,
+                "page": _extract_page(r["text"]),
+                "score_tfidf": float(r.get("score_tfidf", 0.0)),
+                "score_bm25": float(r.get("score_bm25", 0.0)),
+                "score_dense": float(r.get("score_dense", 0.0)),
+                "combo_score": float(r.get("score", 0.0)),
+            }
+        )
 
     # Strict quotes only (no LLM)
     if strict_quotes_only:
         if not selected:
             final = (
-                f"**Quoted Passages:**\n\n---\n"
-                + "\n\n".join(hits['text'].tolist()[:2])
+                "**Quoted Passages:**\n\n---\n"
+                + "\n\n".join(hits["text"].tolist()[:2])
                 + f"\n\n**Citations:** {header_cites}{coverage_note}"
             )
         else:
-            final = (
-                "**Quoted Passages:**\n- "
-                + "\n- ".join(
-                    f"{s['sent']} ({format_citation(s['doc'], s['page'])})"
-                    for s in selected
-                )
-            )
+            bullets = []
+            for s in selected:
+                cite = format_citation(s["doc"], s["page"])
+                bullets.append(f"{s['sent']} ({cite})")
+            final = "**Quoted Passages:**\n- " + "\n- ".join(bullets)
             final += f"\n\n**Citations:** {header_cites}{coverage_note}"
             if include_passages:
                 final += (
-                    "\n\n---\n" + "\n\n".join(hits['text'].tolist()[:2])
+                    "\n\n---\n" + "\n\n".join(hits["text"].tolist()[:2])
                 )
 
         record = {
             "run_id": run_id,
-            "ts": int(time.time()*1000),
+            "ts": int(time.time() * 1000),
             "inputs": {
-                "question": question, "top_k": int(k), "n_sentences": int(n_sentences),
-                "w_tfidf": float(w_tfidf), "w_bm25": float(w_bm25), "w_emb": float(w_emb),
-                "use_llm": False, "model": None, "temperature": float(temperature)
+                "question": question,
+                "top_k": int(k),
+                "n_sentences": int(n_sentences),
+                "w_tfidf": float(w_tfidf),
+                "w_bm25": float(w_bm25),
+                "w_emb": float(w_emb),
+                "use_llm": False,
+                "model": None,
+                "temperature": float(temperature),
             },
             "retrieval": {"hits": retr_list, "latency_ms_retriever": latency_ms_retriever},
             "output": {
@@ -777,10 +936,10 @@ def rag_reply(
                 "used_sentences": [
                     {"sent": s["sent"], "doc": s["doc"], "page": s["page"]}
                     for s in selected
-                ]
+                ],
             },
-            "latency_ms_total": int((time.time()-t0_total)*1000),
-            "openai": None
+            "latency_ms_total": int((time.time() - t0_total) * 1000),
+            "openai": None,
         }
         _safe_write_jsonl(LOG_PATH, record)
         return final
@@ -790,15 +949,14 @@ def rag_reply(
     llm_usage = None
     llm_latency_ms = None
     if use_llm and selected:
-        # Pass APA-style citations into the LLM so it preserves them
+        # Pass APA-cited sentences into LLM
         lines = [
             f"{s['sent']} ({format_citation(s['doc'], s['page'])})"
             for s in selected
         ]
         t0_llm = time.time()
         llm_text, llm_usage = synthesize_with_llm(
-            question, lines,
-            model=model, temperature=temperature
+            question, lines, model=model, temperature=temperature
         )
         t1_llm = time.time()
         llm_latency_ms = int((t1_llm - t0_llm) * 1000)
@@ -810,14 +968,14 @@ def rag_reply(
             )
             if include_passages:
                 final += (
-                    "\n\n---\n" + "\n\n".join(hits['text'].tolist()[:2])
+                    "\n\n---\n" + "\n\n".join(hits["text"].tolist()[:2])
                 )
         else:
             if not extractive:
                 final = (
-                    f"**Answer:** Here are relevant passages.\n\n"
+                    "**Answer:** Here are relevant passages.\n\n"
                     f"**Citations:** {header_cites}{coverage_note}\n\n---\n"
-                    + "\n\n".join(hits['text'].tolist()[:2])
+                    + "\n\n".join(hits["text"].tolist()[:2])
                 )
             else:
                 final = (
@@ -826,14 +984,14 @@ def rag_reply(
                 )
                 if include_passages:
                     final += (
-                        "\n\n---\n" + "\n\n".join(hits['text'].tolist()[:2])
+                        "\n\n---\n" + "\n\n".join(hits["text"].tolist()[:2])
                     )
     else:
         if not extractive:
             final = (
-                f"**Answer:** Here are relevant passages.\n\n"
+                "**Answer:** Here are relevant passages.\n\n"
                 f"**Citations:** {header_cites}{coverage_note}\n\n---\n"
-                + "\n\n".join(hits['text'].tolist()[:2])
+                + "\n\n".join(hits["text"].tolist()[:2])
             )
         else:
             final = (
@@ -842,47 +1000,71 @@ def rag_reply(
             )
             if include_passages:
                 final += (
-                    "\n\n---\n" + "\n\n".join(hits['text'].tolist()[:2])
+                    "\n\n---\n" + "\n\n".join(hits["text"].tolist()[:2])
                 )
 
     # --------- Log full run ---------
     prompt_toks = llm_usage.get("prompt_tokens") if llm_usage else None
-    completion_toks = llm_usage.get("completion_tokens") if llm_usage else None
+    completion_toks = (
+        llm_usage.get("completion_tokens") if llm_usage else None
+    )
     cost_usd = _calc_cost_usd(prompt_toks, completion_toks)
 
     total_ms = int((time.time() - t0_total) * 1000)
     record = {
         "run_id": run_id,
-        "ts": int(time.time()*1000),
+        "ts": int(time.time() * 1000),
         "inputs": {
-            "question": question, "top_k": int(k), "n_sentences": int(n_sentences),
-            "w_tfidf": float(w_tfidf), "w_bm25": float(w_bm25), "w_emb": float(w_emb),
-            "use_llm": bool(use_llm), "model": model, "temperature": float(temperature)
+            "question": question,
+            "top_k": int(k),
+            "n_sentences": int(n_sentences),
+            "w_tfidf": float(w_tfidf),
+            "w_bm25": float(w_bm25),
+            "w_emb": float(w_emb),
+            "use_llm": bool(use_llm),
+            "model": model,
+            "temperature": float(temperature),
         },
         "retrieval": {"hits": retr_list, "latency_ms_retriever": latency_ms_retriever},
         "output": {
             "final_answer": final,
             "used_sentences": [
-                {"sent": s['sent'], "doc": s['doc'], "page": s['page']}
+                {"sent": s["sent"], "doc": s["doc"], "page": s["page"]}
                 for s in selected
-            ]
+            ],
         },
         "latency_ms_total": total_ms,
         "latency_ms_llm": llm_latency_ms,
         "openai": {
             "prompt_tokens": prompt_toks,
             "completion_tokens": completion_toks,
-            "cost_usd": cost_usd
-        } if use_llm else None
+            "cost_usd": cost_usd,
+        }
+        if use_llm
+        else None,
     }
     _safe_write_jsonl(LOG_PATH, record)
     return final
 
-def rag_chat_fn(message, history, top_k, n_sentences, include_passages,
-                use_llm, model_name, temperature, strict_quotes_only,
-                w_tfidf, w_bm25, w_emb):
+
+def rag_chat_fn(
+    message,
+    history,
+    top_k,
+    n_sentences,
+    include_passages,
+    use_llm,
+    model_name,
+    temperature,
+    strict_quotes_only,
+    w_tfidf,
+    w_bm25,
+    w_emb,
+):
     if not message or not message.strip():
-        return "Ask a literature question (e.g., *How does CNT length affect gauge factor?*)"
+        return (
+            "Ask a literature question (e.g., *How does CNT length affect gauge factor?*)"
+        )
     try:
         return rag_reply(
             question=message,
@@ -900,6 +1082,7 @@ def rag_chat_fn(message, history, top_k, n_sentences, include_passages,
     except Exception as e:
         return f"RAG error: {e}"
 
+
 # ========================= UI (science-oriented styling) =========================
 CSS = """
 /* Science-oriented: crisp contrast + readable numerics */
@@ -958,11 +1141,11 @@ input[type="checkbox"], .gr-checkbox, .gr-checkbox > * { pointer-events: auto !i
     color: #dbeafe !important;
 }
 #eval-tab input[type="range"] { accent-color: #22c55e !important; }
-#eval-tab button { 
-    border-radius: 10px !important; 
-    font-weight: 700 !important; 
-    background: #0ea5e9 !important; 
-    color: #001321 !important; 
+#eval-tab button {
+    border-radius: 10px !important;
+    font-weight: 700 !important;
+    background: #0ea5e9 !important;
+    color: #001321 !important;
     border: 1px solid #7dd3fc !important;
 }
 #eval-tab .gr-json, #eval-tab .markdown pre, #eval-tab .markdown code {
@@ -988,27 +1171,27 @@ input[type="checkbox"], .gr-checkbox, .gr-checkbox > * { pointer-events: auto !i
 }
 
 /* Evaluate tab: enforce dark-blue text for labels/marks */
-#eval-tab .label, 
-#eval-tab label, 
+#eval-tab .label,
+#eval-tab label,
 #eval-tab .gr-slider .label,
 #eval-tab .wrap .label,
-#eval-tab .prose, 
-#eval-tab .markdown, 
-#eval-tab p, 
+#eval-tab .prose,
+#eval-tab .markdown,
+#eval-tab p,
 #eval-tab span {
   color: #cfe6ff !important; /* softer than pure white */
 }
 
 /* Target the specific k-slider label strongly */
-#k-slider .label, 
-#k-slider label, 
+#k-slider .label,
+#k-slider label,
 #k-slider .wrap .label {
   color: #cfe6ff !important;
   text-shadow: 0 1px 0 rgba(0,0,0,0.35);
 }
 
 /* Slider track/thumb (dark blue gradient + blue thumb) */
-#eval-tab input[type="range"] { 
+#eval-tab input[type="range"] {
   accent-color: #3b82f6 !important; /* fallback */
 }
 
@@ -1103,7 +1286,7 @@ input[type="checkbox"], .gr-checkbox, .gr-checkbox > * { pointer-events: auto !i
 }
 
 /* When Evaluate tab is active and JS has added .eval-active, bump contrast subtly */
-#eval-tab.eval-active .block, 
+#eval-tab.eval-active .block,
 #eval-tab.eval-active .group {
   border-color: #60a5fa !important;
 }
@@ -1114,7 +1297,7 @@ input[type="checkbox"], .gr-checkbox, .gr-checkbox > * { pointer-events: auto !i
 
 theme = gr.themes.Soft(
     primary_hue="blue",
-    neutral_hue="green"
+    neutral_hue="green",
 ).set(
     body_background_fill="#0b1020",
     body_text_color="#e0f2fe",
@@ -1128,7 +1311,8 @@ theme = gr.themes.Soft(
 
 with gr.Blocks(css=CSS, theme=theme, fill_height=True) as demo:
     # Optional: JS to toggle .eval-active when Evaluate tab selected
-    gr.HTML("""
+    gr.HTML(
+        """
     <script>
     (function(){
       const applyEvalActive = () => {
@@ -1150,14 +1334,14 @@ with gr.Blocks(css=CSS, theme=theme, fill_height=True) as demo:
       setTimeout(applyEvalActive, 300);
     })();
     </script>
-    """)
-    
+    """
+    )
+
     gr.Markdown(
         "<h1 style='margin:0'>Self-Sensing Concrete Assistant</h1>"
         "<p style='opacity:.9'>"
         "Left: ML prediction for Stress Gauge Factor (original scale, MPa<sup>-1</sup>). "
-        "Right: Literature Q&A via Hybrid RAG (BM25 + TF-IDF + optional dense) with MMR sentence selection. "
-        "Answers use APA-style inline citations (e.g., Omar et al., 2021, p. X)."
+        "Right: Literature Q&A via Hybrid RAG (BM25 + TF-IDF + optional dense) with MMR sentence selection."
         "</p>"
     )
 
@@ -1166,38 +1350,108 @@ with gr.Blocks(css=CSS, theme=theme, fill_height=True) as demo:
         with gr.Tab("🔮 Predict Gauge Factor (XGB)"):
             with gr.Row():
                 with gr.Column(scale=7):
-                    with gr.Accordion("Primary conductive filler", open=True, elem_classes=["card"]):
-                        f1_type = gr.Textbox(label="Filler 1 Type *", placeholder="e.g., CNT, Graphite, Steel fiber")
-                        f1_diam = gr.Number(label="Filler 1 Diameter (µm) *")
-                        f1_len  = gr.Number(label="Filler 1 Length (mm) *")
-                        cf_conc = gr.Number(label=f"{CF_COL} *", info="Weight percent of total binder")
-                        f1_dim  = gr.Dropdown(DIM_CHOICES, value=CANON_NA, label="Filler 1 Dimensionality *")
-
-                    with gr.Accordion("Secondary filler (optional)", open=False, elem_classes=["card"]):
-                        f2_type = gr.Textbox(label="Filler 2 Type", placeholder="Optional")
-                        f2_diam = gr.Number(label="Filler 2 Diameter (µm)")
-                        f2_len  = gr.Number(label="Filler 2 Length (mm)")
-                        f2_dim  = gr.Dropdown(DIM_CHOICES, value=CANON_NA, label="Filler 2 Dimensionality")
-
-                    with gr.Accordion("Mix design & specimen", open=False, elem_classes=["card"]):
-                        spec_vol  = gr.Number(label="Specimen Volume (mm3) *")
-                        probe_cnt = gr.Number(label="Probe Count *")
-                        probe_mat = gr.Textbox(label="Probe Material *", placeholder="e.g., Copper, Silver paste")
-                        wb        = gr.Number(label="W/B *")
-                        sb        = gr.Number(label="S/B *")
-                        gauge_len = gr.Number(label="Gauge Length (mm) *")
-                        curing    = gr.Textbox(label="Curing Condition *", placeholder="e.g., 28d water, 20°C")
-                        n_fillers = gr.Number(label="Number of Fillers *")
-
-                    with gr.Accordion("Processing", open=False, elem_classes=["card"]):
-                        dry_temp = gr.Number(label="Drying Temperature (°C)")
-                        dry_hrs  = gr.Number(label="Drying Duration (hr)")
-
-                    with gr.Accordion("Mechanical & electrical loading", open=False, elem_classes=["card"]):
-                        load_rate = gr.Number(label="Loading Rate (MPa/s)")
-                        E_mod     = gr.Number(label="Modulus of Elasticity (GPa) *")
-                        current   = gr.Dropdown(CURRENT_CHOICES, value=CANON_NA, label="Current Type")
-                        voltage   = gr.Number(label="Applied Voltage (V)")
+                    with gr.Accordion(
+                        "Primary conductive filler",
+                        open=True,
+                        elem_classes=["card"],
+                    ):
+                        f1_type = gr.Textbox(
+                            label="Filler 1 Type *",
+                            placeholder="e.g., CNT, Graphite, Steel fiber",
+                        )
+                        f1_diam = gr.Number(
+                            label="Filler 1 Diameter (µm) *"
+                        )
+                        f1_len = gr.Number(
+                            label="Filler 1 Length (mm) *"
+                        )
+                        cf_conc = gr.Number(
+                            label=f"{CF_COL} *",
+                            info="Weight percent of total binder",
+                        )
+                        f1_dim = gr.Dropdown(
+                            DIM_CHOICES,
+                            value=CANON_NA,
+                            label="Filler 1 Dimensionality *",
+                        )
+
+                    with gr.Accordion(
+                        "Secondary filler (optional)",
+                        open=False,
+                        elem_classes=["card"],
+                    ):
+                        f2_type = gr.Textbox(
+                            label="Filler 2 Type", placeholder="Optional"
+                        )
+                        f2_diam = gr.Number(
+                            label="Filler 2 Diameter (µm)"
+                        )
+                        f2_len = gr.Number(
+                            label="Filler 2 Length (mm)"
+                        )
+                        f2_dim = gr.Dropdown(
+                            DIM_CHOICES,
+                            value=CANON_NA,
+                            label="Filler 2 Dimensionality",
+                        )
+
+                    with gr.Accordion(
+                        "Mix design & specimen",
+                        open=False,
+                        elem_classes=["card"],
+                    ):
+                        spec_vol = gr.Number(
+                            label="Specimen Volume (mm3) *"
+                        )
+                        probe_cnt = gr.Number(
+                            label="Probe Count *"
+                        )
+                        probe_mat = gr.Textbox(
+                            label="Probe Material *",
+                            placeholder="e.g., Copper, Silver paste",
+                        )
+                        wb = gr.Number(label="W/B *")
+                        sb = gr.Number(label="S/B *")
+                        gauge_len = gr.Number(
+                            label="Gauge Length (mm) *"
+                        )
+                        curing = gr.Textbox(
+                            label="Curing Condition *",
+                            placeholder="e.g., 28d water, 20°C",
+                        )
+                        n_fillers = gr.Number(
+                            label="Number of Fillers *"
+                        )
+
+                    with gr.Accordion(
+                        "Processing", open=False, elem_classes=["card"]
+                    ):
+                        dry_temp = gr.Number(
+                            label="Drying Temperature (°C)"
+                        )
+                        dry_hrs = gr.Number(
+                            label="Drying Duration (hr)"
+                        )
+
+                    with gr.Accordion(
+                        "Mechanical & electrical loading",
+                        open=False,
+                        elem_classes=["card"],
+                    ):
+                        load_rate = gr.Number(
+                            label="Loading Rate (MPa/s)"
+                        )
+                        E_mod = gr.Number(
+                            label="Modulus of Elasticity (GPa) *"
+                        )
+                        current = gr.Dropdown(
+                            CURRENT_CHOICES,
+                            value=CANON_NA,
+                            label="Current Type",
+                        )
+                        voltage = gr.Number(
+                            label="Applied Voltage (V)"
+                        )
 
                 with gr.Column(scale=5):
                     with gr.Group(elem_classes=["card"]):
@@ -1205,32 +1459,54 @@ with gr.Blocks(css=CSS, theme=theme, fill_height=True) as demo:
                             label="Predicted Stress GF (MPa-1)",
                             value=0.0,
                             precision=6,
-                            elem_id="pred-out"
+                            elem_id="pred-out",
                         )
                         gr.Markdown(f"<small>{MODEL_STATUS}</small>")
                         with gr.Row():
-                            btn_pred  = gr.Button("Predict", variant="primary")
+                            btn_pred = gr.Button(
+                                "Predict", variant="primary"
+                            )
                             btn_clear = gr.Button("Clear")
-                            btn_demo  = gr.Button("Fill Example")
+                            btn_demo = gr.Button("Fill Example")
 
-                    with gr.Accordion("About this model", open=False, elem_classes=["card"]):
+                    with gr.Accordion(
+                        "About this model",
+                        open=False,
+                        elem_classes=["card"],
+                    ):
                         gr.Markdown(
                             "- Pipeline: ColumnTransformer → (RobustScaler + OneHot) → XGBoost\n"
-                            "- Target: Stress GF (MPa<sup>-1</sup>) on original scale "
-                            "(model may train on log1p; saved flag used at inference).\n"
+                            "- Target: Stress GF (MPa<sup>-1</sup>) on original scale (model may train on log1p; saved flag used at inference).\n"
                             "- Missing values are safely imputed per-feature.\n"
                             "- Trained columns:\n"
                             f"  `{', '.join(MAIN_VARIABLES)}`",
-                            elem_classes=["prose"]
+                            elem_classes=["prose"],
                         )
 
             inputs_in_order = [
-                f1_type, f1_diam, f1_len, cf_conc,
-                f1_dim,  f2_type, f2_diam, f2_len,
-                f2_dim,  spec_vol, probe_cnt, probe_mat,
-                wb, sb, gauge_len, curing, n_fillers,
-                dry_temp, dry_hrs, load_rate,
-                E_mod, current, voltage
+                f1_type,
+                f1_diam,
+                f1_len,
+                cf_conc,
+                f1_dim,
+                f2_type,
+                f2_diam,
+                f2_len,
+                f2_dim,
+                spec_vol,
+                probe_cnt,
+                probe_mat,
+                wb,
+                sb,
+                gauge_len,
+                curing,
+                n_fillers,
+                dry_temp,
+                dry_hrs,
+                load_rate,
+                E_mod,
+                current,
+                voltage,
             ]
 
             def _predict_wrapper(*vals):
@@ -1240,106 +1516,177 @@ with gr.Blocks(css=CSS, theme=theme, fill_height=True) as demo:
             btn_pred.click(
                 _predict_wrapper,
                 inputs=inputs_in_order,
-                outputs=out_pred
+                outputs=out_pred,
             )
             btn_clear.click(
                 lambda: _clear_all(),
                 inputs=None,
-                outputs=inputs_in_order
-            ).then(
-                lambda: 0.0,
-                outputs=out_pred
-            )
+                outputs=inputs_in_order,
+            ).then(lambda: 0.0, outputs=out_pred)
             btn_demo.click(
                 lambda: _fill_example(),
                 inputs=None,
-                outputs=inputs_in_order
+                outputs=inputs_in_order,
             )
 
         # ------------------------- Literature Tab -------------------------
-        with gr.Tab("📚 Ask the Literature (Hybrid RAG + MMR)", elem_id="rag-tab"):
+        with gr.Tab(
+            "📚 Ask the Literature (Hybrid RAG + MMR)", elem_id="rag-tab"
+        ):
             pdf_count = len(list(LOCAL_PDF_DIR.glob("**/*.pdf")))
             gr.Markdown(
                 f"Using local folder <code>papers/</code> — **{pdf_count} PDF(s)** indexed. "
-                "Upload more PDFs and reload the Space to expand coverage. "
-                "Answers use APA-like inline citations (e.g., Omar et al., 2021, p. X)."
+                "Upload more PDFs and reload the Space to expand coverage. Answers use APA-style inline citations."
             )
             with gr.Row():
-                top_k = gr.Slider(5, 12, value=8, step=1, label="Top-K chunks")
-                n_sentences = gr.Slider(2, 6, value=4, step=1, label="Answer length (sentences)")
+                top_k = gr.Slider(
+                    5,
+                    12,
+                    value=8,
+                    step=1,
+                    label="Top-K chunks",
+                )
+                n_sentences = gr.Slider(
+                    2,
+                    6,
+                    value=4,
+                    step=1,
+                    label="Answer length (sentences)",
+                )
                 include_passages = gr.Checkbox(
                     value=False,
                     label="Include supporting passages",
-                    interactive=True
+                    interactive=True,
                 )
 
-            with gr.Accordion("Retriever weights (advanced)", open=False):
-                w_tfidf = gr.Slider(0.0, 1.0, value=W_TFIDF_DEFAULT, step=0.05, label="TF-IDF weight")
-                w_bm25  = gr.Slider(0.0, 1.0, value=W_BM25_DEFAULT,  step=0.05, label="BM25 weight")
-                w_emb   = gr.Slider(
-                    0.0, 1.0,
+            with gr.Accordion(
+                "Retriever weights (advanced)", open=False
+            ):
+                w_tfidf = gr.Slider(
+                    0.0,
+                    1.0,
+                    value=W_TFIDF_DEFAULT,
+                    step=0.05,
+                    label="TF-IDF weight",
+                )
+                w_bm25 = gr.Slider(
+                    0.0,
+                    1.0,
+                    value=W_BM25_DEFAULT,
+                    step=0.05,
+                    label="BM25 weight",
+                )
+                w_emb = gr.Slider(
+                    0.0,
+                    1.0,
                     value=(0.0 if not USE_DENSE else 0.40),
                     step=0.05,
-                    label="Dense weight (set 0 if disabled)"
+                    label="Dense weight (set 0 if disabled)",
                 )
 
             # Hidden states (unchanged)
-            state_use_llm     = gr.State(LLM_AVAILABLE)
-            state_model_name  = gr.State(os.getenv("OPENAI_MODEL", OPENAI_MODEL))
+            state_use_llm = gr.State(LLM_AVAILABLE)
+            state_model_name = gr.State(
+                os.getenv("OPENAI_MODEL", OPENAI_MODEL)
+            )
             state_temperature = gr.State(0.2)
-            state_strict      = gr.State(False)
+            state_strict = gr.State(False)
 
             gr.ChatInterface(
                 fn=rag_chat_fn,
                 additional_inputs=[
-                    top_k, n_sentences, include_passages,
-                    state_use_llm, state_model_name, state_temperature, state_strict,
-                    w_tfidf, w_bm25, w_emb
+                    top_k,
+                    n_sentences,
+                    include_passages,
+                    state_use_llm,
+                    state_model_name,
+                    state_temperature,
+                    state_strict,
+                    w_tfidf,
+                    w_bm25,
+                    w_emb,
                 ],
                 title="Literature Q&A",
-                description="Hybrid retrieval with diversity. Answers carry APA-style inline citations."
+                description=(
+                    "Hybrid retrieval with diversity. Answers carry APA-style inline citations "
+                    "derived from paper_citations.csv."
+                ),
             )
 
-        # ====== Evaluate (Gold vs Logs) — darker, higher-contrast ======
-        with gr.Tab("📏 Evaluate (Gold vs Logs)", elem_id="eval-tab"):
-            gr.Markdown("Upload your **gold.csv** and compute metrics against the app logs.")
+        # ====== Evaluate (Gold vs Logs) ======
+        with gr.Tab(
+            "📏 Evaluate (Gold vs Logs)", elem_id="eval-tab"
+        ):
+            gr.Markdown(
+                "Upload your **gold.csv** and compute retrieval metrics against the app logs."
+            )
             with gr.Row():
-                gold_file = gr.File(label="gold.csv", file_types=[".csv"], interactive=True)
-                k_slider  = gr.Slider(3, 12, value=8, step=1,
-                                      label="k for Hit/Recall/nDCG", elem_id="k-slider")
+                gold_file = gr.File(
+                    label="gold.csv",
+                    file_types=[".csv"],
+                    interactive=True,
+                )
+                k_slider = gr.Slider(
+                    3,
+                    12,
+                    value=8,
+                    step=1,
+                    label="k for Hit/Recall/nDCG",
+                    elem_id="k-slider",
+                )
             with gr.Row():
-                btn_eval = gr.Button("Compute Metrics", variant="primary")
+                btn_eval = gr.Button(
+                    "Compute Metrics", variant="primary"
+                )
             with gr.Row():
-                out_perq = gr.File(label="Per-question metrics (CSV)", elem_id="perq-file")
-                out_agg  = gr.File(label="Aggregate metrics (JSON)", elem_id="agg-file")
-            out_json = gr.JSON(label="Aggregate summary", elem_id="agg-json")
-            out_log  = gr.Markdown(label="Run log", elem_id="eval-log")
+                out_perq = gr.File(
+                    label="Per-question metrics (CSV)",
+                    elem_id="perq-file",
+                )
+                out_agg = gr.File(
+                    label="Aggregate metrics (JSON)",
+                    elem_id="agg-file",
+                )
+            out_json = gr.JSON(
+                label="Aggregate summary", elem_id="agg-json"
+            )
+            out_log = gr.Markdown(
+                label="Run log", elem_id="eval-log"
+            )
 
             def _run_eval_inproc(gold_path: str, k: int = 8):
                 import json as _json
+
                 out_dir = str(ARTIFACT_DIR)
                 logs = str(LOG_PATH)
                 cmd = [
-                    sys.executable, "rag_eval_metrics.py",
-                    "--gold_csv", gold_path,
-                    "--logs_jsonl", logs,
-                    "--k", str(k),
-                    "--out_dir", out_dir
+                    sys.executable,
+                    "rag_eval_metrics.py",
+                    "--gold_csv",
+                    gold_path,
+                    "--logs_jsonl",
+                    logs,
+                    "--k",
+                    str(k),
+                    "--out_dir",
+                    out_dir,
                 ]
                 try:
                     p = subprocess.run(
                         cmd,
                         capture_output=True,
                         text=True,
-                        check=False
+                        check=False,
                     )
                     stdout = p.stdout or ""
                     stderr = p.stderr or ""
                     perq = ARTIFACT_DIR / "metrics_per_question.csv"
-                    agg  = ARTIFACT_DIR / "metrics_aggregate.json"
+                    agg = ARTIFACT_DIR / "metrics_aggregate.json"
                     agg_json = {}
                     if agg.exists():
-                        agg_json = _json.loads(agg.read_text(encoding="utf-8"))
+                        agg_json = _json.loads(
+                            agg.read_text(encoding="utf-8")
+                        )
                     report = (
                         "```\n"
                         + (stdout.strip() or "(no stdout)")
@@ -1348,19 +1695,30 @@ with gr.Blocks(css=CSS, theme=theme, fill_height=True) as demo:
                     )
                     return (
                         str(perq) if perq.exists() else None,
-                        str(agg)  if agg.exists()  else None,
+                        str(agg) if agg.exists() else None,
                         agg_json,
-                        report
+                        report,
                     )
                 except Exception as e:
-                    return (None, None, {}, f"**Eval error:** {e}")
+                    return (
+                        None,
+                        None,
+                        {},
+                        f"**Eval error:** {e}",
+                    )
 
             def _eval_wrapper(gf, k):
-                from pathlib import Path as _Path
+                from pathlib import Path as _P
+
                 if gf is None:
-                    default_gold = _Path("gold.csv")
+                    default_gold = _P("gold.csv")
                     if not default_gold.exists():
-                        return None, None, {}, "**No gold.csv provided or found in repo root.**"
+                        return (
+                            None,
+                            None,
+                            {},
+                            "**No gold.csv provided or found in repo root.**",
+                        )
                     gold_path = str(default_gold)
                 else:
                     gold_path = gf.name
@@ -1369,23 +1727,14 @@ with gr.Blocks(css=CSS, theme=theme, fill_height=True) as demo:
             btn_eval.click(
                 _eval_wrapper,
                 inputs=[gold_file, k_slider],
-                outputs=[out_perq, out_agg, out_json, out_log]
+                outputs=[out_perq, out_agg, out_json, out_log],
             )
 
 # ------------- Launch -------------
 if __name__ == "__main__":
     demo.queue().launch()
-
-    import os
-    import pandas as pd
-
-    # Folder where your RAG files are stored
-    folder = "papers"  # change if needed
-
-    # List all files in the folder
-    files = sorted(os.listdir(folder))
-
-    # Save them to a CSV file
+    # Build/update paper_list.csv for convenience
+    folder = "papers"
+    files = sorted(os.listdir(folder)) if os.path.isdir(folder) else []
     pd.DataFrame({"doc": files}).to_csv("paper_list.csv", index=False)
-
-    print("✅ Saved paper_list.csv with", len(files), "papers")
+    print(f"✅ Saved paper_list.csv with {len(files)} papers")