Upload 2 files

.gitattributes

@@ -35,3 +35,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 DM[[:space:]](1).xlsx filter=lfs diff=lfs merge=lfs -text
 DM.xlsx filter=lfs diff=lfs merge=lfs -text
+DM[[:space:]](3).xlsx filter=lfs diff=lfs merge=lfs -text

DM (3).xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da6461e3d4f644f26ca21b99e1d8c5941e1d404c3fb8f23ba3353cd3d81049a8
+size 20060833

app (11).py

@@ -0,0 +1,1678 @@
+import os
+import re
+import tempfile
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+from huggingface_hub import InferenceClient
+from sklearn.preprocessing import PowerTransformer
+
+# ============================================================
+# 1. KONFIGURASI FILE & PARAMETER
+# ============================================================
+
+DATA_FILE       = "DM.xlsx"                       # data utama perpustakaan
+META_KAB_FILE   = "jumlahdesa_fixed.xlsx"         # kecamatan & desa/kel per kab/kota
+META_SDSMP_FILE = "jumlah_SD_SMP.xlsx"            # jumlah SD & SMP per kab/kota
+META_SMA_FILE   = "Data_SMA_propinsi_update.xlsx" # jumlah SMA per provinsi
+
+# Kelompok indikator IPLM
+koleksi_cols = [
+    "JudulTercetak","EksemplarTercetak","JudulElektronik","EksemplarElektronik",
+    "TambahJudulTercetak","TambahEksemplarTercetak",
+    "TambahJudulElektronik","TambahEksemplarElektronik",
+    "KomitmenAnggaranKoleksi"
+]
+sdm_cols = [
+    "TenagaKualifikasiIlmuPerpustakaan",
+    "TenagaFungsionalProfesional",
+    "TenagaPKB",
+    "AnggaranTenaga"
+]
+pelayanan_cols = [
+    "PesertaBudayaBaca","PemustakaLuringDaring","PemustakaFasilitasTIK",
+    "PemanfaatanJudulTercetak","PemanfaatanEksemplarTercetak",
+    "PemanfaatanJudulElektronik","PemanfaatanEksemplarElektronik"
+]
+pengelolaan_cols = [
+    "KegiatanBudayaBaca","KegiatanKerjasama","VariasiLayanan","Kebijakan","AnggaranLayanan"
+]
+all_indicators = koleksi_cols + sdm_cols + pelayanan_cols + pengelolaan_cols
+
+# Bobot indeks IPLM
+w_kepatuhan = 0.30
+w_kinerja   = 0.70
+
+# Bobot untuk Confidence
+W_DATA   = 0.7
+W_SAMPLE = 0.3
+SAMPLE_THRESHOLD = 10   # ambang jumlah perpus per kab/kota
+
+# Target normatif per jenis perpustakaan
+TARGETS = {
+    "sekolah": {
+        "JudulTercetak": 1000,
+        "EksemplarTercetak": 5000,
+        "KegiatanBudayaBaca": 12,
+        "PemustakaLuringDaring": 1000,
+    },
+    "umum": {
+        "JudulTercetak": 500,
+        "EksemplarTercetak": 1000,
+        "KegiatanBudayaBaca": 24,
+        "PemustakaLuringDaring": 1000,
+        "VariasiLayanan": 7,
+        "TenagaKualifikasiIlmuPerpustakaan": 1,
+    },
+    "khusus": {
+        "JudulTercetak": 5000,
+        "EksemplarTercetak": 10000,
+        "KegiatanBudayaBaca": 6,
+        "PemustakaLuringDaring": 1000,
+    }
+}
+
+# ============================================================
+# 1b. KONFIGURASI LLM (Hugging Face Inference)
+# ============================================================
+
+USE_LLM = True
+
+# Pilih salah satu model yang kompatibel
+LLM_MODEL_NAME = "meta-llama/Meta-Llama-3-8B-Instruct"
+# LLM_MODEL_NAME = "mistralai/Mistral-7B-Instruct-v0.2"
+
+HF_TOKEN = (
+    os.getenv("HF_TOKEN")
+    or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    or os.getenv("HF_API_TOKEN")
+)
+
+_HF_CLIENT = None
+
+
+def get_llm_client():
+    """
+    Inisialisasi InferenceClient sekali, lalu dipakai ulang.
+    Kalau gagal (misal token salah / model tidak support), kembalikan None.
+    """
+    global _HF_CLIENT
+    if _HF_CLIENT is not None:
+        return _HF_CLIENT
+
+    try:
+        if HF_TOKEN:
+            _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME, token=HF_TOKEN)
+        else:
+            _HF_CLIENT = InferenceClient(model=LLM_MODEL_NAME)
+        return _HF_CLIENT
+    except Exception:
+        _HF_CLIENT = None
+        return None
+
+
+# ============================================================
+# 2. FUNGSI UTIL
+# ============================================================
+
+def _canon(s: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "", str(s).lower())
+
+
+def coerce_num(val):
+    if pd.isna(val):
+        return np.nan
+    t = str(val).strip()
+    if t == "" or t in {"-", "–", "—"}:
+        return np.nan
+    t = t.replace("\u00a0", " ").replace("Rp", "").replace("%", "")
+    t = re.sub(r"[^0-9,.\-]", "", t)
+    if t.count(".") > 1 and t.count(",") == 1:
+        t = t.replace(".", "").replace(",", ".")
+    elif t.count(",") > 1 and t.count(".") == 1:
+        t = t.replace(",", "")
+    elif t.count(",") == 1 and t.count(".") == 0:
+        t = t.replace(",", ".")
+    else:
+        t = t.replace(",", "")
+    try:
+        return float(t)
+    except Exception:
+        return np.nan
+
+
+def minmax_norm(s: pd.Series) -> pd.Series:
+    x = s.astype(float)
+    mn, mx = x.min(skipna=True), x.max(skipna=True)
+    if pd.isna(mn) or pd.isna(mx) or mx == mn:
+        return pd.Series(0.0, index=s.index)
+    return (x - mn) / (mx - mn)
+
+
+def pick_col(df, candidates):
+    """
+    Pilih kolom dari daftar kandidat dengan:
+    1) Cocok nama persis dulu
+    2) Kalau tidak ada, pakai versi canonical (_canon)
+    """
+    for c in candidates:
+        if c in df.columns:
+            return c
+    can_map = {_canon(c): c for c in df.columns}
+    for c in candidates:
+        k = _canon(c)
+        if k in can_map:
+            return can_map[k]
+    return None
+
+
+def norm_kew(v):
+    if pd.isna(v):
+        return None
+    t = str(v).strip().upper()
+    if "KAB" in t or "KOTA" in t:
+        return "KAB/KOTA"
+    if "PROV" in t:
+        return "PROVINSI"
+    if "PUSAT" in t or "NASIONAL" in t:
+        return "PUSAT"
+    return t
+
+
+def _norm_text(x):
+    if pd.isna(x):
+        return None
+    t = str(x).strip().upper()
+    return " ".join(t.split())
+
+
+def penalized_mean(row, cols):
+    vals = []
+    for c in cols:
+        colname = f"norm_{c}"
+        if colname in row.index:
+            v = row[colname]
+            if pd.isna(v):
+                v = 0.0
+            vals.append(v)
+    if not vals:
+        return np.nan
+    return float(np.sum(vals) / len(vals))
+
+
+def skor_normatif(value, target):
+    if pd.isna(value):
+        return 0.0
+    return min(float(value) / target, 1.0)
+
+
+def slugify(s: str) -> str:
+    if s is None:
+        return "NA"
+    t = str(s).strip()
+    if t == "":
+        return "NA"
+    return _canon(t).upper()
+
+
+def norm_prov_label(s):
+    """
+    Normalisasi nama provinsi agar konsisten di semua file:
+    - Hilangkan kata 'PROVINSI' / 'PROPINSI'
+    - Hilangkan spasi ganda & non-alnum
+    - Uppercase
+    """
+    if pd.isna(s):
+        return None
+    t = str(s).upper()
+    for bad in ["PROVINSI", "PROPINSI"]:
+        t = t.replace(bad, "")
+    t = " ".join(t.split())
+    return re.sub(r"[^A-Z0-9]+", "", t)
+
+
+def norm_kab_label(s):
+    """
+    Normalisasi nama Kab/Kota tapi tetap membedakan:
+    - 'Kabupaten Bandung' -> 'KABBANDUNG'
+    - 'Kota Bandung'      -> 'KOTABANDUNG'
+    Dipakai untuk:
+    - DM.xlsx
+    - jumlahdesa_fixed.xlsx
+    - jumlah_SD_SMP.xlsx
+    """
+    if pd.isna(s):
+        return None
+
+    t = str(s).upper()
+    t = t.replace("KABUPATEN", "KAB")
+    t = t.replace("KAB.", "KAB")
+    t = t.replace("KAB  ", "KAB ")
+
+    t = t.replace("KOTA ADMINISTRASI", "KOTA")
+    t = t.replace("KOTA ADM.", "KOTA")
+    t = t.replace("KOTA.", "KOTA")
+
+    t = " ".join(t.split())
+    return re.sub(r"[^A-Z0-9]+", "", t)
+
+
+# ============================================================
+# 3. LOAD DATA DM.xlsx + META
+# ============================================================
+
+DATA_INFO = ""
+df_all_raw = None
+meta_kab_df = None
+meta_sma_df = None
+
+prov_col_glob = kab_col_glob = kew_col_glob = jenis_col_glob = nama_col_glob = None
+
+try:
+    fp = Path(DATA_FILE)
+    if not fp.exists():
+        raise FileNotFoundError(f"File tidak ditemukan: {DATA_FILE}")
+
+    xls = pd.ExcelFile(fp)
+    frames = [pd.read_excel(fp, sheet_name=s) for s in xls.sheet_names]
+    df_all_raw = pd.concat(frames, ignore_index=True, sort=False)
+
+    prov_col_glob  = pick_col(df_all_raw, ["provinsi", "Provinsi", "PROVINSI"])
+    kab_col_glob   = pick_col(df_all_raw, ["kab_kota", "Kab_Kota", "Kab/Kota", "KAB/KOTA", "kabupaten_kota", "kota"])
+    kew_col_glob   = pick_col(df_all_raw, ["kewenangan", "jenis_kewenangan", "Kewenangan", "KEWENANGAN"])
+    jenis_col_glob = pick_col(df_all_raw, ["jenis_perpustakaan", "JENIS_PERPUSTAKAAN", "Jenis Perpustakaan", "jenis perpustakaan"])
+    nama_col_glob  = pick_col(df_all_raw, ["nama_perpustakaan", "nm_perpustakaan", "nm_instansi_lembaga", "Nama Perpustakaan"])
+
+    if kew_col_glob:
+        df_all_raw["KEW_NORM"] = df_all_raw[kew_col_glob].apply(norm_kew)
+    else:
+        df_all_raw["KEW_NORM"] = None
+
+    val_map_jenis = {
+        "PERPUSTAKAAN SEKOLAH": "sekolah",
+        "SEKOLAH": "sekolah",
+        "PERPUSTAKAAN UMUM": "umum",
+        "UMUM": "umum",
+        "PERPUSTAKAAN DAERAH": "umum",
+        "PERPUSTAKAAN KHUSUS": "khusus",
+        "KHUSUS": "khusus",
+    }
+    if jenis_col_glob:
+        df_all_raw["_dataset"] = df_all_raw[jenis_col_glob].apply(_norm_text).map(val_map_jenis)
+    else:
+        df_all_raw["_dataset"] = None
+
+    def all_prov_choices():
+        if prov_col_glob is None:
+            return ["(Semua)"]
+        s = df_all_raw[prov_col_glob].dropna().astype(str).str.strip()
+        vals = sorted([o for o in s.unique() if o != ""])
+        return ["(Semua)"] + vals
+
+    def get_kab_choices_for_prov(prov_value):
+        if kab_col_glob is None:
+            return ["(Semua)"]
+        if prov_value is None or prov_value == "(Semua)" or prov_col_glob is None:
+            s = df_all_raw[kab_col_glob].dropna().astype(str).str.strip()
+        else:
+            m = df_all_raw[prov_col_glob].astype(str).str.strip() == prov_value
+            s = df_all_raw.loc[m, kab_col_glob].dropna().astype(str).str.strip()
+        vals = sorted([x for x in s.unique() if x != ""])
+        return ["(Semua)"] + vals
+
+    def all_kew_choices():
+        s = df_all_raw["KEW_NORM"].dropna().astype(str).str.strip()
+        vals = sorted([o for o in s.unique() if o != ""])
+        if not vals:
+            return ["(Semua)"]
+        return ["(Semua)"] + vals
+
+    prov_choices = all_prov_choices()
+    kab_choices  = get_kab_choices_for_prov(prov_choices[0] if prov_choices else "(Semua)")
+    kew_choices  = all_kew_choices()
+    default_kew  = "KAB/KOTA" if "KAB/KOTA" in kew_choices else kew_choices[0]
+
+    DATA_INFO = f"Data terbaca dari: **{DATA_FILE}** | Jumlah baris: **{len(df_all_raw)}**"
+except Exception as e:
+    df_all_raw = None
+    prov_choices = kab_choices = kew_choices = ["(Semua)"]
+    default_kew = "(Semua)"
+    DATA_INFO = f"⚠️ Gagal memuat data dari file: `{DATA_FILE}`\n\nError: `{e}`"
+
+# 3b. META KECAMATAN/DESA + SD/SMP + SMA
+extra_info = []
+
+# --- jumlah kecamatan & desa/kel per kab/kota ---
+try:
+    meta_kab_raw = pd.read_excel(META_KAB_FILE)
+    col_kab = pick_col(meta_kab_raw, ["Kab/Kota", "Kab_Kota", "kab/kota", "kabupaten_kota"])
+    col_kec = pick_col(meta_kab_raw, ["Kecamatan", "jml_kecamatan", "jumlah_kecamatan"])
+    col_des = pick_col(meta_kab_raw, ["Desa/Kel", "Desa Kelurahan", "Desa", "Desa_kel"])
+
+    if col_kab and col_kec and col_des:
+        meta_kab_df = pd.DataFrame({
+            "Kab_Kota_Label": meta_kab_raw[col_kab].astype(str).str.strip(),
+            "Jml_Kecamatan":  meta_kab_raw[col_kec].apply(coerce_num),
+            "Jml_DesaKel":    meta_kab_raw[col_des].apply(coerce_num),
+        })
+        meta_kab_df["kab_key"] = meta_kab_df["Kab_Kota_Label"].apply(norm_kab_label)
+        extra_info.append(f"Verifikasi Kab/Kota (Kec/Desa) dari **{META_KAB_FILE}** (n={len(meta_kab_df)})")
+    else:
+        meta_kab_df = None
+        extra_info.append(f"Verifikasi Kab/Kota: kolom kunci tidak lengkap di `{META_KAB_FILE}`")
+except Exception as e:
+    meta_kab_df = None
+    extra_info.append(f"⚠️ Gagal memuat `{META_KAB_FILE}` ({e})")
+
+# --- jumlah SD & SMP per kab/kota ---
+try:
+    sd_smp_raw = pd.read_excel(META_SDSMP_FILE)
+    col_kab2 = pick_col(sd_smp_raw, [
+        "Kabupaten/Kota_Kabupaten/Kota", "Kabupaten/Kota",
+        "Kab/Kota", "Kab_Kota", "kab/kota", "kabupaten_kota"
+    ])
+    col_sd   = pick_col(sd_smp_raw, ["SD", "Jumlah SD", "Total SD", "SD_Total", "jml_sd", "Jml_SD"])
+    col_smp  = pick_col(sd_smp_raw, ["SMP", "Jumlah SMP", "Total SMP", "SMP_Total", "jml_smp", "Jml_SMP"])
+
+    if col_kab2 and (col_sd or col_smp):
+        df_sd_smp = pd.DataFrame({
+            "Kab_Kota_Label_SD": sd_smp_raw[col_kab2].astype(str).str.strip(),
+        })
+        df_sd_smp["Jml_SD"]  = sd_smp_raw[col_sd].apply(coerce_num) if col_sd else 0.0
+        df_sd_smp["Jml_SMP"] = sd_smp_raw[col_smp].apply(coerce_num) if col_smp else 0.0
+
+        df_sd_smp["kab_key"] = df_sd_smp["Kab_Kota_Label_SD"].apply(norm_kab_label)
+
+        df_sd_smp_grp = df_sd_smp.groupby("kab_key", as_index=False).agg({
+            "Jml_SD": "sum",
+            "Jml_SMP": "sum",
+        })
+
+        if meta_kab_df is not None:
+            meta_kab_df = meta_kab_df.merge(
+                df_sd_smp_grp,
+                on="kab_key",
+                how="left"
+            )
+        else:
+            meta_kab_df = df_sd_smp_grp.copy()
+            meta_kab_df["Kab_Kota_Label"] = df_sd_smp.groupby("kab_key")["Kab_Kota_Label_SD"].first().values
+
+        extra_info.append(
+            f"Data SD/SMP per Kab/Kota dari **{META_SDSMP_FILE}** ditambahkan (n={len(df_sd_smp_grp)})"
+        )
+    else:
+        extra_info.append(f"Data SD/SMP: kolom kunci tidak lengkap di `{META_SDSMP_FILE}`")
+except Exception as e:
+    extra_info.append(f"⚠️ Gagal memuat `{META_SDSMP_FILE}` ({e})")
+
+# --- jumlah SMA per provinsi ---
+try:
+    meta_sma_raw = pd.read_excel(META_SMA_FILE)
+
+    col_prov_sma = pick_col(meta_sma_raw, [
+        "Provinsi", "provinsi", "PROVINSI", "NAMA_PROVINSI", "Nama Provinsi",
+        "nm_prov", "nm_provinsi", "prov"
+    ])
+    # Fokus pada kolom TOTAL / Jml_SMA / SMA / Total SMA / SMA_Total
+    col_sma = pick_col(meta_sma_raw, [
+        "Total SMA", "TOTAL_SMA", "TOTAL", "total",
+        "Jml_SMA", "Jumlah SMA", "SMA", "SMA_Total",
+        "jumlah_sma", "total_sma", "jml_sma"
+    ])
+
+    if col_prov_sma is None:
+        raise ValueError("Kolom provinsi tidak ditemukan dalam file SMA.")
+    if col_sma is None:
+        raise ValueError("Kolom total jumlah SMA tidak ditemukan.")
+
+    meta_sma_df = pd.DataFrame({
+        "Provinsi_Label": meta_sma_raw[col_prov_sma].astype(str).str.strip(),
+        "Jml_SMA":        meta_sma_raw[col_sma].apply(coerce_num),
+    })
+    # Normalisasi nama provinsi agar konsisten dengan DM
+    meta_sma_df["prov_key"] = meta_sma_df["Provinsi_Label"].apply(norm_prov_label)
+    # Jika ada duplikat (misal variasi penulisan), agregasi ke total per prov_key
+    meta_sma_df = meta_sma_df.groupby(["prov_key", "Provinsi_Label"], as_index=False).agg(
+        {"Jml_SMA": "sum"}
+    )
+
+    extra_info.append(f"Verifikasi SMA per Provinsi berhasil dimuat ({len(meta_sma_df)} provinsi).")
+except Exception as e:
+    meta_sma_df = None
+    extra_info.append(f"⚠️ Gagal memuat file SMA: {e}")
+
+if extra_info:
+    DATA_INFO = DATA_INFO + "<br>" + "<br>".join(extra_info)
+
+
+# ============================================================
+# 4. BELL CURVE
+# ============================================================
+
+def make_bell_figure(df_all: pd.DataFrame,
+                     title: str,
+                     index_col: str = "Indeks_Real_0_100",
+                     name_col: str = None,
+                     min_points: int = 5) -> go.Figure:
+
+    fig = go.Figure()
+
+    if index_col not in df_all.columns:
+        fig.update_layout(
+            title=title,
+            xaxis_title="Indeks (0–100)",
+            yaxis_title="Kepadatan (relatif)",
+        )
+        return fig
+
+    df_plot = df_all.copy()
+    df_plot = df_plot[pd.notna(df_plot[index_col])]
+
+    if df_plot.empty or len(df_plot) < min_points:
+        fig.update_layout(
+            title=title,
+            xaxis_title="Indeks (0–100)",
+            yaxis_title="Kepadatan (relatif)",
+            annotations=[
+                dict(
+                    text="Grafik tidak ditampilkan (data terlalu sedikit).",
+                    x=0.5, y=0.5, xref="paper", yref="paper",
+                    showarrow=False, font=dict(size=14)
+                )
+            ]
+        )
+        return fig
+
+    x_vals = df_plot[index_col].values.astype(float)
+    mu = x_vals.mean()
+    sigma = x_vals.std(ddof=1) if len(x_vals) > 1 else 1.0
+
+    xs = np.linspace(max(0, x_vals.min() - 5), min(100, x_vals.max() + 5), 200)
+    pdf = (1.0 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((xs - mu) / sigma) ** 2)
+    pdf = pdf / pdf.max()
+    y_max = 1.0
+
+    if name_col and name_col in df_plot.columns:
+        hover_text = [
+            f"{str(n)}<br>Indeks: {v:.2f}"
+            for n, v in zip(df_plot[name_col], x_vals)
+        ]
+    else:
+        hover_text = [f"Indeks: {v:.2f}" for v in x_vals]
+
+    fig.add_trace(go.Scatter(
+        x=xs,
+        y=pdf,
+        mode="lines",
+        name="Bell curve",
+        hoverinfo="skip"
+    ))
+
+    fig.add_trace(go.Scatter(
+        x=x_vals,
+        y=np.zeros_like(x_vals),
+        mode="markers",
+        name="Perpustakaan",
+        hovertext=hover_text,
+        hovertemplate="%{hovertext}<extra></extra>"
+    ))
+
+    q1, q2, q3 = np.quantile(x_vals, [0.25, 0.5, 0.75])
+    for q, label in [(q1, "Q1"), (q2, "Q2 (Median)"), (q3, "Q3")]:
+        fig.add_trace(go.Scatter(
+            x=[q, q],
+            y=[0, y_max * 1.05],
+            mode="lines",
+            name=label,
+            hovertemplate=f"{label}: {q:.2f}<extra></extra>"
+        ))
+
+    fig.update_layout(
+        title=title,
+        xaxis_title="Indeks IPLM (0–100)",
+        yaxis_title="Kepadatan (relatif)",
+        yaxis=dict(showticklabels=False, zeroline=True, range=[0, y_max * 1.2]),
+        margin=dict(l=40, r=20, t=60, b=40),
+        hovermode="x"
+    )
+
+    return fig
+
+
+# ============================================================
+# 5. PIPELINE REALSCORE + NORMATIF
+# ============================================================
+
+def run_pipeline_core(df_subset: pd.DataFrame, kab_name=None, kew_name=None):
+    df = df_subset.copy()
+    df_raw = df_subset.copy()
+
+    canonical_targets = set(all_indicators)
+    alias_map_raw = {
+        "j_judul_koleksi_tercetak": "JudulTercetak",
+        "j_eksemplar_koleksi_tercetak": "EksemplarTercetak",
+        "j_judul_koleksi_digital": "JudulElektronik",
+        "j_eksemplar_koleksi_digital": "EksemplarElektronik",
+        "tambah_judul_koleksi_tercetak": "TambahJudulTercetak",
+        "tambah_eksemplar_koleksi_tercetak": "TambahEksemplarTercetak",
+        "tambah_judul_koleksi_digital": "TambahJudulElektronik",
+        "tambah_eksemplar_koleksi_digital": "TambahEksemplarElektronik",
+        "j_anggaran_koleksi": "KomitmenAnggaranKoleksi",
+        "j_tenaga_ilmu_perpus": "TenagaKualifikasiIlmuPerpustakaan",
+        "j_tenaga_nonilmu_perpus": "TenagaFungsionalProfesional",
+        "j_tenaga_pkb": "TenagaPKB",
+        "j_anggaran_diklat_perpus": "AnggaranTenaga",
+        "j_peserta_budaya_baca": "PesertaBudayaBaca",
+        "j_pemustaka_luring_daring": "PemustakaLuringDaring",
+        "j_pemustaka_fasilitas_tik": "PemustakaFasilitasTIK",
+        "j_judul_koleksi_tercetak_termanfaat": "PemanfaatanJudulTercetak",
+        "j_eksemplar_koleksi_tercetak_termanfaat": "PemanfaatanEksemplarTercetak",
+        "j_judul_koleksi_digital_termanfaat": "PemanfaatanJudulElektronik",
+        "j_eksemplar_koleksi_digital_termanfaat": "PemanfaatanEksemplarElektronik",
+        "j_kegiatan_budaya_baca_peningkatan_literasi": "KegiatanBudayaBaca",
+        "j_kerjasama_pengembangan_perpus": "KegiatanKerjasama",
+        "j_variasi_layanan": "VariasiLayanan",
+        "j_kebijakan_prosedur_pelayanan": "Kebijakan",
+        "j_anggaran_peningkatan_pelayanan": "AnggaranLayanan"
+    }
+    alias_map = {_canon(k): v for k, v in alias_map_raw.items()}
+
+    rename_map = {}
+    for col in list(df.columns):
+        ccol = _canon(col)
+        if ccol in alias_map:
+            rename_map[col] = alias_map[ccol]
+        else:
+            for tgt in canonical_targets:
+                if ccol == _canon(tgt):
+                    rename_map[col] = tgt
+                    break
+    if rename_map:
+        df = df.rename(columns=rename_map)
+
+    available_indicators = [c for c in all_indicators if c in df.columns]
+    for c in available_indicators:
+        df[c] = df[c].apply(coerce_num)
+
+    # Yeo–Johnson + MinMax
+    yj_cols = []
+    for c in available_indicators:
+        yj_col = f"yj_{c}"
+        x = df[c].astype(float).values
+        mask = ~np.isnan(x)
+        transformed = np.full_like(x, np.nan, dtype=float)
+        if mask.sum() > 1:
+            pt = PowerTransformer(method="yeo-johnson", standardize=False)
+            transformed[mask] = pt.fit_transform(x[mask].reshape(-1, 1)).ravel()
+        else:
+            transformed[mask] = x[mask]
+        df[yj_col] = transformed
+        yj_cols.append(yj_col)
+
+    for yj_col in yj_cols:
+        base = yj_col[3:]
+        df[f"norm_{base}"] = minmax_norm(df[yj_col])
+
+    # Sub-indeks real
+    df["sub_koleksi"]     = df.apply(lambda r: penalized_mean(r, [c for c in koleksi_cols    if c in available_indicators]), axis=1)
+    df["sub_sdm"]         = df.apply(lambda r: penalized_mean(r, [c for c in sdm_cols        if c in available_indicators]), axis=1)
+    df["sub_pelayanan"]   = df.apply(lambda r: penalized_mean(r, [c for c in pelayanan_cols  if c in available_indicators]), axis=1)
+    df["sub_pengelolaan"] = df.apply(lambda r: penalized_mean(r, [c for c in pengelolaan_cols if c in available_indicators]), axis=1)
+
+    df["dim_kepatuhan"] = df[["sub_koleksi", "sub_sdm"]].mean(axis=1)
+    df["dim_kinerja"]   = df[["sub_pelayanan", "sub_pengelolaan"]].mean(axis=1)
+
+    df["Indeks_Real_0_100"] = 100 * (w_kepatuhan * df["dim_kepatuhan"] + w_kinerja * df["dim_kinerja"])
+
+    # Confidence
+    df["n_ind_filled"] = df[available_indicators].notna().sum(axis=1)
+    df["n_ind_total"]  = len(available_indicators)
+
+    df["Confidence_Data"] = np.where(
+        df["n_ind_total"] > 0,
+        df["n_ind_filled"] / df["n_ind_total"],
+        np.nan
+    )
+
+    if kab_col_glob and kab_col_glob in df.columns:
+        df["_Kab_norm"] = df[kab_col_glob].astype(str).str.upper().str.strip()
+        freq_kab = df["_Kab_norm"].value_counts()
+        df["Jml_Perpus_Kab"] = df["_Kab_norm"].map(freq_kab)
+        df["Confidence_Sample"] = (df["Jml_Perpus_Kab"] / SAMPLE_THRESHOLD).clip(0, 1)
+    else:
+        df["Jml_Perpus_Kab"] = np.nan
+        df["Confidence_Sample"] = 1.0
+
+    df["Confidence_IPLM"] = (
+        W_DATA   * df["Confidence_Data"].fillna(0) +
+        W_SAMPLE * df["Confidence_Sample"].fillna(0)
+    )
+
+    df["Indeks_Real_AdjData"] = df["Indeks_Real_0_100"] * df["Confidence_Data"].fillna(0)
+    df["Indeks_Real_AdjConf"] = df["Indeks_Real_0_100"] * df["Confidence_IPLM"].fillna(0)
+
+    # Indeks normatif
+    df["Indeks_Normatif_0_100"] = np.nan
+    df["sub_koleksi_n"] = np.nan
+    df["sub_sdm_n"] = np.nan
+    df["sub_pelayanan_n"] = np.nan
+    df["sub_pengelolaan_n"] = np.nan
+    df["dim_kepatuhan_n"] = np.nan
+    df["dim_kinerja_n"] = np.nan
+
+    for i, row in df.iterrows():
+        jenis = row.get("_dataset", None)
+        if jenis not in TARGETS:
+            continue
+        t = TARGETS[jenis]
+
+        skor_ind = {}
+        for ind, target in t.items():
+            if ind in df.columns:
+                skor_ind[ind] = skor_normatif(row[ind], target)
+
+        sub_koleksi_n = np.mean([
+            skor_ind.get("JudulTercetak", 0),
+            skor_ind.get("EksemplarTercetak", 0)
+        ])
+        sub_sdm_n = skor_ind.get("TenagaKualifikasiIlmuPerpustakaan", 0)
+        sub_pelayanan_n = np.mean([
+            skor_ind.get("PemustakaLuringDaring", 0),
+            skor_ind.get("KegiatanBudayaBaca", 0)
+        ])
+        sub_pengelolaan_n = skor_ind.get("VariasiLayanan", 0)
+
+        dim_kepatuhan_n = np.mean([sub_koleksi_n, sub_sdm_n])
+        dim_kinerja_n   = np.mean([sub_pelayanan_n, sub_pengelolaan_n])
+
+        indeks_normatif = 100 * (w_kepatuhan * dim_kepatuhan_n + w_kinerja * dim_kinerja_n)
+
+        df.at[i, "sub_koleksi_n"]     = sub_koleksi_n
+        df.at[i, "sub_sdm_n"]         = sub_sdm_n
+        df.at[i, "sub_pelayanan_n"]   = sub_pelayanan_n
+        df.at[i, "sub_pengelolaan_n"] = sub_pengelolaan_n
+        df.at[i, "dim_kepatuhan_n"]   = dim_kepatuhan_n
+        df.at[i, "dim_kinerja_n"]     = dim_kinerja_n
+        df.at[i, "Indeks_Normatif_0_100"] = indeks_normatif
+
+    df["Indeks_Normatif_AdjConf"] = df["Indeks_Normatif_0_100"] * df["Confidence_IPLM"].fillna(0)
+
+    # DETAIL untuk tampilan (lengkap, nanti di-view akan di-hide kolom tertentu)
+    detail_cols = []
+    if prov_col_glob and prov_col_glob in df.columns:
+        detail_cols.append(prov_col_glob)
+    if kab_col_glob and kab_col_glob in df.columns:
+        detail_cols.append(kab_col_glob)
+    if nama_col_glob and nama_col_glob in df.columns:
+        detail_cols.append(nama_col_glob)
+
+    detail_cols += [
+        "_dataset",
+        "sub_koleksi", "sub_sdm", "sub_pelayanan", "sub_pengelolaan",
+        "dim_kepatuhan", "dim_kinerja",
+        "Indeks_Real_0_100",
+        "Indeks_Real_AdjData",
+        "Indeks_Real_AdjConf",
+        "Indeks_Normatif_0_100",
+        "Indeks_Normatif_AdjConf",
+        "Confidence_Data",
+        "Confidence_Sample",
+        "Confidence_IPLM",
+    ]
+    detail_cols = [c for c in detail_cols if c in df.columns]
+
+    detail_df = df[detail_cols].copy().round(3)
+
+    # AGREGAT per jenis
+    expected_ds = ["sekolah", "umum", "khusus"]
+    label_map = {
+        "sekolah": "Perpustakaan Sekolah",
+        "umum": "Perpustakaan Umum",
+        "khusus": "Perpustakaan Khusus"
+    }
+
+    rows = []
+    for ds in expected_ds:
+        dsub = df[df["_dataset"] == ds].copy()
+        if dsub.empty:
+            rows.append({
+                "Jenis Perpustakaan": label_map.get(ds, ds),
+                "Jumlah Perpustakaan": 0,
+                "Rata2_DimKepatuhan": 0.0,
+                "Rata2_DimKinerja": 0.0,
+                "Rata2_Indeks_IPLM_0_100": 0.0,
+            })
+        else:
+            rows.append({
+                "Jenis Perpustakaan": label_map.get(ds, ds),
+                "Jumlah Perpustakaan": len(dsub),
+                "Rata2_DimKepatuhan": dsub["dim_kepatuhan"].mean(skipna=True),
+                "Rata2_DimKinerja": dsub["dim_kinerja"].mean(skipna=True),
+                "Rata2_Indeks_IPLM_0_100": dsub["Indeks_Real_0_100"].mean(skipna=True),
+            })
+
+    if rows:
+        base_rows = rows[:len(expected_ds)]
+        total_jumlah = int(sum(r["Jumlah Perpustakaan"] for r in base_rows))
+        mean_dim_kep     = float(np.mean([r["Rata2_DimKepatuhan"] for r in base_rows]))
+        mean_dim_kinerja = float(np.mean([r["Rata2_DimKinerja"] for r in base_rows]))
+        mean_indeks      = float(np.mean([r["Rata2_Indeks_IPLM_0_100"] for r in base_rows]))
+
+        rows.append({
+            "Jenis Perpustakaan": "Rata-rata keseluruhan",
+            "Jumlah Perpustakaan": total_jumlah,
+            "Rata2_DimKepatuhan": mean_dim_kep,
+            "Rata2_DimKinerja": mean_dim_kinerja,
+            "Rata2_Indeks_IPLM_0_100": mean_indeks,
+        })
+
+    agg_view = pd.DataFrame(rows).round(3)
+
+    # Simpan Excel (AGG, DETAIL, RAW)
+    kab_slug = slugify(kab_name) if kab_name else "SEMUA_KAB"
+    kew_slug = slugify(kew_name) if kew_name else "SEMUA_KEW"
+    tmpdir = tempfile.mkdtemp()
+
+    agg_path    = os.path.join(tmpdir, f"IPLM_RealscoreNormatif_Agregat_{kab_slug}_{kew_slug}.xlsx")
+    detail_path = os.path.join(tmpdir, f"IPLM_RealscoreNormatif_Detail_{kab_slug}_{kew_slug}.xlsx")
+    raw_path    = os.path.join(tmpdir, f"IPLM_RealscoreNormatif_Raw_{kab_slug}_{kew_slug}.xlsx")
+
+    agg_view.to_excel(agg_path, index=False)
+    df.to_excel(detail_path, index=False)
+    df_raw.to_excel(raw_path, index=False)
+
+    # Bell curve
+    name_col = nama_col_glob if (nama_col_glob and nama_col_glob in detail_df.columns) else None
+
+    fig_all = make_bell_figure(detail_df, "Sebaran Indeks RealScore – Semua Perpustakaan",
+                               index_col="Indeks_Real_0_100", name_col=name_col)
+
+    fig_sekolah = make_bell_figure(
+        detail_df[detail_df["_dataset"] == "sekolah"],
+        "Sebaran Indeks RealScore – Perpustakaan Sekolah",
+        index_col="Indeks_Real_0_100", name_col=name_col, min_points=3
+    )
+
+    fig_umum = make_bell_figure(
+        detail_df[detail_df["_dataset"] == "umum"],
+        "Sebaran Indeks RealScore – Perpustakaan Umum",
+        index_col="Indeks_Real_0_100", name_col=name_col, min_points=3
+    )
+
+    fig_khusus = make_bell_figure(
+        detail_df[detail_df["_dataset"] == "khusus"],
+        "Sebaran Indeks RealScore – Perpustakaan Khusus",
+        index_col="Indeks_Real_0_100", name_col=name_col, min_points=3
+    )
+
+    return (
+        agg_view,
+        detail_df,
+        agg_path,
+        detail_path,
+        raw_path,
+        fig_all,
+        fig_sekolah,
+        fig_umum,
+        fig_khusus,
+    )
+
+
+# ============================================================
+# 6. VERIFIKASI SAMPEL
+# ============================================================
+
+def compute_verification(df_filtered: pd.DataFrame, kew_value):
+    if df_filtered is None or len(df_filtered) == 0:
+        return pd.DataFrame()
+
+    kew_norm = str(kew_value or "").upper()
+
+    # ---------- Kewenangan KAB/KOTA ----------
+    if ("KAB" in kew_norm or "KOTA" in kew_norm) and (kab_col_glob is not None) and (meta_kab_df is not None):
+        tmp = df_filtered.copy()
+        tmp = tmp[pd.notna(tmp[kab_col_glob])]
+        if tmp.empty:
+            return pd.DataFrame()
+
+        tmp["kab_key"] = tmp[kab_col_glob].apply(norm_kab_label)
+
+        # total perpus
+        g_total = tmp.groupby("kab_key").size().rename("jml_perpus_sampel_total").reset_index()
+
+        # klasifikasi jenjang sekolah (kalau ada)
+        if "sub_jenis_perpus" in tmp.columns:
+            def jenjang(x):
+                if pd.isna(x):
+                    return "OTHER"
+                t = str(x).upper()
+                if " SD " in f" {t} " or " SD/" in t or " MI " in f" {t} ":
+                    return "SD"
+                if " SMP " in f" {t} " or " SMP/" in t or " MTS " in f" {t} ":
+                    return "SMP"
+                return "OTHER"
+            tmp["jenjang_sekolah"] = tmp["sub_jenis_perpus"].apply(jenjang)
+        else:
+            tmp["jenjang_sekolah"] = "OTHER"
+
+        if "_dataset" in tmp.columns:
+            mask_sek = tmp["_dataset"] == "sekolah"
+        else:
+            mask_sek = True
+
+        tmp_sek = tmp[mask_sek].copy()
+        tmp_sd  = tmp_sek[tmp_sek["jenjang_sekolah"] == "SD"].copy()
+        tmp_smp = tmp_sek[tmp_sek["jenjang_sekolah"] == "SMP"].copy()
+
+        g_sd      = tmp_sd.groupby("kab_key").size().rename("jml_perpus_sd_sampel").reset_index()
+        g_smp     = tmp_smp.groupby("kab_key").size().rename("jml_perpus_smp_sampel").reset_index()
+        g_sekolah = tmp_sek.groupby("kab_key").size().rename("jml_perpus_sekolah_total").reset_index()
+
+        if "_dataset" in tmp.columns:
+            tmp_umum = tmp[tmp["_dataset"] == "umum"].copy()
+        else:
+            tmp_umum = tmp.copy()
+        g_umum = tmp_umum.groupby("kab_key").size().rename("jml_perpus_umum_sampel").reset_index()
+
+        use_cols = ["kab_key", "Kab_Kota_Label", "Jml_Kecamatan", "Jml_DesaKel", "Jml_SD", "Jml_SMP"]
+        use_cols = [c for c in use_cols if (meta_kab_df is not None and c in meta_kab_df.columns)]
+
+        merged = (
+            g_total
+            .merge(g_sd,      on="kab_key", how="left")
+            .merge(g_smp,     on="kab_key", how="left")
+            .merge(g_sekolah, on="kab_key", how="left")
+            .merge(g_umum,    on="kab_key", how="left")
+            .merge(meta_kab_df[use_cols], on="kab_key", how="left")
+        )
+
+        for c in ["jml_perpus_sampel_total", "jml_perpus_sd_sampel",
+                  "jml_perpus_smp_sampel", "jml_perpus_sekolah_total",
+                  "jml_perpus_umum_sampel"]:
+            if c in merged.columns:
+                merged[c] = merged[c].fillna(0).astype(int)
+
+        def safe_pct(num, den):
+            if pd.isna(den) or den <= 0:
+                return np.nan
+            return 100.0 * float(num) / float(den)
+
+        # sekolah SD+SMP
+        if "Jml_SD" in merged.columns or "Jml_SMP" in merged.columns:
+            merged["total_sd_smp"] = merged[["Jml_SD", "Jml_SMP"]].sum(axis=1, skipna=True)
+        else:
+            merged["total_sd_smp"] = np.nan
+
+        merged["cov_sekolah_total_%"] = merged.apply(
+            lambda r: safe_pct(r["jml_perpus_sekolah_total"], r.get("total_sd_smp", np.nan)),
+            axis=1
+        )
+
+        # umum vs kombinasi (Kecamatan + Desa/Kel)
+        merged["total_kec_desakel"] = merged.get("Jml_Kecamatan", np.nan) + merged.get("Jml_DesaKel", np.nan)
+        merged["cov_umum_vs_kec_desakel_%"] = merged.apply(
+            lambda r: safe_pct(r["jml_perpus_umum_sampel"], r.get("total_kec_desakel", np.nan)),
+            axis=1
+        )
+
+        out = pd.DataFrame({
+            "Kab/Kota": merged["Kab_Kota_Label"],
+            "Perpus Sampel (Total)": merged["jml_perpus_sampel_total"],
+            "Perpus Sampel – SD": merged["jml_perpus_sd_sampel"],
+            "Perpus Sampel – SMP": merged["jml_perpus_smp_sampel"],
+            "Perpus Sampel – Sekolah (Total SD+SMP)": merged["jml_perpus_sekolah_total"],
+            "Sekolah (SD+SMP)": merged.get("total_sd_smp", np.nan),
+            "Coverage Perpus Sekolah vs Sekolah (%)": merged["cov_sekolah_total_%"],
+            "Perpus Sampel – Umum": merged["jml_perpus_umum_sampel"],
+            "Jumlah Kecamatan": merged.get("Jml_Kecamatan", np.nan),
+            "Jumlah Desa/Kel": merged.get("Jml_DesaKel", np.nan),
+            "Coverage Perpus Umum vs Kec+Desa/Kel (%)": merged["cov_umum_vs_kec_desakel_%"],
+        })
+
+        return out.sort_values("Kab/Kota").reset_index(drop=True).round(3)
+
+    # ---------- Kewenangan PROVINSI ----------
+    if ("PROV" in kew_norm) and (meta_sma_df is not None):
+        tmp = df_filtered.copy()
+
+        if prov_col_glob is None:
+            possible = [c for c in tmp.columns if "prov" in c.lower()]
+            if possible:
+                prov_use = possible[0]
+            else:
+                return pd.DataFrame({"Info": ["Kolom provinsi tidak ditemukan di DM.xlsx"]})
+        else:
+            prov_use = prov_col_glob
+
+        tmp = tmp[pd.notna(tmp[prov_use])]
+        if tmp.empty:
+            return pd.DataFrame({"Info": ["Tidak ada data perpustakaan pada kewenangan provinsi."]})
+
+        # Normalisasi provinsi di DM agar konsisten dengan meta_sma_df
+        tmp["prov_key"] = tmp[prov_use].apply(norm_prov_label)
+
+        g_total = tmp.groupby("prov_key").size().rename("Jumlah_Perpus_Sampel").reset_index()
+
+        if "_dataset" in tmp.columns:
+            tmp_sek = tmp[tmp["_dataset"] == "sekolah"].copy()
+        else:
+            tmp_sek = tmp.copy()
+        g_sek = tmp_sek.groupby("prov_key").size().rename("Jml_Perpus_SMA_Sampel").reset_index()
+
+        merged = g_total.merge(g_sek, on="prov_key", how="left") \
+                        .merge(meta_sma_df[["prov_key", "Provinsi_Label", "Jml_SMA"]],
+                               on="prov_key", how="left")
+
+        merged["Jml_Perpus_SMA_Sampel"] = merged["Jml_Perpus_SMA_Sampel"].fillna(0).astype(int)
+
+        def cov_sma(row):
+            tot = row.get("Jml_SMA", np.nan)
+            if pd.isna(tot) or tot <= 0:
+                return np.nan
+            return 100.0 * row["Jml_Perpus_SMA_Sampel"] / tot
+
+        merged["Coverage_Perpus_SMA_vs_SMA_%"] = merged.apply(cov_sma, axis=1)
+
+        cols_out = [
+            "Provinsi_Label",
+            "Jumlah_Perpus_Sampel",
+            "Jml_Perpus_SMA_Sampel",
+            "Jml_SMA",
+            "Coverage_Perpus_SMA_vs_SMA_%",
+        ]
+        exists = [c for c in cols_out if c in merged.columns]
+        if not exists:
+            return pd.DataFrame()
+
+        return merged[exists].sort_values("Provinsi_Label").reset_index(drop=True).round(3)
+
+    return pd.DataFrame()
+
+
+# ============================================================
+# 7. KONTEKS RINGKAS UNTUK LLM (RAG MINI)
+# ============================================================
+
+def build_context_for_llm(detail_df: pd.DataFrame,
+                          agg_df: pd.DataFrame,
+                          verif_df: pd.DataFrame,
+                          kab_name: str,
+                          kew_value: str) -> str:
+    wilayah = kab_name
+    if kew_value and kew_value != "(Semua)":
+        wilayah = f"{kab_name} (kewenangan {kew_value})"
+
+    lines = []
+    lines.append(f"Wilayah: {wilayah}")
+    lines.append(f"Jumlah perpustakaan sampel: {len(detail_df)}")
+
+    # Rata-rata indeks: utamakan baris "Rata-rata keseluruhan" di agg_df
+    mean_ind = np.nan
+    if agg_df is not None and not agg_df.empty and "Jenis Perpustakaan" in agg_df.columns:
+        mask_total = agg_df["Jenis Perpustakaan"].astype(str).str.lower().str.startswith("rata-rata")
+        if mask_total.any():
+            try:
+                mean_ind = float(
+                    agg_df.loc[mask_total, "Rata2_Indeks_IPLM_0_100"].iloc[0]
+                )
+            except Exception:
+                mean_ind = np.nan
+
+    # Fallback ke rata-rata detail bila agregat tidak tersedia
+    if (np.isnan(mean_ind) or mean_ind == 0) and "Indeks_Real_0_100" in detail_df.columns:
+        mean_ind = detail_df["Indeks_Real_0_100"].mean(skipna=True)
+
+    if not np.isnan(mean_ind):
+        lines.append(f"Rata-rata Indeks IPLM 0-100: {mean_ind:.2f}")
+
+    # Dimensi kepatuhan & kinerja
+    mean_kep = np.nan
+    mean_kin = np.nan
+    if "dim_kepatuhan" in detail_df.columns:
+        mean_kep = detail_df["dim_kepatuhan"].mean(skipna=True)
+        lines.append(f"Rata-rata dimensi kepatuhan (0-1): {mean_kep:.3f}")
+    if "dim_kinerja" in detail_df.columns:
+        mean_kin = detail_df["dim_kinerja"].mean(skipna=True)
+        lines.append(f"Rata-rata dimensi kinerja (0-1): {mean_kin:.3f}")
+
+    # Confidence
+    if "Confidence_IPLM" in detail_df.columns:
+        mean_conf = detail_df["Confidence_IPLM"].mean(skipna=True)
+        if not np.isnan(mean_conf):
+            lines.append(f"Rata-rata Confidence_IPLM (0-1): {mean_conf:.2f}")
+
+    # Ringkasan per jenis perpustakaan
+    if agg_df is not None and not agg_df.empty and "Jenis Perpustakaan" in agg_df.columns:
+        lines.append("\nRingkasan per jenis perpustakaan:")
+        for _, r in agg_df.iterrows():
+            jp = str(r.get("Jenis Perpustakaan", "") or "")
+            if jp.lower().startswith("rata-rata"):
+                continue
+            n = r.get("Jumlah Perpustakaan", np.nan)
+            idx = r.get("Rata2_Indeks_IPLM_0_100", np.nan)
+            if pd.isna(idx):
+                continue
+            lines.append(f"- {jp}: jumlah sampel={int(n)}, rata-rata indeks={idx:.2f}")
+
+    # Contoh perpustakaan dengan indeks yang bervariasi (top-3 dan bottom-3)
+    if "Indeks_Real_0_100" in detail_df.columns:
+        df_valid = detail_df.dropna(subset=["Indeks_Real_0_100"]).copy()
+
+        if "Confidence_IPLM" in df_valid.columns:
+            df_valid = df_valid.sort_values("Confidence_IPLM", ascending=False)
+
+        col_nama = nama_col_glob if (nama_col_glob and nama_col_glob in df_valid.columns) else None
+        if not df_valid.empty and col_nama:
+            top3 = df_valid.sort_values("Indeks_Real_0_100", ascending=False).head(3)
+            bottom3 = df_valid.sort_values("Indeks_Real_0_100", ascending=True).head(3)
+
+            lines.append("\nContoh perpustakaan dengan indeks relatif lebih tinggi:")
+            for _, r in top3.iterrows():
+                lines.append(
+                    f"- {str(r[col_nama])}: indeks={r['Indeks_Real_0_100']:.2f}, "
+                    f"kepatuhan={r['dim_kepatuhan']:.3f}, kinerja={r['dim_kinerja']:.3f}"
+                )
+
+            lines.append("\nContoh perpustakaan dengan indeks yang masih perlu penguatan:")
+            for _, r in bottom3.iterrows():
+                lines.append(
+                    f"- {str(r[col_nama])}: indeks={r['Indeks_Real_0_100']:.2f}, "
+                    f"kepatuhan={r['dim_kepatuhan']:.3f}, kinerja={r['dim_kinerja']:.3f}"
+                )
+
+    # Ringkasan coverage (kalau ada verif_df)
+    if verif_df is not None and not verif_df.empty:
+        try:
+            if "Coverage Perpus Sekolah vs Sekolah (%)" in verif_df.columns:
+                cov_sek = verif_df["Coverage Perpus Sekolah vs Sekolah (%)"]
+                if len(cov_sek.dropna()) > 0:
+                    avg_cov_sek = cov_sek.mean()
+                    lines.append(
+                        f"Rata-rata coverage perpustakaan sekolah terhadap SD+SMP: {avg_cov_sek:.2f}%"
+                    )
+            if "Coverage Perpus Umum vs Kec+Desa/Kel (%)" in verif_df.columns:
+                cov_umum = verif_df["Coverage Perpus Umum vs Kec+Desa/Kel (%)"]
+                if len(cov_umum.dropna()) > 0:
+                    avg_cov_umum = cov_umum.mean()
+                    lines.append(
+                        f"Rata-rata coverage perpustakaan umum terhadap kecamatan+desa/kelurahan: {avg_cov_umum:.2f}%"
+                    )
+        except Exception:
+            pass
+
+    return "\n".join(lines)
+
+
+# ============================================================
+# 7a. RULE-BASED ANALYSIS (FALLBACK)
+# ============================================================
+
+def classify_level(x):
+    # dipertahankan hanya sebagai placeholder; tidak dipakai untuk teks penilaian
+    if pd.isna(x):
+        return "tidak tersedia"
+    if x < 40:
+        return "-"
+    if x < 60:
+        return "-"
+    return "-"
+
+
+def generate_rule_based_analysis(detail_df: pd.DataFrame,
+                                 agg_df: pd.DataFrame,
+                                 kab_name: str,
+                                 kew_value: str) -> str:
+    if detail_df is None or detail_df.empty:
+        return "Tidak ada data yang dapat dianalisis."
+
+    wilayah = kab_name
+    if kew_value and kew_value != "(Semua)":
+        wilayah = f"{kab_name} (kewenangan {kew_value})"
+
+    # Rata-rata indeks: utamakan baris "Rata-rata keseluruhan" di agg_df
+    if agg_df is not None and not agg_df.empty and "Jenis Perpustakaan" in agg_df.columns:
+        mask_total = agg_df["Jenis Perpustakaan"].astype(str).str.lower().str.startswith("rata-rata")
+        if mask_total.any():
+            try:
+                mean_ind = float(
+                    agg_df.loc[mask_total, "Rata2_Indeks_IPLM_0_100"].iloc[0]
+                )
+            except Exception:
+                mean_ind = detail_df.get("Indeks_Real_0_100", pd.Series(dtype=float)).mean(skipna=True)
+        else:
+            mean_ind = detail_df.get("Indeks_Real_0_100", pd.Series(dtype=float)).mean(skipna=True)
+    else:
+        mean_ind = detail_df.get("Indeks_Real_0_100", pd.Series(dtype=float)).mean(skipna=True)
+
+    mean_kep = detail_df.get("dim_kepatuhan", pd.Series(dtype=float)).mean(skipna=True)
+    mean_kin = detail_df.get("dim_kinerja", pd.Series(dtype=float)).mean(skipna=True)
+    mean_conf = detail_df.get("Confidence_IPLM", pd.Series(dtype=float)).mean(skipna=True)
+
+    lines = []
+    lines.append("## Analisis Otomatis & Rekomendasi Kebijakan (Rule-based)\n")
+    lines.append("### Gambaran Umum Wilayah")
+    lines.append(f"- Wilayah: {wilayah}")
+    lines.append(f"- Jumlah perpustakaan dalam sampel: {len(detail_df)}")
+    lines.append(f"- Rata-rata Indeks IPLM 2025: {mean_ind:.2f}")
+    lines.append(f"- Rata-rata dimensi kepatuhan (0–1): {mean_kep:.3f}")
+    lines.append(f"- Rata-rata dimensi kinerja (0–1): {mean_kin:.3f}")
+    if not pd.isna(mean_conf):
+        lines.append(f"- Rata-rata Confidence_IPLM: {mean_conf:.2f}")
+
+    lines.append("\n### Capaian per Jenis Perpustakaan")
+    if agg_df is not None and not agg_df.empty:
+        for _, r in agg_df.iterrows():
+            jp = str(r.get("Jenis Perpustakaan", "") or "")
+            if not jp or jp.lower().startswith("rata-rata"):
+                continue
+            idx = r.get("Rata2_Indeks_IPLM_0_100", np.nan)
+            n = int(r.get("Jumlah Perpustakaan", 0))
+            if pd.isna(idx):
+                continue
+            lines.append(f"- {jp}: rata-rata indeks {idx:.2f} dengan {n} perpustakaan.")
+    else:
+        lines.append("- Data agregat per jenis perpustakaan tidak tersedia.")
+
+    lines.append("\n### Arah Kebijakan dan Rekomendasi Program")
+    lines.append(
+        "Prioritas utama adalah penguatan layanan dasar perpustakaan serta peningkatan "
+        "ketersediaan SDM dan koleksi. Pola capaian pada dimensi kepatuhan menunjukkan bahwa "
+        "aspek koleksi, kebijakan layanan, dan kualifikasi pustakawan masih memiliki ruang penguatan "
+        "dan perlu dibenahi secara terencana. Sementara itu, capaian dimensi kinerja mengindikasikan "
+        "bahwa intensitas pemanfaatan dan kegiatan literasi perlu diperluas agar perpustakaan "
+        "lebih konsisten berfungsi sebagai pusat belajar masyarakat."
+    )
+    lines.append(
+        "Program-program yang dapat diprioritaskan antara lain: peningkatan alokasi anggaran "
+        "untuk pengembangan koleksi mutakhir, penguatan kapasitas pustakawan melalui pelatihan "
+        "berkelanjutan, perluasan kegiatan budaya baca yang menyasar komunitas rentan, serta "
+        "kolaborasi lintas sektor dengan satuan pendidikan, organisasi masyarakat, dan pelaku "
+        "usaha lokal. Seluruh intervensi perlu disertai mekanisme monitoring dan evaluasi "
+        "berbasis data IPLM agar perbaikan yang dilakukan dapat terpantau dari waktu ke waktu."
+    )
+
+    lines.append(
+        "\n> Catatan: analisis ini disusun secara otomatis berbasis data IPLM. "
+        "Untuk penetapan kebijakan, tetap diperlukan verifikasi lapangan dan kajian kualitatif tambahan."
+    )
+
+    return "\n".join(lines)
+
+
+# ============================================================
+# 7b. ANALISIS BERBASIS LLM (DENGAN FALLBACK RULE-BASED)
+# ============================================================
+
+def generate_llm_analysis(detail_df: pd.DataFrame,
+                          agg_df: pd.DataFrame,
+                          verif_df: pd.DataFrame,
+                          kab_name: str,
+                          kew_value: str) -> str:
+    """
+    Analisis otomatis:
+    - Jika pemanggilan LLM gagal -> fallback ke rule-based dengan pesan error ringkas.
+    """
+
+    context = build_context_for_llm(detail_df, agg_df, verif_df, kab_name, kew_value)
+
+    client = get_llm_client()
+    if client is None or not USE_LLM:
+        rb = generate_rule_based_analysis(detail_df, agg_df, kab_name, kew_value)
+        return (
+            "⚠️ Terjadi kendala saat menginisialisasi model LLM, sehingga analisis otomatis "
+            "saat ini menggunakan pendekatan **rule-based**.\n\n"
+            + rb
+        )
+
+    system_prompt = (
+        "Anda adalah analis kebijakan perpustakaan dan literasi yang berpengalaman di Indonesia. "
+        "Tugas Anda adalah membaca ringkasan data Indeks Pembangunan Literasi Masyarakat (IPLM) "
+        "dan menyusun analisis kebijakan yang tajam, tetapi tetap komunikatif dan mudah dipahami "
+        "oleh pemangku kepentingan pemerintah daerah."
+    )
+
+    user_prompt = f"""
+DATA RINGKAS IPLM UNTUK WILAYAH BERIKUT:
+
+{context}
+
+TULISKAN ANALISIS DALAM BAHASA INDONESIA FORMAL, DENGAN STRUKTUR:
+
+1. Gambaran umum kondisi perpustakaan di wilayah tersebut (1 paragraf).
+2. Analisis capaian indeks: soroti kekuatan dan area yang masih memerlukan penguatan, terutama perbedaan antar jenis perpustakaan (2 paragraf).
+3. Analisis risiko dan kesenjangan layanan, termasuk jika coverage perpustakaan terhadap satuan pendidikan atau wilayah administratif masih terbatas (1–2 paragraf).
+4. Rekomendasi program dan kebijakan prioritas yang konkret untuk 3–5 tahun ke depan. Susun dalam bentuk paragraf naratif, bukan bullet list (2 paragraf).
+
+PANDUAN GAYA:
+- Jangan hanya mengulang angka apa adanya, tetapi jelaskan maknanya.
+- Jangan menggunakan istilah penilaian eksplisit seperti "rendah", "sedang", atau "tinggi" untuk menyebut nilai indeks.
+  Gunakan frasa netral seperti "masih memiliki ruang penguatan", "belum sesuai harapan", atau "perlu konsolidasi".
+- Gunakan istilah kebijakan publik dan manajemen program perpustakaan ketika relevan.
+- Hindari kalimat terlalu panjang; gunakan kalimat efektif dan jelas.
+"""
+
+    try:
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ]
+
+        resp = client.chat_completion(
+            model=LLM_MODEL_NAME,
+            messages=messages,
+            max_tokens=1000,
+            temperature=0.25,
+            top_p=0.9,
+        )
+
+        text = resp.choices[0].message.content.strip()
+        if not text:
+            raise ValueError("Respon LLM kosong.")
+
+        return text
+
+    except Exception as e:
+        rb = generate_rule_based_analysis(detail_df, agg_df, kab_name, kew_value)
+        return (
+            "⚠️ Terjadi error saat memanggil model LLM, sehingga analisis berikut "
+            "dibuat menggunakan pendekatan **rule-based**.\n\n"
+            f"(Detail teknis: {repr(e)})\n\n"
+            f"{rb}"
+        )
+
+
+# ============================================================
+# 8. WORD REPORT (Plotly Pie + Indeks + Agregat + LLM Narrative)
+# ============================================================
+
+from docx import Document
+from docx.shared import Inches
+import plotly.express as px
+
+# Cek apakah kaleido tersedia
+try:
+    import kaleido  # noqa: F401
+    HAS_KALEIDO = True
+except Exception:
+    HAS_KALEIDO = False
+
+
+def make_pie_plotly(num, den, title):
+    """
+    Generate pie chart PNG menggunakan Plotly.
+    Jika kaleido tidak tersedia / gagal, return None (tanpa error).
+    """
+    if not HAS_KALEIDO:
+        return None
+
+    if den is None or den <= 0:
+        values = [0, 1]
+        labels = ["Terjangkau", "Belum Terjangkau"]
+    else:
+        values = [num, max(den - num, 0)]
+        labels = ["Terjangkau", "Belum Terjangkau"]
+
+    fig = px.pie(
+        values=values,
+        names=labels,
+        title=title,
+        hole=0.3
+    )
+
+    tmp = tempfile.mktemp(suffix=".png")
+    try:
+        fig.write_image(tmp, scale=2)
+        return tmp
+    except Exception:
+        return None
+
+
+def generate_word_report_all(detail_df, agg_df, verif_df, prov, kab, kew, analysis_text):
+    """
+    Membuat laporan lengkap untuk wilayah yang dipilih:
+    - Ringkasan indeks
+    - Tabel agregat
+    - (opsional) Pie chart coverage
+    - Narasi otomatis (LLM/rule-based)
+    """
+    # Tidak berlaku untuk PUSAT
+    if kew == "PUSAT":
+        return None
+
+    wilayah = kab if kab != "(Semua)" else prov
+
+    doc = Document()
+    doc.add_heading(f"Laporan IPLM – {wilayah}", level=1)
+
+    # =====================
+    # 1. Ringkasan Indeks
+    # =====================
+    doc.add_heading("Ringkasan Indeks", level=2)
+
+    # Rata-rata Indeks: pakai agregat "Rata-rata keseluruhan" agar konsisten
+    if agg_df is not None and not agg_df.empty and "Jenis Perpustakaan" in agg_df.columns:
+        mask_total = agg_df["Jenis Perpustakaan"].astype(str).str.lower().str.startswith("rata-rata")
+        if mask_total.any():
+            try:
+                mean_ind = float(
+                    agg_df.loc[mask_total, "Rata2_Indeks_IPLM_0_100"].iloc[0]
+                )
+            except Exception:
+                mean_ind = detail_df["Indeks_Real_0_100"].mean(skipna=True)
+        else:
+            mean_ind = detail_df["Indeks_Real_0_100"].mean(skipna=True)
+    else:
+        mean_ind = detail_df["Indeks_Real_0_100"].mean(skipna=True)
+
+    mean_kep = detail_df["dim_kepatuhan"].mean(skipna=True)
+    mean_kin = detail_df["dim_kinerja"].mean(skipna=True)
+    mean_conf = detail_df["Confidence_IPLM"].mean(skipna=True)
+
+    doc.add_paragraph(f"- Jumlah perpustakaan: {len(detail_df)}")
+    doc.add_paragraph(f"- Rata-rata Indeks IPLM: {mean_ind:.2f}")
+    doc.add_paragraph(f"- Rata-rata Dimensi Kepatuhan (0–1): {mean_kep:.3f}")
+    doc.add_paragraph(f"- Rata-rata Dimensi Kinerja (0–1): {mean_kin:.3f}")
+    doc.add_paragraph(f"- Rata-rata Confidence IPLM: {mean_conf:.2f}")
+
+    # =====================
+    # 2. Tabel Agregat
+    # =====================
+    doc.add_heading("Ringkasan Agregat per Jenis Perpustakaan", level=2)
+
+    table = doc.add_table(rows=1, cols=len(agg_df.columns))
+    hdr = table.rows[0].cells
+    for i, c in enumerate(agg_df.columns):
+        hdr[i].text = str(c)
+
+    for _, row in agg_df.iterrows():
+        r = table.add_row().cells
+        for i, c in enumerate(agg_df.columns):
+            r[i].text = str(row[c])
+
+    # =====================
+    # 3. PIE CHART COVERAGE (opsional)
+    # =====================
+    doc.add_heading("Coverage / Cakupan Pembinaan", level=2)
+
+    if not HAS_KALEIDO:
+        doc.add_paragraph(
+            "Grafik pie coverage tidak dibuat karena modul 'kaleido' "
+            "tidak tersedia di server. Hanya ringkasan teks yang ditampilkan."
+        )
+    elif verif_df is not None and not verif_df.empty:
+
+        if kew == "KAB/KOTA":
+            for _, r in verif_df.iterrows():
+                nama = r["Kab/Kota"]
+
+                # Sekolah SD+SMP
+                if "Sekolah (SD+SMP)" in verif_df.columns:
+                    img_path = make_pie_plotly(
+                        r["Perpus Sampel – Sekolah (Total SD+SMP)"],
+                        r["Sekolah (SD+SMP)"],
+                        f"Coverage Perpustakaan Sekolah – {nama}"
+                    )
+                    if img_path:
+                        doc.add_paragraph(f"Coverage Perpustakaan Sekolah – {nama}")
+                        doc.add_picture(img_path, width=Inches(4))
+
+                # Umum
+                if "Jumlah Kecamatan" in verif_df.columns and "Jumlah Desa/Kel" in verif_df.columns:
+                    denom = r["Jumlah Kecamatan"] + r["Jumlah Desa/Kel"]
+                    img_path = make_pie_plotly(
+                        r["Perpus Sampel – Umum"],
+                        denom,
+                        f"Coverage Perpustakaan Umum – {nama}"
+                    )
+                    if img_path:
+                        doc.add_paragraph(f"Coverage Perpustakaan Umum – {nama}")
+                        doc.add_picture(img_path, width=Inches(4))
+
+        elif kew == "PROVINSI":
+            for _, r in verif_df.iterrows():
+                nama = r["Provinsi_Label"]
+                img_path = make_pie_plotly(
+                    r["Jml_Perpus_SMA_Sampel"],
+                    r["Jml_SMA"],
+                    f"Coverage Perpustakaan SMA – {nama}"
+                )
+                if img_path:
+                    doc.add_paragraph(f"Coverage Perpustakaan SMA – {nama}")
+                    doc.add_picture(img_path, width=Inches(4))
+
+    # =====================
+    # 4. Narasi LLM / Rule-based
+    # =====================
+    doc.add_heading("Analisis Naratif Otomatis", level=2)
+    for paragraph in analysis_text.split("\n"):
+        if paragraph.strip():
+            doc.add_paragraph(paragraph)
+
+    # =====================
+    # Simpan
+    # =====================
+    outpath = tempfile.mktemp(suffix=".docx")
+    doc.save(outpath)
+    return outpath
+
+
+# ============================================================
+# 8. FUNGSI GRADIO
+# ============================================================
+
+def run_app(prov_value, kab_value, kew_value):
+    if df_all_raw is None:
+        empty = pd.DataFrame()
+        return (
+            empty, empty, empty,   # agg_df, detail_df, verif_df
+            None, None, None,      # agg_path, detail_path, raw_path
+            None,                  # word_path
+            None, None, None, None,  # fig_all, fig_sekolah, fig_umum, fig_khusus
+            "Data belum berhasil dimuat. Periksa kembali nama file di DATA_FILE.",
+            "Belum ada analisis otomatis yang dapat ditampilkan."
+        )
+
+    df = df_all_raw.copy()
+
+    # Filter provinsi
+    if prov_col_glob and prov_value and prov_value != "(Semua)":
+        df = df[df[prov_col_glob].astype(str).str.strip() == prov_value]
+
+    # Filter kab/kota
+    if kab_col_glob and kab_value and kab_value != "(Semua)":
+        df = df[df[kab_col_glob].astype(str).str.strip() == kab_value]
+
+    # Filter kewenangan
+    if kew_value and kew_value != "(Semua)":
+        df = df[df["KEW_NORM"] == kew_value]
+
+    if len(df) == 0:
+        empty = pd.DataFrame()
+        return (
+            empty, empty, empty,   # agg_df, detail_df, verif_df
+            None, None, None,      # agg_path, detail_path, raw_path
+            None,                  # word_path
+            None, None, None, None,  # fig_all, fig_sekolah, fig_umum, fig_khusus
+            "Tidak ada data untuk kombinasi filter yang dipilih.",
+            "Belum ada analisis otomatis yang dapat ditampilkan."
+        )
+
+    kab_name = kab_value if kab_value and kab_value != "(Semua)" else "SEMUA KAB/KOTA"
+    kew_name = kew_value if kew_value and kew_value != "(Semua)" else "SEMUA KEWENANGAN"
+
+    (
+        agg_df,
+        detail_df,
+        agg_path,
+        detail_path,
+        raw_path,
+        fig_all,
+        fig_sekolah,
+        fig_umum,
+        fig_khusus,
+    ) = run_pipeline_core(df, kab_name=kab_name, kew_name=kew_name)
+
+    # Verifikasi sampel
+    verif_df = compute_verification(df, kew_value)
+
+    # Pesan ringkas di UI (menggunakan detail_df lengkap)
+    mean_conf = None
+    if "Confidence_IPLM" in detail_df.columns:
+        mean_conf = detail_df["Confidence_IPLM"].mean(skipna=True)
+
+    msg = f"Berhasil dihitung untuk {len(detail_df)} baris perpustakaan."
+    if mean_conf is not None and not np.isnan(mean_conf):
+        msg += f" | Rata-rata Confidence_IPLM: {mean_conf:.2f}"
+    if not verif_df.empty:
+        msg += " | Verifikasi sampel tersedia."
+
+    # Analisis otomatis (LLM / rule-based) pakai detail_df lengkap
+    analysis_text = generate_llm_analysis(
+        detail_df=detail_df,
+        agg_df=agg_df,
+        verif_df=verif_df,
+        kab_name=kab_name,
+        kew_value=kew_value,
+    )
+
+    # Laporan Word (pakai detail_df lengkap)
+    word_path = generate_word_report_all(
+        detail_df, agg_df, verif_df,
+        prov_value, kab_value, kew_value,
+        analysis_text
+    )
+
+    # === VIEW UNTUK UI: sembunyikan indeks normatif & confidence ===
+    cols_hide = [
+        "Indeks_Normatif_0_100",
+        "Indeks_Normatif_AdjConf",
+        "Indeks_Real_AdjConf",
+        "Indeks_Real_AdjData",
+        "Confidence_IPLM",
+        "Confidence_Data",
+        "Confidence_Sample",
+    ]
+    detail_df_view = detail_df.drop(columns=[c for c in cols_hide if c in detail_df.columns], errors="ignore")
+
+    return (
+        agg_df,
+        detail_df_view,   # yang tampil di UI sudah tanpa kolom normatif & confidence
+        verif_df,
+        agg_path,
+        detail_path,
+        raw_path,
+        word_path,
+        fig_all,
+        fig_sekolah,
+        fig_umum,
+        fig_khusus,
+        msg,
+        analysis_text,
+    )
+
+
+def on_prov_change(prov_value):
+    if df_all_raw is None or kab_col_glob is None:
+        return gr.update(choices=["(Semua)"], value="(Semua)")
+    if prov_value is None or prov_value == "(Semua)" or prov_col_glob is None:
+        s = df_all_raw[kab_col_glob].dropna().astype(str).str.strip()
+    else:
+        m = df_all_raw[prov_col_glob].astype(str).str.strip() == prov_value
+        s = df_all_raw.loc[m, kab_col_glob].dropna().astype(str).str.strip()
+    vals = sorted([x for x in s.unique() if x != ""])
+    new_choices = ["(Semua)"] + vals
+    return gr.update(choices=new_choices, value="(Semua)")
+
+
+# ============================================================
+# 9. BUILD UI GRADIO
+# ============================================================
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        f"""
+        # IPLM 2025 – RealScore + Normatif + Verifikasi Sampel + Analisis Otomatis (LLM + Rule-based)
+
+        Dataset diambil langsung dari file di repository (tanpa upload):
+
+        - **`{DATA_FILE}`** – Data perpustakaan (semua jenis, multi-sheet).
+        - **`{META_KAB_FILE}`** – Jumlah kecamatan & desa/kel per kab/kota.
+        - **`{META_SDSMP_FILE}`** – Jumlah SD & SMP per kab/kota.
+        - **`{META_SMA_FILE}`** – Jumlah SMA per provinsi.
+
+        {DATA_INFO}
+        """
+    )
+
+    with gr.Row():
+        dd_prov = gr.Dropdown(label="Provinsi", choices=prov_choices, value=prov_choices[0])
+        dd_kab  = gr.Dropdown(label="Kab/Kota", choices=kab_choices, value=kab_choices[0])
+        dd_kew  = gr.Dropdown(label="Kewenangan", choices=kew_choices, value=default_kew)
+
+    dd_prov.change(
+        fn=on_prov_change,
+        inputs=dd_prov,
+        outputs=dd_kab,
+    )
+
+    run_btn = gr.Button("Jalankan Perhitungan")
+    msg_out = gr.Markdown()
+
+    gr.Markdown("### Hasil Agregat (RealScore) per Jenis Perpustakaan")
+    agg_df_out = gr.DataFrame(interactive=False)
+
+    gr.Markdown("### Detail Indeks (Real) per Perpustakaan")
+    detail_df_out = gr.DataFrame(interactive=False)
+
+    gr.Markdown("### Verifikasi Kondisi Sampel di Lapangan")
+    verif_df_out = gr.DataFrame(
+        label="Perbandingan jumlah sampel dengan populasi unit (SD/SMP/SMA, Kecamatan, Desa/Kel)",
+        interactive=False
+    )
+
+    gr.Markdown("### Sebaran Indeks – Semua Perpustakaan (RealScore)")
+    bell_all_out = gr.Plot()
+
+    gr.Markdown("### Sebaran Indeks – Perpustakaan Sekolah")
+    bell_sekolah_out = gr.Plot()
+
+    gr.Markdown("### Sebaran Indeks – Perpustakaan Umum")
+    bell_umum_out = gr.Plot()
+
+    gr.Markdown("### Sebaran Indeks – Perpustakaan Khusus")
+    bell_khusus_out = gr.Plot()
+
+    gr.Markdown("### Analisis Otomatis & Rekomendasi Kebijakan")
+    analysis_out = gr.Markdown()
+
+    with gr.Row():
+        agg_file_out   = gr.File(label="Download File Agregat (.xlsx)")
+        detail_file_out = gr.File(label="Download File Detail (.xlsx)")
+        raw_file_out   = gr.File(label="Download Data Mentah (.xlsx)")
+        word_file_out  = gr.File(label="Download Laporan Word (.docx)")
+
+    run_btn.click(
+        fn=run_app,
+        inputs=[dd_prov, dd_kab, dd_kew],
+        outputs=[
+            agg_df_out,
+            detail_df_out,
+            verif_df_out,
+            agg_file_out,
+            detail_file_out,
+            raw_file_out,
+            word_file_out,
+            bell_all_out,
+            bell_sekolah_out,
+            bell_umum_out,
+            bell_khusus_out,
+            msg_out,
+            analysis_out,
+        ],
+    )
+
+demo.launch()