Update app.py

app.py

@@ -1,18 +1,28 @@
 import os
 import re
 import textwrap
+import traceback
 import pandas as pd
 import gradio as gr
 
 from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from langchain_community.vectorstores import FAISS
 from langchain_core.documents import Document
 from langchain_core.prompts import PromptTemplate
-from langchain_community.vectorstores import FAISS
 
 
-# =========================================================
-# Pretty output helpers (same idea as your Step 6)
-# =========================================================
+# =========================
+# Files expected in repo root
+# =========================
+BASE_DIR = os.path.dirname(__file__)
+CSV_FILE = os.path.join(BASE_DIR, "Customer records.csv")
+RISK_PDF = os.path.join(BASE_DIR, "Risk_Policy.pdf")
+INT_PDF  = os.path.join(BASE_DIR, "Interest_Rate_Policy.pdf")
+
+
+# =========================
+# Helpers: formatting
+# =========================
 def one_sentence_per_line(text: str, width: int = 110) -> str:
     if text is None:
         return ""
@@ -23,8 +33,7 @@ def one_sentence_per_line(text: str, width: int = 110) -> str:
             prefix, body = prefix_match.group(1), prefix_match.group(2)
             wrapped = textwrap.wrap(body, width=max(20, width - len(prefix))) or [""]
             return [prefix + wrapped[0]] + [(" " * len(prefix)) + w for w in wrapped[1:]]
-        wrapped = textwrap.wrap(line, width=width) or [""]
-        return wrapped
+        return textwrap.wrap(line, width=width) or [""]
 
     out_lines = []
     for raw_line in str(text).splitlines():
@@ -35,10 +44,8 @@ def one_sentence_per_line(text: str, width: int = 110) -> str:
         parts = re.split(r"(?<=[.!?])\s+", line)
         for part in parts:
             part = part.strip()
-            if not part:
-                continue
-            out_lines.extend(_wrap_line(part))
-
+            if part:
+                out_lines.extend(_wrap_line(part))
     return "\n".join(out_lines)
 
 
@@ -55,35 +62,30 @@ def enforce_third_person(text: str, customer_name: str) -> str:
     return text
 
 
-def format_customer_profile(profile) -> str:
-    if profile is None:
+def format_customer_profile(profile: dict) -> str:
+    if not profile:
         return ""
-
-    if isinstance(profile, str):
-        return profile
-
     d = dict(profile)
-    preferred_order = ["ID", "Name", "Email", "Credit_Score", "Nationality", "Account_Status", "PR_Status"]
+
+    preferred = ["ID", "Name", "Email", "Credit_Score", "Nationality", "Account_Status", "PR_Status"]
 
     nat = str(d.get("Nationality", "")).strip().lower()
     if nat == "singaporean":
         d.pop("PR_Status", None)
 
     lines = []
-    for k in preferred_order:
+    for k in preferred:
         if k in d:
             lines.append(f"{k}: {d.get(k)}")
-
     for k in sorted(d.keys()):
-        if k not in preferred_order:
+        if k not in preferred:
             lines.append(f"{k}: {d.get(k)}")
-
     return "\n".join(lines)
 
 
-# =========================================================
-# Load CSV (same idea as Step 3)
-# =========================================================
+# =========================
+# Load CSV + build mock systems
+# =========================
 def load_customer_csv(csv_path: str) -> pd.DataFrame:
     df_all = pd.read_csv(csv_path)
     df_all.columns = [c.strip() for c in df_all.columns]
@@ -124,10 +126,9 @@ def build_mock_systems(df_all: pd.DataFrame):
     return df_credit, df_account, df_gov
 
 
-def get_customer_profile(customer_id: str, df_credit, df_account, df_gov):
+def get_customer_profile(customer_id: str):
     customer_id = str(customer_id).strip()
-
-    credit_rec = df_credit[df_credit["ID"].astype(str) == customer_id]
+    credit_rec = DF_CREDIT[DF_CREDIT["ID"].astype(str) == customer_id]
     if credit_rec.empty:
         return None
 
@@ -135,13 +136,13 @@ def get_customer_profile(customer_id: str, df_credit, df_account, df_gov):
     email = credit_rec.iloc[0]["Email"]
     credit_score = int(credit_rec.iloc[0]["Credit_Score"])
 
-    acct_rec = df_account[df_account["ID"].astype(str) == customer_id]
+    acct_rec = DF_ACCOUNT[DF_ACCOUNT["ID"].astype(str) == customer_id]
     nationality = acct_rec.iloc[0]["Nationality"] if not acct_rec.empty else None
     account_status = acct_rec.iloc[0]["Account_Status"] if not acct_rec.empty else None
 
     pr_status = None
     if nationality and str(nationality).strip().lower() == "non-singaporean":
-        gov_rec = df_gov[df_gov["ID"].astype(str) == customer_id]
+        gov_rec = DF_GOV[DF_GOV["ID"].astype(str) == customer_id]
         pr_status = bool(gov_rec.iloc[0]["PR_Status"]) if not gov_rec.empty else None
 
     return {
@@ -155,9 +156,9 @@ def get_customer_profile(customer_id: str, df_credit, df_account, df_gov):
     }
 
 
-# =========================================================
-# PDFs -> text -> parse rules (same as Step 4)
-# =========================================================
+# =========================
+# PDF ingest + parse policies
+# =========================
 def extract_pdf_text(pdf_path: str) -> str:
     from pypdf import PdfReader
     reader = PdfReader(pdf_path)
@@ -167,80 +168,63 @@ def extract_pdf_text(pdf_path: str) -> str:
     return "\n".join(pages)
 
 
-def load_policies(risk_pdf_path: str, interest_pdf_path: str):
-    risk_policy_text = extract_pdf_text(risk_pdf_path)
-    interest_policy_text = extract_pdf_text(interest_pdf_path)
-
+def parse_policies(risk_text: str, interest_text: str):
+    # Interest rates
     rate_matches = re.findall(
         r"\b(Low|Medium|High)\b\s+([0-9]+\.[0-9]+)\s*%?",
-        interest_policy_text,
+        interest_text,
         flags=re.IGNORECASE
     )
     interest_rates = {k.capitalize(): float(v) for k, v in rate_matches}
 
+    # Risk table rows
     risk_rows = re.findall(
         r"(\d{3})\s*(?:-|–|—)?\s*(\d{3})\s+(Delinquent|Closed|Good-standing)\s+(High|Medium|Low)",
-        risk_policy_text,
+        risk_text,
         flags=re.IGNORECASE,
     )
 
     risk_mapping = {}
     for lo, hi, status, risk in risk_rows:
         band = (int(lo), int(hi))
-        key = (band, status.strip().lower())
-        risk_mapping[key] = risk.capitalize()
+        risk_mapping[(band, status.strip().lower())] = risk.capitalize()
 
-    return risk_policy_text, interest_policy_text, risk_mapping, interest_rates
+    return risk_mapping, interest_rates
 
 
-# =========================================================
-# Deterministic rules (same as Step 5)
-# =========================================================
 def _score_band(score: int):
-    if 300 <= score <= 674:
-        return (300, 674)
-    if 675 <= score <= 749:
-        return (675, 749)
-    if 750 <= score <= 850:
-        return (750, 850)
-    if score < 300:
-        return (300, 674)
+    if 300 <= score <= 674: return (300, 674)
+    if 675 <= score <= 749: return (675, 749)
+    if 750 <= score <= 850: return (750, 850)
+    if score < 300: return (300, 674)
     return (750, 850)
 
 
-def determine_overall_risk(score: int, account_status: str, risk_mapping: dict) -> str:
+def determine_overall_risk(score: int, account_status: str) -> str:
     band = _score_band(score)
     status = str(account_status).strip().lower()
-    key = (band, status)
-    if key not in risk_mapping:
-        return "High"
-    return risk_mapping[key]
+    return RISK_MAPPING.get((band, status), "High")
 
 
-def determine_interest_rate(overall_risk: str, interest_rates: dict) -> float:
-    return float(interest_rates[overall_risk])
+def determine_interest_rate(overall_risk: str) -> float:
+    return float(INTEREST_RATES[overall_risk])
 
 
-def is_non_singaporean_no_pr(customer_id: str, df_account, df_gov) -> bool:
-    try:
-        cid = str(customer_id).strip()
-        nat_row = df_account[df_account["ID"].astype(str).str.strip() == cid]
-        nationality = nat_row.iloc[0]["Nationality"] if not nat_row.empty else None
+def is_non_singaporean_no_pr(customer_id: str) -> bool:
+    cid = str(customer_id).strip()
+    nat_row = DF_ACCOUNT[DF_ACCOUNT["ID"].astype(str).str.strip() == cid]
+    nationality = nat_row.iloc[0]["Nationality"] if not nat_row.empty else None
 
-        pr_row = df_gov[df_gov["ID"].astype(str).str.strip() == cid]
-        pr_status = bool(pr_row.iloc[0]["PR_Status"]) if not pr_row.empty else False
+    pr_row = DF_GOV[DF_GOV["ID"].astype(str).str.strip() == cid]
+    pr_status = bool(pr_row.iloc[0]["PR_Status"]) if not pr_row.empty else False
 
-        return (str(nationality).strip().lower() != "singaporean") and (pr_status is False)
-    except Exception:
-        return False
+    return (str(nationality).strip().lower() != "singaporean") and (pr_status is False)
 
 
-def apply_mandatory_exception_to_report(report_text: str, customer_id: str, df_account, df_gov) -> str:
-    if report_text is None:
-        report_text = ""
-    text = str(report_text)
+def apply_mandatory_exception_to_report(report_text: str, customer_id: str) -> str:
+    text = "" if report_text is None else str(report_text)
 
-    if not is_non_singaporean_no_pr(customer_id, df_account, df_gov):
+    if not is_non_singaporean_no_pr(customer_id):
         return text
 
     text = re.sub(
@@ -264,12 +248,45 @@ def apply_mandatory_exception_to_report(report_text: str, customer_id: str, df_a
     return text
 
 
-# =========================================================
-# Prompts (same meaning as Step 6)
-# =========================================================
-qa_prompt_template = """
-You are a helpful banking assistant.
-Answer the user's question based strictly on the provided Customer Data and Policy Rules.
+# =========================
+# Unstructured resolver (Colab-style)
+# =========================
+def resolve_customer_id(unstructured_text: str):
+    s = (unstructured_text or "").strip()
+    if not s:
+        return None, "❌ Please enter Applicant Name or ID."
+
+    # 1) Extract an ID from any sentence
+    m = re.search(r"\b(\d{3,})\b", s)
+    if m:
+        cid = m.group(1)
+        prof = get_customer_profile(cid)
+        if prof:
+            return cid, f"✅ Found ID {cid}: {prof['Name']}"
+        return None, f"❌ No such customer ID: {cid}"
+
+    # 2) Otherwise treat as name search (contains)
+    results = DF_CREDIT[DF_CREDIT["Name"].astype(str).str.contains(s, case=False, na=False)]
+    if results.empty:
+        return None, f"❌ No such customer: '{s}'"
+
+    if len(results) == 1:
+        cid = str(results.iloc[0]["ID"])
+        nm = str(results.iloc[0]["Name"])
+        return cid, f"✅ Found Name '{nm}' -> ID {cid}"
+
+    # Multiple matches: no dropdown, just tell user to type ID
+    opts = ", ".join([f"{r['Name']} (ID {r['ID']})" for _, r in results.iterrows()])
+    return None, f"⚠️ Multiple customers match '{s}'. Please enter ID. Matches: {opts}"
+
+
+# =========================
+# Prompts / Chains
+# =========================
+QA_PROMPT = PromptTemplate(
+    input_variables=["customer_data", "policy_rules", "question"],
+    template="""
+You are a helpful banking assistant. Answer the user's question based strictly on the provided Customer Data and Policy Rules.
 
 CUSTOMER DATA:
 {customer_data}
@@ -282,24 +299,22 @@ USER QUESTION:
 
 ANSWER:
 """
-qa_prompt = PromptTemplate(
-    input_variables=["customer_data", "policy_rules", "question"],
-    template=qa_prompt_template
 )
 
-advice_prompt_template = """You are a helpful loan officer assistant.
+ADVICE_PROMPT = PromptTemplate(
+    input_variables=["customer_data", "policy_rules", "question"],
+    template="""You are a helpful loan officer assistant.
 
-Write in THIRD PERSON about the customer.
-Always use the customer's Name and possessive.
+Write in THIRD PERSON about the customer. Always use the customer's Name and possessive.
 Never address the reader as 'you' or 'your'.
 
-You must provide ADVICE/RECOMMENDATION.
+You must provide ADVICE/RECOMMENDATION (not just restating risk and rate).
 Use ONLY the provided Customer Data and Policy Rules.
 
 REQUIREMENTS:
-- Provide 3-5 actionable advice points.
-- Include a final recommendation: APPROVE or NOT RECOMMEND / REJECT.
-- If customer is Non-Singaporean and PR_Status is False, you MUST recommend NOT RECOMMEND / REJECT.
+- Provide 3-5 actionable advice points (short sentences).
+- Include a clear final recommendation: APPROVE or NOT RECOMMEND / REJECT.
+- If customer is Non-Singaporean and PR_Status is False, you MUST recommend NOT RECOMMEND / REJECT regardless of risk level.
 - Keep it concise.
 
 CUSTOMER DATA:
@@ -313,17 +328,14 @@ USER QUESTION:
 
 ANSWER:
 """
-advice_prompt = PromptTemplate(
-    input_variables=["customer_data", "policy_rules", "question"],
-    template=advice_prompt_template
 )
 
-report_prompt_template = """
-You are a senior loan officer.
-Generate a comprehensive loan assessment report based on the provided customer data and banking policies.
-Analyze the customer's profile, determine their overall risk, and calculate the applicable interest rate.
-Provide a clear recommendation on whether to approve the loan and justify it with policy rules,
-especially for any exceptions.
+REPORT_PROMPT = PromptTemplate(
+    input_variables=["customer_data", "policy_rules"],
+    template="""
+You are a senior loan officer. Generate a comprehensive loan assessment report based on the provided customer data and banking policies.
+Analyze the customer's profile, determine overall risk, calculate interest rate, and provide a clear recommendation.
+Follow any mandatory exceptions.
 
 CUSTOMER DATA:
 {customer_data}
@@ -333,250 +345,200 @@ POLICY RULES:
 
 REPORT:
 """
-report_prompt = PromptTemplate(
-    input_variables=["customer_data", "policy_rules"],
-    template=report_prompt_template
 )
 
 
-# =========================================================
-# Spaces init: NO pip installs, NO getpass
-# =========================================================
-BASE = os.path.dirname(__file__)
-CSV_PATH = os.path.join(BASE, "Customer records.csv")
-RISK_PDF = os.path.join(BASE, "Risk_Policy.pdf")
-INT_PDF = os.path.join(BASE, "Interest_Rate_Policy.pdf")
+# =========================
+# Global init (Spaces safe)
+# =========================
+RETRIEVER = None
+POLICY_FULL = ""
+LLM = None
 
-RETRIEVER_CACHE = None  # build embeddings lazily
+INIT_ERROR = None
 
+try:
+    # Check files
+    missing = [p for p in [CSV_FILE, RISK_PDF, INT_PDF] if not os.path.exists(p)]
+    if missing:
+        raise RuntimeError("Missing required files in repo root:\n" + "\n".join(missing))
 
-def init():
-    api_key = os.getenv("OPENAI_API_KEY", "").strip()
+    # Clean key (fixes illegal header newline)
+    api_key = os.getenv("OPENAI_API_KEY", "")
+    api_key = api_key.strip()
+    os.environ["OPENAI_API_KEY"] = api_key
     if not api_key:
         raise RuntimeError("Missing OPENAI_API_KEY. Set it in Space Secrets.")
 
-    missing = [p for p in [CSV_PATH, RISK_PDF, INT_PDF] if not os.path.exists(p)]
-    if missing:
-        raise RuntimeError("Missing required files:\n" + "\n".join(missing))
+    # Load CSV
+    DF_ALL = load_customer_csv(CSV_FILE)
+    DF_CREDIT, DF_ACCOUNT, DF_GOV = build_mock_systems(DF_ALL)
 
-    # Load data
-    df_all = load_customer_csv(CSV_PATH)
-    df_credit, df_account, df_gov = build_mock_systems(df_all)
+    # Load PDFs
+    RISK_TEXT = extract_pdf_text(RISK_PDF)
+    INT_TEXT  = extract_pdf_text(INT_PDF)
+    POLICY_FULL = RISK_TEXT + "\n\n" + INT_TEXT
 
-    # Load policies + parse
-    risk_text, interest_text, risk_mapping, interest_rates = load_policies(RISK_PDF, INT_PDF)
-    policy_full_text = risk_text + "\n\n" + interest_text
+    # Parse policies
+    RISK_MAPPING, INTEREST_RATES = parse_policies(RISK_TEXT, INT_TEXT)
 
     # LLM
     model_name = os.getenv("OPENAI_MODEL", "gpt-4o")
-    llm = ChatOpenAI(model=model_name, temperature=0)
+    LLM = ChatOpenAI(model=model_name, temperature=0, openai_api_key=api_key)
 
     # Chains (LCEL)
-    qa_chain = qa_prompt | llm
-    advice_chain = advice_prompt | llm
-    report_chain = report_prompt | llm
-
-    # For dropdown convenience
-    df_names = df_credit[["ID", "Name"]].copy()
-    df_names["label"] = df_names["Name"] + " (ID " + df_names["ID"].astype(str) + ")"
-    all_choices = df_names["label"].tolist()
-
-    return (
-        df_credit, df_account, df_gov,
-        risk_mapping, interest_rates,
-        risk_text, interest_text,
-        policy_full_text,
-        qa_chain, advice_chain, report_chain,
-        df_names, all_choices
-    )
-
+    QA_CHAIN = QA_PROMPT | LLM
+    ADVICE_CHAIN = ADVICE_PROMPT | LLM
+    REPORT_CHAIN = REPORT_PROMPT | LLM
 
-try:
-    (
-        DF_CREDIT, DF_ACCOUNT, DF_GOV,
-        RISK_MAP, RATE_MAP,
-        RISK_TEXT, INT_TEXT,
-        POLICY_FULL,
-        QA_CHAIN, ADVICE_CHAIN, REPORT_CHAIN,
-        DF_NAMES, ALL_CHOICES
-    ) = init()
-    INIT_ERROR = None
 except Exception as e:
     INIT_ERROR = str(e)
 
 
-def _build_retriever_if_needed():
-    global RETRIEVER_CACHE
-    if RETRIEVER_CACHE is not None:
-        return RETRIEVER_CACHE, None
+def build_retriever_if_needed():
+    global RETRIEVER
+    if RETRIEVER is not None:
+        return RETRIEVER
 
-    try:
-        docs = [
-            Document(page_content=RISK_TEXT, metadata={"source": "Risk_Policy.pdf"}),
-            Document(page_content=INT_TEXT, metadata={"source": "Interest_Rate_Policy.pdf"}),
-        ]
-        embeddings = OpenAIEmbeddings()
-        vector_db = FAISS.from_documents(docs, embeddings)
-        RETRIEVER_CACHE = vector_db.as_retriever()
-        return RETRIEVER_CACHE, None
-    except Exception as e:
-        return None, str(e)
+    api_key = os.getenv("OPENAI_API_KEY", "").strip()
+    if not api_key:
+        return None
+
+    docs = [
+        Document(page_content=RISK_TEXT, metadata={"source": "Risk_Policy.pdf"}),
+        Document(page_content=INT_TEXT,  metadata={"source": "Interest_Rate_Policy.pdf"}),
+    ]
+    embeddings = OpenAIEmbeddings(openai_api_key=api_key)
+    db = FAISS.from_documents(docs, embeddings)
+    RETRIEVER = db.as_retriever()
+    return RETRIEVER
 
 
-def _policy_context(use_rag: bool) -> str:
+def get_policy_context(use_rag: bool) -> str:
     if not use_rag:
         return POLICY_FULL
 
-    retriever, err = _build_retriever_if_needed()
-    if retriever is None:
-        return POLICY_FULL + f"\n\n[Note] RAG disabled due to embeddings error: {err}"
-
     try:
-        relevant_docs = retriever.invoke("risk level interest rate PR status")
-        ctx = "\n\n".join([d.page_content for d in relevant_docs]).strip()
+        retriever = build_retriever_if_needed()
+        if retriever is None:
+            return POLICY_FULL + "\n\n[Note] RAG unavailable (missing API key). Using full policy text."
+
+        docs = retriever.invoke("risk level interest rate PR status")
+        ctx = "\n\n".join([d.page_content for d in docs]).strip()
         return ctx if ctx else POLICY_FULL
     except Exception as e:
-        return POLICY_FULL + f"\n\n[Note] RAG retrieval failed, using full policy text: {e}"
-
-
-def find_matches(name_or_id: str):
-    if INIT_ERROR:
-        return [], f"❌ Initialization error:\n{INIT_ERROR}"
-
-    s = (name_or_id or "").strip()
-    if not s:
-        return [], "Type a Name or ID, then click Find."
-
-    # ID
-    if s.isdigit():
-        prof = get_customer_profile(s, DF_CREDIT, DF_ACCOUNT, DF_GOV)
-        if prof:
-            label = prof["Name"] + " (ID " + str(prof["ID"]) + ")"
-            return [label], f"✅ Found ID {s}"
-        return [], f"❌ ID {s} not found."
-
-    # Name contains
-    results = DF_CREDIT[DF_CREDIT["Name"].astype(str).str.contains(s, case=False, na=False)]
-    if results.empty:
-        return [], f"❌ No customer matched '{s}'."
-
-    if len(results) == 1:
-        row = results.iloc[0]
-        label = row["Name"] + " (ID " + str(row["ID"]) + ")"
-        return [label], f"✅ Found Name '{row['Name']}'"
-
-    labels = []
-    for _, r in results.iterrows():
-        labels.append(r["Name"] + " (ID " + str(r["ID"]) + ")")
-    return labels, f"⚠️ Multiple matches for '{s}'. Please select one."
-
-
-def _resolve_id_from_label(label: str) -> str:
-    row = DF_NAMES[DF_NAMES["label"] == label]
-    if row.empty:
-        return ""
-    return str(row.iloc[0]["ID"])
+        return POLICY_FULL + f"\n\n[Note] RAG failed, using full policy text: {e}"
 
 
-def run_action(selected_label: str, action: str, use_rag: bool):
+# =========================
+# Main Run (Colab-style)
+# =========================
+def run_action(user_input: str, action: str, use_rag: bool):
     if INIT_ERROR:
-        return f"❌ Initialization error:\n{INIT_ERROR}"
+        return f"❌ Initialization error:\n\n{INIT_ERROR}"
 
-    cid = _resolve_id_from_label(selected_label)
-    if not cid:
-        return "❌ Please select an applicant first."
-
-    profile = get_customer_profile(cid, DF_CREDIT, DF_ACCOUNT, DF_GOV)
-    if not profile:
-        return f"❌ Customer ID {cid} not found."
-
-    prof_text = format_customer_profile(profile)
-    name = profile.get("Name", "Customer")
-
-    policy_context = _policy_context(use_rag)
-
-    # Option 1: Risk & interest
-    if action == "1) Check Risk & Interest":
-        question = f"What are the risk level and applicable interest rate for the customer {cid}?"
-        response = QA_CHAIN.invoke({
-            "customer_data": prof_text,
-            "policy_rules": policy_context,
-            "question": question
-        })
-        return one_sentence_per_line(response.content)
-
-    # Option 2: Advice
-    if action == "2) Advice / Recommendation":
-        question = f"What interest rate advice can be recommended for customer with Id {cid}?"
-        response = ADVICE_CHAIN.invoke({
-            "customer_data": prof_text,
-            "policy_rules": policy_context,
-            "question": question
+    try:
+        customer_id, msg = resolve_customer_id(user_input)
+        if not customer_id:
+            return msg
+
+        profile = get_customer_profile(customer_id)
+        if not profile:
+            return f"❌ No such customer ID: {customer_id}"
+
+        profile_text = format_customer_profile(profile)
+        policy_context = get_policy_context(use_rag)
+
+        # Deterministic summary (optional but helps demo)
+        overall_risk = determine_overall_risk(profile["Credit_Score"], profile["Account_Status"])
+        rate = determine_interest_rate(overall_risk)
+        must_reject = is_non_singaporean_no_pr(customer_id)
+
+        det = [
+            msg,
+            "",
+            "Deterministic (Policy-based):",
+            f"- Overall risk: {overall_risk}",
+            f"- Interest rate: {rate:.3f}%",
+        ]
+        if must_reject:
+            det.append("- Mandatory exception: NOT RECOMMEND / REJECT (Non-Singaporean without PR).")
+        det_text = "\n".join(det)
+
+        if action == "1) Check Risk & Interest":
+            question = f"What are the risk level and applicable interest rate for the customer {customer_id}?"
+            resp = QA_CHAIN.invoke({
+                "customer_data": profile_text,
+                "policy_rules": policy_context,
+                "question": question
+            })
+            return det_text + "\n\nAI Output:\n" + one_sentence_per_line(resp.content)
+
+        if action == "2) Advice / Recommendation":
+            question = f"What interest rate advice can be recommended for customer with Id {customer_id}?"
+            resp = ADVICE_CHAIN.invoke({
+                "customer_data": profile_text,
+                "policy_rules": policy_context,
+                "question": question
+            })
+            return det_text + "\n\nAI Output:\n" + one_sentence_per_line(enforce_third_person(resp.content, profile.get("Name", "Customer")))
+
+        # 3) FULL report
+        customer_data_with_exception = profile_text + (
+            "\n\nMANDATORY EXCEPTION (must follow): Non-Singaporean with PR_Status = False => NOT RECOMMENDED / REJECTED."
+            if must_reject else ""
+        )
+        full_report = REPORT_CHAIN.invoke({
+            "customer_data": customer_data_with_exception,
+            "policy_rules": policy_context
         })
-        return one_sentence_per_line(enforce_third_person(response.content, name))
-
-    # Option 3: Full report (+ mandatory exception enforcement)
-    customer_data_with_exception = prof_text + (
-        "\n\nMANDATORY EXCEPTION (must follow): Non-Singaporean with PR_Status = False => NOT RECOMMENDED / REJECTED."
-        if is_non_singaporean_no_pr(cid, DF_ACCOUNT, DF_GOV)
-        else ""
-    )
+        final_text = apply_mandatory_exception_to_report(full_report.content, customer_id)
+        return det_text + "\n\nFull Report:\n" + one_sentence_per_line(final_text)
 
-    full_report = REPORT_CHAIN.invoke({
-        "customer_data": customer_data_with_exception,
-        "policy_rules": policy_context
-    })
-
-    report_text = apply_mandatory_exception_to_report(full_report.content, cid, DF_ACCOUNT, DF_GOV)
-    return one_sentence_per_line(report_text)
+    except Exception:
+        return "❌ Run failed:\n\n" + traceback.format_exc()
 
 
-# =========================================================
-# Gradio UI (replaces your input() loop)
-# =========================================================
+# =========================
+# Gradio UI (NO dropdown)
+# =========================
 with gr.Blocks(title="Bank Loan Officer System") as demo:
-    gr.Markdown("# 🏦 BANK LOAN OFFICER SYSTEM (v2.0) — Web Demo")
-    gr.Markdown("Type Applicant Name or ID → Find → Select → Run an action.")
+    gr.Markdown("# 🏦 Bank Loan Officer System (Unstructured Input Search)")
+    gr.Markdown("Type Applicant **Name / ID / sentence**. The system resolves and responds like your Colab notebook.")
 
     if INIT_ERROR:
         gr.Markdown(f"## ❌ Initialization error\n\n```\n{INIT_ERROR}\n```")
 
-    with gr.Row():
-        name_or_id = gr.Textbox(label="Applicant Name OR ID", placeholder="e.g. Hilda or 3333")
-        find_btn = gr.Button("🔎 Find")
+    user_input = gr.Textbox(
+        label="Applicant Name or ID (unstructured)",
+        placeholder="e.g. 3333 OR Hilda OR 'please check loan for 3333'"
+    )
 
-    with gr.Row():
-        matches = gr.Dropdown(
-            label="Matches (select one)",
-            choices=[] if INIT_ERROR else ALL_CHOICES,
-            value=None
-        )
-        find_status = gr.Textbox(label="Find status", interactive=False)
-
-    find_btn.click(fn=find_matches, inputs=[name_or_id], outputs=[matches, find_status])
-
-    gr.Markdown("### Actions")
-    with gr.Row():
-        action = gr.Radio(
-            label="Select Option",
-            choices=[
-                "1) Check Risk & Interest",
-                "2) Advice / Recommendation",
-                "3) FULL Formal Loan Report"
-            ],
-            value="1) Check Risk & Interest"
-        )
-        use_rag = gr.Checkbox(
-            label="Use RAG (FAISS embeddings + retrieval). If it fails, auto fallback.",
-            value=True
-        )
+    action = gr.Radio(
+        label="Action",
+        choices=[
+            "1) Check Risk & Interest",
+            "2) Advice / Recommendation",
+            "3) FULL Formal Loan Report"
+        ],
+        value="1) Check Risk & Interest"
+    )
+
+    use_rag = gr.Checkbox(
+        label="Use RAG (FAISS embeddings). If it fails, auto fallback.",
+        value=False
+    )
 
     run_btn = gr.Button("🚀 Run")
-    output = gr.Textbox(label="Output", lines=24)
+    output = gr.Textbox(label="Output", lines=28)
+
+    run_btn.click(fn=run_action, inputs=[user_input, action, use_rag], outputs=[output])
+    user_input.submit(fn=run_action, inputs=[user_input, action, use_rag], outputs=[output])
 
-    run_btn.click(fn=run_action, inputs=[matches, action, use_rag], outputs=[output])
 
-demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)
+# =========================
+# HF Spaces launch (the add-on at bottom)
+# =========================
 PORT = int(os.environ.get("PORT", 7860))
 demo.queue().launch(
     server_name="0.0.0.0",