Update app/app_chat.py

app/app_chat.py

@@ -8,42 +8,66 @@ import os
 import boto3
 from botocore.config import Config
 
-AWS_REGION = os.getenv("AWS_REGION", "us-east-1")
-
-bedrock = boto3.client(
-    "bedrock-runtime",
-    region_name=AWS_REGION,
-    config=Config(read_timeout=60, connect_timeout=60, retries={"max_attempts": 3}),
-)
+# ============================================================
+# Bedrock (Amazon Nova) setup
+# ============================================================
 
-# Choose a Nova model ID available in your Bedrock account.
-# Common examples include Nova Lite / Pro in Bedrock.
+AWS_REGION = os.getenv("AWS_REGION", "us-east-1")
 NOVA_MODEL_ID = os.getenv("NOVA_MODEL_ID", "us.amazon.nova-lite-v1:0")
 
+def make_bedrock_client():
+    """
+    Creates a Bedrock Runtime client.
+    Auth is provided via Hugging Face Secrets / env vars:
+      - AWS_BEARER_TOKEN_BEDROCK (Bedrock API key)
+      - AWS_REGION
+    """
+    # If key not set, we'll still create client, but calls will fail with a clear error later.
+    return boto3.client(
+        "bedrock-runtime",
+        region_name=AWS_REGION,
+        config=Config(read_timeout=60, connect_timeout=60, retries={"max_attempts": 3}),
+    )
+
+bedrock = make_bedrock_client()
 
+# ============================================================
+# Streamlit App
+# ============================================================
 
 st.set_page_config(page_title="EchoML", page_icon="💬", layout="wide")
-st.title("💬 Chat with Your Model(IRIS Edition)")
+st.title("💬 Chat with Your Model (IRIS Edition)")
 
 # Sidebar configuration
 with st.sidebar:
     st.header("Settings")
-    api_url = st.text_input("FastAPI endpoint", value="https://query-your-model-api-784882848382.us-central1.run.app/explain")
-    model_path = st.text_input("Model path", value="Query_Your_Model/model_data/model.pkl")
+    api_url = st.text_input(
+        "FastAPI endpoint",
+        value=os.getenv("ECHO_API_URL", "https://query-your-model-api-784882848382.us-central1.run.app/explain"),
+    )
+    model_path = st.text_input("Model path", value=os.getenv("MODEL_PATH", "Query_Your_Model/model_data/model.pkl"))
     feat_names_str = st.text_input(
         "Feature names (comma-separated)",
-        value="sepal length (cm),sepal width (cm),petal length (cm),petal width (cm)"
+        value=os.getenv(
+            "FEATURE_NAMES",
+            "sepal length (cm),sepal width (cm),petal length (cm),petal width (cm)"
+        ),
     )
-    namespace = st.text_input("Namespace", value="Query_Your_Model/data/base_indices/iris_global")
+    namespace = st.text_input("Namespace", value=os.getenv("NAMESPACE", "Query_Your_Model/data/base_indices/iris_global"))
     alpha = st.slider("Alpha (retrieval weight)", 0.0, 1.0, 0.7, 0.05)
     k = st.slider("Top-K similar to retrieve", 1, 10, 5)
 
+    st.divider()
+    st.caption("LLM provider: Amazon Bedrock (Nova)")
+    st.caption(f"AWS_REGION: `{AWS_REGION}`")
+    st.caption(f"NOVA_MODEL_ID: `{NOVA_MODEL_ID}`")
 
-feat_names = [s.strip() for s in feat_names_str.split(",")]
-
-
+feat_names = [s.strip() for s in feat_names_str.split(",") if s.strip()]
 
+# ============================================================
 # Helpers
+# ============================================================
+
 def label_from_pred(y_pred):
     try:
         num = int(round(float(y_pred)))
@@ -66,10 +90,10 @@ def summarize_prediction(res):
 
 def show_similar_cases(res, n_display, feat_names):
     sims = safe_similar_cases(res)
-    if not sims: 
+    if not sims:
         return "No similar cases were retrieved."
     n = min(n_display, len(sims))
-    lines = [f"It found **{len(sims)}** similar past cases (showing **{n}**):"]
+    lines = [f"It found **{len(sims)}** similar cases (showing **{n}**):"]
     for case in sims[:n]:
         features_named = ", ".join([f"{name} = {val:.2f}" for name, val in zip(feat_names, case["features"])])
         lines.append(f"- **{case['case_id']}** → {features_named}, predicted as **{case['y_pred']}**.")
@@ -82,7 +106,7 @@ def plot_shap_bar(topk):
     feats = [f["feature"] for f in topk]
     shap_vals = [f["shap"] for f in topk]
     fig, ax = plt.subplots()
-    ax.barh(feats, shap_vals)  # default colors per instructions
+    ax.barh(feats, shap_vals)  # default colors
     ax.set_xlabel("SHAP value (impact on prediction)")
     ax.set_title("Feature importance for this prediction")
     st.pyplot(fig)
@@ -119,7 +143,29 @@ def explain_in_words(res, n_display, feat_names):
     st.markdown("\n".join(msg))
     plot_shap_bar(topk)
 
+def bedrock_llm(prompt: str) -> str:
+    """
+    Calls Amazon Nova via Bedrock Converse API.
+    Requires Hugging Face Secret: AWS_BEARER_TOKEN_BEDROCK
+    """
+    if not os.getenv("AWS_BEARER_TOKEN_BEDROCK"):
+        return (
+            "LLM explanation is not available because `AWS_BEARER_TOKEN_BEDROCK` is not set.\n\n"
+            "In Hugging Face Spaces → Settings → Variables and secrets → Secrets, add:\n"
+            "- Name: AWS_BEARER_TOKEN_BEDROCK\n"
+            "- Value: (your Bedrock API key)\n"
+        )
+
+    resp = bedrock.converse(
+        modelId=NOVA_MODEL_ID,
+        messages=[{"role": "user", "content": [{"text": prompt}]}],
+    )
+    return resp["output"]["message"]["content"][0]["text"]
+
 def llm_explain(res, feat_names, extra_context=None):
+    """
+    LLM explanation: can handle 'why' and 'what-if' using the provided context (old/new).
+    """
     try:
         pred = label_from_pred(res["prediction"]["y_pred"])
         proba = res["prediction"]["proba"]
@@ -141,20 +187,14 @@ def llm_explain(res, feat_names, extra_context=None):
             "- Why the model made the prediction\n"
             "- Which features mattered\n"
             "- Why those features mattered\n"
-            "- Experiments the user could perform: tell them which feature values to increase/decrease"
-        )
-
-        response = bedrock.converse(
-            modelId=NOVA_MODEL_ID,
-            messages=[{"role": "user", "content": [{"text": prompt}]}],
+            "- 2-3 experiments the user could perform: tell them which feature values to increase/decrease"
         )
 
-        return response["output"]["message"]["content"][0]["text"]
+        return bedrock_llm(prompt)
 
     except Exception as e:
         return f"LLM explanation failed: {e}"
 
-
 def interpret_question(user_q):
     q = (user_q or "").lower()
     if any(w in q for w in ["what if", "increase", "decrease", "set ", "make ", "higher", "lower", "raise", "reduce", "change"]):
@@ -173,9 +213,13 @@ def perform_api_call(features):
         "namespace": namespace,
         "retrieval": {"alpha": alpha, "k": k, "use_retrieval": True, "namespace": namespace},
     }
-    return requests.post(api_url, json=payload).json()
+    r = requests.post(api_url, json=payload, timeout=60)
+    r.raise_for_status()
+    return r.json()
 
+# ============================================================
 # What-if parsing
+# ============================================================
 
 FEATURE_NAME_PAT = re.compile(r"([a-zA-Z][a-zA-Z0-9 _\-\(\)]*)")
 
@@ -204,24 +248,13 @@ def default_delta(curr):
 def apply_what_if(user_q, feat_names, current_features):
     """
     Returns (new_features, change_text) or (None, error_msg)
-
-    Handles:
-      - "increase sepal length to 5.8"
-      - "decrease petal width by 0.2"
-      - "increase sepal width by 10%"
-      - "make petal length higher"
-      - "slightly increase sepal width"
-      - "increase sepal length to 5.8, decrease petal width to 0.2 and reduce sepal width a bit"
     """
-
     q = user_q.lower()
     new = current_features.copy()
     changes = []
 
-    # Split query by commas or 'and'
     parts = re.split(r",| and ", q)
 
-    # Define modifiers with scaling factors (relative to default 10%)
     modifier_scale = {
         "slightly": 0.5,
         "a bit": 0.5,
@@ -238,7 +271,6 @@ def apply_what_if(user_q, feat_names, current_features):
         if not part:
             continue
 
-        # Detect intensity modifier
         scale = 1.0
         for mod, factor in modifier_scale.items():
             if mod in part:
@@ -246,7 +278,7 @@ def apply_what_if(user_q, feat_names, current_features):
                 part = part.replace(mod, "")
                 break
 
-        # 1) Direct set: "= X" or "to X"
+        # 1) Set to value
         m = re.search(r"(?:set|what if|change|increase|decrease|raise|reduce)\s+(.*?)\s*(?:=|to)\s*([-+]?\d*\.?\d+)", part)
         if m:
             feat_frag, val_str = m.group(1), m.group(2)
@@ -263,7 +295,7 @@ def apply_what_if(user_q, feat_names, current_features):
             changes.append(f"Set **{fname}** to **{val:.2f}**.")
             continue
 
-        # 2) increase/decrease by absolute value
+        # 2) Increase/decrease by absolute value
         m = re.search(r"(increase|decrease|raise|reduce)\s+(.*?)\s+by\s+([-+]?\d*\.?\d+)\b(?!%)", part)
         if m:
             op, feat_frag, val_str = m.groups()
@@ -276,16 +308,13 @@ def apply_what_if(user_q, feat_names, current_features):
                 changes.append(f"Couldn't parse a number from: '{val_str}'.")
                 continue
             delta *= scale
-            if op in ["decrease", "reduce"]:
-                delta = -abs(delta)
-            else:
-                delta = abs(delta)
+            delta = -abs(delta) if op in ["decrease", "reduce"] else abs(delta)
             idx = feat_names.index(fname)
             new[idx] = new[idx] + delta
             changes.append(f"{'Increased' if delta>0 else 'Decreased'} **{fname}** by **{abs(delta):.2f}** → **{new[idx]:.2f}**.")
             continue
 
-        # 3) increase/decrease by percent
+        # 3) Increase/decrease by percent
         m = re.search(r"(increase|decrease|raise|reduce)\s+(.*?)\s+by\s+([-+]?\d*\.?\d+)\s*%", part)
         if m:
             op, feat_frag, perc_str = m.groups()
@@ -299,12 +328,12 @@ def apply_what_if(user_q, feat_names, current_features):
                 continue
             perc *= scale
             idx = feat_names.index(fname)
-            factor = 1.0 + (abs(perc)/100.0 if op in ["increase","raise"] else -abs(perc)/100.0)
+            factor = 1.0 + (abs(perc) / 100.0 if op in ["increase", "raise"] else -abs(perc) / 100.0)
             new[idx] = new[idx] * factor
             changes.append(f"{op.title()}d **{fname}** by **{abs(perc):.0f}%** → **{new[idx]:.2f}**.")
             continue
 
-        # 4) make X higher/lower (no number) → ±10% default * modifier scale
+        # 4) Make higher/lower (no number)
         m = re.search(r"(make|set)?\s*(.*?)\s*(higher|lower|increase|decrease|raise|reduce)", part)
         if m:
             _, feat_frag, direction = m.groups()
@@ -327,9 +356,11 @@ def apply_what_if(user_q, feat_names, current_features):
 
     return new, "\n".join(changes)
 
-
+# ============================================================
 # Step 1: Enter features & predict
-st.subheader("Step 1 – Enter features to generate a prediction in the order: [sepal length,sepal width,petal length and petal width]")
+# ============================================================
+
+st.subheader("Step 1 – Enter features to generate a prediction in the order: [sepal length, sepal width, petal length, petal width]")
 user_features = st.text_input("Enter feature values (comma-separated)", "")
 predict_btn = st.button("🔍 Predict and Explain")
 
@@ -345,19 +376,21 @@ if predict_btn:
             st.warning(f"Expected {len(feat_names)} values ({', '.join(feat_names)}), but got {len(features)}.")
         else:
             st.session_state["input_features"] = features
-            # Show entered features
             st.markdown("### ✨ Entered Features")
             st.markdown("\n".join([f"- **{n}** = {v:.2f}" for n, v in zip(feat_names, features)]))
-            # Call API
+
             res = perform_api_call(features)
             st.session_state["prediction_result"] = res
             st.session_state["messages"] = []
             st.success(summarize_prediction(res))
-            st.info("Scroll down to explore similar cases or chat ")
+            st.info("Scroll down to explore similar cases or chat.")
     except Exception as e:
-        st.error(f"Error contacting API: {e}")
+        st.error(f"Error generating prediction: {e}")
+
+# ============================================================
+# Step 2 + 3
+# ============================================================
 
-# Step 2: Similar cases
 if st.session_state["prediction_result"]:
     st.divider()
     st.subheader("Step 2 – Explore similar cases")
@@ -376,26 +409,22 @@ if st.session_state["prediction_result"]:
     else:
         st.write("No similar cases retrieved.")
 
-    # Step 3: Explanation Mode + Chat
     st.divider()
     st.subheader("Step 3 – Chat with the model about this prediction")
 
-    # Choose explanation mode BEFORE asking questions
     if "chat_mode" not in st.session_state:
         st.session_state["chat_mode"] = "System"
     st.session_state["chat_mode"] = st.radio(
         "How should explanations be generated?",
         ["System", "LLM (Natural language)"],
-        index=0 if "System" in st.session_state["chat_mode"] else 1,
+        index=0 if st.session_state["chat_mode"] == "System" else 1,
         horizontal=True,
     )
 
-    # Show previous messages
     for role, content in st.session_state["messages"]:
         with st.chat_message(role):
             st.markdown(content)
 
-    # Chat input
     if user_q := st.chat_input("Ask e.g. 'Why this prediction?' or 'Increase petal length by 0.3' or 'set sepal width to 3.8'"):
         st.session_state["messages"].append(("user", user_q))
         with st.chat_message("user"):
@@ -403,7 +432,6 @@ if st.session_state["prediction_result"]:
 
         intent = interpret_question(user_q)
 
-        # Current base result
         base_res = st.session_state["prediction_result"]
         base_pred = base_res["prediction"]["y_pred"]
         base_proba = base_res["prediction"]["proba"]
@@ -411,7 +439,7 @@ if st.session_state["prediction_result"]:
 
         if intent == "explain":
             if "LLM" in st.session_state["chat_mode"]:
-                with st.spinner(" Generating LLM explanation..."):
+                with st.spinner("Generating LLM explanation (Nova)..."):
                     answer = llm_explain(base_res, feat_names)
                 st.session_state["messages"].append(("assistant", answer))
                 with st.chat_message("assistant"):
@@ -428,7 +456,6 @@ if st.session_state["prediction_result"]:
                 st.markdown(text)
 
         elif intent == "what_if":
-            # Parse & apply change, recompute, compare
             if st.session_state["input_features"] is None:
                 msg = "Please run a prediction first (Step 1) so I know your starting feature values."
                 st.session_state["messages"].append(("assistant", msg))
@@ -452,15 +479,14 @@ if st.session_state["prediction_result"]:
                         ctx = {
                             "change_applied": status,
                             "before": {"features": st.session_state["input_features"], "label": base_label, "proba": base_proba},
-                            "after": {"features": new_feats, "label": new_label, "proba": new_proba}
+                            "after": {"features": new_feats, "label": new_label, "proba": new_proba},
                         }
-                        with st.spinner(" Summarizing the effect with LLM..."):
+                        with st.spinner("Summarizing the effect (Nova)..."):
                             answer = llm_explain(new_res, feat_names, extra_context=ctx)
                         st.session_state["messages"].append(("assistant", answer))
                         with st.chat_message("assistant"):
                             st.markdown(answer)
                     else:
-                        # System comparison summary + new SHAP chart
                         lines = [
                             f"**Change applied:** {status}",
                             f"**Before:** {base_label} (class `{base_pred}`) — confidence **{base_proba:.2f}**",
@@ -473,7 +499,6 @@ if st.session_state["prediction_result"]:
                         st.session_state["messages"].append(("assistant", "What-if comparison + SHAP shown above."))
 
         else:
-            # Summary fallback
             summary = summarize_prediction(base_res)
             st.session_state["messages"].append(("assistant", summary))
             with st.chat_message("assistant"):