update

app.py

@@ -4,27 +4,33 @@ import json
 import time
 import traceback
 from pathlib import Path
-from typing import Dict, Any, List, Tuple
+from typing import Dict, Any, List, Tuple, Optional
 
 import pandas as pd
 import gradio as gr
-import papermill as pm
 import plotly.graph_objects as go
 
-# Optional LLM (HuggingFace Inference API)
+try:
+    import papermill as pm
+except Exception:
+    pm = None
+
 try:
     from huggingface_hub import InferenceClient
 except Exception:
     InferenceClient = None
 
 # =========================================================
-# CONFIG
+# CONFIG — ITALY HOSPITALITY MARKET INSIGHT ASSISTANT
 # =========================================================
 
 BASE_DIR = Path(__file__).resolve().parent
 
-NB1 = os.environ.get("NB1", "datacreation.ipynb").strip()
-NB2 = os.environ.get("NB2", "pythonanalysis.ipynb").strip()
+NB1 = os.environ.get("NB1", "1_Data_Creation_Italy_Hospitality.ipynb").strip()
+NB2 = os.environ.get("NB2", "2a_Python_Analysis_Italy_Hospitality.ipynb").strip()
+
+CLEANED_CSV = os.environ.get("CLEANED_CSV", "italy_hospitality_market_cleaned.csv").strip()
+ENRICHED_CSV = os.environ.get("ENRICHED_CSV", "italy_hospitality_market_enriched_synthetic.csv").strip()
 
 RUNS_DIR = BASE_DIR / "runs"
 ART_DIR = BASE_DIR / "artifacts"
@@ -32,20 +38,22 @@ PY_FIG_DIR = ART_DIR / "py" / "figures"
 PY_TAB_DIR = ART_DIR / "py" / "tables"
 
 PAPERMILL_TIMEOUT = int(os.environ.get("PAPERMILL_TIMEOUT", "1800"))
-MAX_PREVIEW_ROWS = int(os.environ.get("MAX_FILE_PREVIEW_ROWS", "50"))
+MAX_PREVIEW_ROWS = int(os.environ.get("MAX_FILE_PREVIEW_ROWS", "80"))
 MAX_LOG_CHARS = int(os.environ.get("MAX_LOG_CHARS", "8000"))
 
+# Hugging Face Inference API
 HF_API_KEY = os.environ.get("HF_API_KEY", "").strip()
 MODEL_NAME = os.environ.get("MODEL_NAME", "deepseek-ai/DeepSeek-R1").strip()
 HF_PROVIDER = os.environ.get("HF_PROVIDER", "novita").strip()
+
+# Optional n8n automation webhook. Expected JSON response:
+# {"answer": "...", "chart": "risk|investment|city|region|overview|none"}
 N8N_WEBHOOK_URL = os.environ.get("N8N_WEBHOOK_URL", "").strip()
 
 LLM_ENABLED = bool(HF_API_KEY) and InferenceClient is not None
-llm_client = (
-    InferenceClient(provider=HF_PROVIDER, api_key=HF_API_KEY)
-    if LLM_ENABLED
-    else None
-)
+llm_client = InferenceClient(provider=HF_PROVIDER, api_key=HF_API_KEY) if LLM_ENABLED else None
+
+CHART_PALETTE = ["#7c5cbf", "#2ec4a0", "#e8537a", "#e8a230", "#5e8fef", "#c45ea8"]
 
 # =========================================================
 # HELPERS
@@ -55,12 +63,29 @@ def ensure_dirs():
     for p in [RUNS_DIR, ART_DIR, PY_FIG_DIR, PY_TAB_DIR]:
         p.mkdir(parents=True, exist_ok=True)
 
-def stamp():
+def stamp() -> str:
     return time.strftime("%Y%m%d-%H%M%S")
 
 def tail(text: str, n: int = MAX_LOG_CHARS) -> str:
     return (text or "")[-n:]
 
+def csv_path(prefer_enriched: bool = True) -> Path:
+    enriched = BASE_DIR / ENRICHED_CSV
+    cleaned = BASE_DIR / CLEANED_CSV
+    if prefer_enriched and enriched.exists():
+        return enriched
+    if cleaned.exists():
+        return cleaned
+    return enriched
+
+def read_market_data(prefer_enriched: bool = True) -> pd.DataFrame:
+    path = csv_path(prefer_enriched)
+    if not path.exists():
+        return pd.DataFrame(columns=["section", "location", "entity", "metric_name", "value", "unit", "period", "source_page", "note"])
+    df = pd.read_csv(path)
+    df["value"] = pd.to_numeric(df.get("value"), errors="coerce")
+    return df
+
 def _ls(dir_path: Path, exts: Tuple[str, ...]) -> List[str]:
     if not dir_path.is_dir():
         return []
@@ -75,21 +100,39 @@ def _read_json(path: Path):
 
 def artifacts_index() -> Dict[str, Any]:
     return {
+        "core_files": {
+            "cleaned_dataset": CLEANED_CSV if (BASE_DIR / CLEANED_CSV).exists() else None,
+            "enriched_synthetic_dataset": ENRICHED_CSV if (BASE_DIR / ENRICHED_CSV).exists() else None,
+        },
         "python": {
             "figures": _ls(PY_FIG_DIR, (".png", ".jpg", ".jpeg")),
             "tables": _ls(PY_TAB_DIR, (".csv", ".json")),
         },
     }
 
+def pivot_metrics(df: pd.DataFrame, section: Optional[str] = None, entity: Optional[str] = None) -> pd.DataFrame:
+    d = df.copy()
+    if section:
+        d = d[d["section"].eq(section)]
+    if entity:
+        d = d[d["entity"].eq(entity)]
+    if d.empty:
+        return pd.DataFrame()
+    wide = d.pivot_table(index=["location", "entity"], columns="metric_name", values="value", aggfunc="first").reset_index()
+    wide.columns.name = None
+    return wide
+
 # =========================================================
 # PIPELINE RUNNERS
 # =========================================================
 
 def run_notebook(nb_name: str) -> str:
     ensure_dirs()
+    if pm is None:
+        return "ERROR: papermill is not installed. Add it to requirements.txt."
     nb_in = BASE_DIR / nb_name
     if not nb_in.exists():
-        return f"ERROR: {nb_name} not found."
+        return f"ERROR: {nb_name} not found in {BASE_DIR}."
     nb_out = RUNS_DIR / f"run_{stamp()}_{nb_name}"
     pm.execute_notebook(
         input_path=str(nb_in),
@@ -100,17 +143,15 @@ def run_notebook(nb_name: str) -> str:
         request_save_on_cell_execute=True,
         execution_timeout=PAPERMILL_TIMEOUT,
     )
-    return f"Executed {nb_name}"
-
+    return f"Executed {nb_name}. Output saved to {nb_out.name}"
 
 def run_datacreation() -> str:
     try:
         log = run_notebook(NB1)
-        csvs = [f.name for f in BASE_DIR.glob("*.csv")]
-        return f"OK  {log}\n\nCSVs now in /app:\n" + "\n".join(f"  - {c}" for c in sorted(csvs))
+        csvs = sorted(p.name for p in BASE_DIR.glob("*.csv"))
+        return f"OK — {log}\n\nCSVs available:\n" + "\n".join(f"  - {c}" for c in csvs)
     except Exception as e:
-        return f"FAILED  {e}\n\n{traceback.format_exc()[-2000:]}"
-
+        return f"FAILED — {e}\n\n{traceback.format_exc()[-2000:]}"
 
 def run_pythonanalysis() -> str:
     try:
@@ -118,494 +159,393 @@ def run_pythonanalysis() -> str:
         idx = artifacts_index()
         figs = idx["python"]["figures"]
         tabs = idx["python"]["tables"]
-        return (
-            f"OK  {log}\n\n"
-            f"Figures: {', '.join(figs) or '(none)'}\n"
-            f"Tables:  {', '.join(tabs) or '(none)'}"
-        )
+        return f"OK — {log}\n\nFigures: {', '.join(figs) or '(none)'}\nTables: {', '.join(tabs) or '(none)'}"
     except Exception as e:
-        return f"FAILED  {e}\n\n{traceback.format_exc()[-2000:]}"
-
+        return f"FAILED — {e}\n\n{traceback.format_exc()[-2000:]}"
 
 def run_full_pipeline() -> str:
-    logs = []
-    logs.append("=" * 50)
-    logs.append("STEP 1/2: Data Creation (web scraping + synthetic data)")
-    logs.append("=" * 50)
-    logs.append(run_datacreation())
-    logs.append("")
-    logs.append("=" * 50)
-    logs.append("STEP 2/2: Python Analysis (sentiment, ARIMA, dashboard)")
-    logs.append("=" * 50)
-    logs.append(run_pythonanalysis())
-    return "\n".join(logs)
-
+    return "\n".join([
+        "=" * 58,
+        "STEP 1/2: Data Creation — real-world PwC hospitality indicators",
+        "=" * 58,
+        run_datacreation(),
+        "",
+        "=" * 58,
+        "STEP 2/2: Python Analysis — synthetic scores + dashboard artifacts",
+        "=" * 58,
+        run_pythonanalysis(),
+    ])
 
 # =========================================================
-# GALLERY LOADERS
+# DATA / TABLE LOADERS
 # =========================================================
 
-def _load_all_figures() -> List[Tuple[str, str]]:
-    """Return list of (filepath, caption) for Gallery."""
-    items = []
-    for p in sorted(PY_FIG_DIR.glob("*.png")):
-        items.append((str(p), p.stem.replace('_', ' ').title()))
-    return items
-
-
-def _load_table_safe(path: Path) -> pd.DataFrame:
+def load_table_safe(path: Path) -> pd.DataFrame:
     try:
-        if path.suffix == ".json":
+        if path.suffix.lower() == ".json":
             obj = _read_json(path)
-            if isinstance(obj, dict):
-                return pd.DataFrame([obj])
-            return pd.DataFrame(obj)
+            return pd.DataFrame([obj]) if isinstance(obj, dict) else pd.DataFrame(obj)
         return _read_csv(path)
     except Exception as e:
         return pd.DataFrame([{"error": str(e)}])
 
-
 def refresh_gallery():
-    """Called when user clicks Refresh on Gallery tab."""
-    figures = _load_all_figures()
+    figures = [(str(p), p.stem.replace("_", " ").title()) for p in sorted(PY_FIG_DIR.glob("*.png"))]
     idx = artifacts_index()
-
     table_choices = list(idx["python"]["tables"])
 
+    # Always include core datasets in table dropdown
+    for core in [CLEANED_CSV, ENRICHED_CSV]:
+        if (BASE_DIR / core).exists() and core not in table_choices:
+            table_choices.insert(0, core)
+
     default_df = pd.DataFrame()
     if table_choices:
-        default_df = _load_table_safe(PY_TAB_DIR / table_choices[0])
-
-    return (
-        figures if figures else [],
-        gr.update(choices=table_choices, value=table_choices[0] if table_choices else None),
-        default_df,
-    )
+        chosen = table_choices[0]
+        path = BASE_DIR / chosen if (BASE_DIR / chosen).exists() else PY_TAB_DIR / chosen
+        default_df = load_table_safe(path)
 
+    return figures, gr.update(choices=table_choices, value=table_choices[0] if table_choices else None), default_df
 
 def on_table_select(choice: str):
     if not choice:
         return pd.DataFrame([{"hint": "Select a table above."}])
-    path = PY_TAB_DIR / choice
+    path = BASE_DIR / choice if (BASE_DIR / choice).exists() else PY_TAB_DIR / choice
     if not path.exists():
         return pd.DataFrame([{"error": f"File not found: {choice}"}])
-    return _load_table_safe(path)
-
+    return load_table_safe(path)
 
 # =========================================================
-# KPI LOADER
+# KPIs
 # =========================================================
 
 def load_kpis() -> Dict[str, Any]:
-    for candidate in [PY_TAB_DIR / "kpis.json", PY_FIG_DIR / "kpis.json"]:
-        if candidate.exists():
-            try:
-                return _read_json(candidate)
-            except Exception:
-                pass
-    return {}
+    df = read_market_data(prefer_enriched=True)
+    if df.empty:
+        return {}
+    syn = df[df["section"].eq("synthetic_features")]
+    risk = syn[syn["metric_name"].eq("risk_score")]
+    investment = syn[syn["metric_name"].eq("investment_potential_score")]
+    attractiveness = syn[syn["metric_name"].eq("market_attractiveness_score")]
+
+    return {
+        "locations": int(df["location"].nunique()),
+        "metrics": int(df["metric_name"].nunique()),
+        "real_rows": int((df["section"] != "synthetic_features").sum()),
+        "synthetic_rows": int((df["section"] == "synthetic_features").sum()),
+        "avg_risk_score": round(float(risk["value"].mean()), 1) if not risk.empty else None,
+        "avg_investment_potential": round(float(investment["value"].mean()), 1) if not investment.empty else None,
+        "avg_market_attractiveness": round(float(attractiveness["value"].mean()), 1) if not attractiveness.empty else None,
+    }
+
+def render_kpi_cards() -> str:
+    kpis = load_kpis()
+    if not kpis:
+        return """
+        <div style='background:rgba(255,255,255,.72);border-radius:20px;padding:28px;text-align:center;border:1px solid #ddd;'>
+          <div style='font-size:34px;'>🏨</div>
+          <b>No hospitality data found yet</b><br>
+          <span>Run the pipeline or place the CSV files in the app folder.</span>
+        </div>"""
+
+    cards = [
+        ("📍", "Locations", kpis.get("locations"), "#a48de8"),
+        ("📊", "Metrics", kpis.get("metrics"), "#7aa6f8"),
+        ("🧪", "Synthetic Rows", kpis.get("synthetic_rows"), "#6ee7c7"),
+        ("⚠️", "Avg Risk Score", kpis.get("avg_risk_score"), "#e8537a"),
+        ("💼", "Avg Investment Potential", kpis.get("avg_investment_potential"), "#2ec4a0"),
+        ("⭐", "Avg Market Attractiveness", kpis.get("avg_market_attractiveness"), "#e8a230"),
+    ]
+
+    html = "<div style='display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:12px;margin-bottom:24px;'>"
+    for icon, label, value, colour in cards:
+        value = "—" if value is None else value
+        html += f"""
+        <div style='background:rgba(255,255,255,.78);border-radius:20px;padding:18px;text-align:center;
+                    border:1px solid rgba(124,92,191,.18);box-shadow:0 4px 16px rgba(124,92,191,.08);
+                    border-top:3px solid {colour};'>
+          <div style='font-size:26px;margin-bottom:7px;'>{icon}</div>
+          <div style='color:#8b78c6;font-size:10px;text-transform:uppercase;letter-spacing:1.4px;font-weight:800;'>{label}</div>
+          <div style='color:#2d1f4e;font-size:18px;font-weight:800;margin-top:6px;'>{value}</div>
+        </div>"""
+    html += "</div>"
+    return html
+
+# =========================================================
+# INTERACTIVE CHARTS
+# =========================================================
+
+def styled_layout(**kwargs) -> dict:
+    defaults = dict(
+        template="plotly_white",
+        paper_bgcolor="rgba(255,255,255,0.96)",
+        plot_bgcolor="rgba(255,255,255,0.98)",
+        font=dict(family="system-ui, sans-serif", color="#2d1f4e", size=12),
+        margin=dict(l=60, r=20, t=70, b=70),
+        title=dict(font=dict(size=16, color="#4b2d8a")),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1),
+    )
+    defaults.update(kwargs)
+    return defaults
 
+def empty_chart(title: str) -> go.Figure:
+    fig = go.Figure()
+    fig.update_layout(
+        title=title,
+        height=420,
+        template="plotly_white",
+        annotations=[dict(text="No data available yet", x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False)],
+    )
+    return fig
+
+def build_city_performance_chart() -> go.Figure:
+    df = read_market_data(True)
+    wide = pivot_metrics(df, section="city_performance", entity="city")
+    needed = [c for c in ["occupancy_yoy", "adr_yoy", "revpar_yoy"] if c in wide.columns]
+    if wide.empty or not needed:
+        return empty_chart("City Performance — Occupancy, ADR, RevPAR")
+    fig = go.Figure()
+    for i, col in enumerate(needed):
+        fig.add_trace(go.Bar(x=wide["location"], y=wide[col], name=col.replace("_", " ").upper(), marker_color=CHART_PALETTE[i]))
+    fig.update_layout(**styled_layout(title=dict(text="City Performance YoY — Occupancy, ADR, RevPAR"), barmode="group", height=430))
+    fig.update_yaxes(title="YoY change (%)")
+    return fig
+
+def build_region_demand_chart() -> go.Figure:
+    df = read_market_data(True)
+    wide = pivot_metrics(df, section="regional_demand", entity="region")
+    needed = [c for c in ["domestic_demand_growth", "international_demand_growth"] if c in wide.columns]
+    if wide.empty or not needed:
+        return empty_chart("Regional Demand Growth")
+    fig = go.Figure()
+    for i, col in enumerate(needed):
+        fig.add_trace(go.Bar(y=wide["location"], x=wide[col], orientation="h", name=col.replace("_", " ").title(), marker_color=CHART_PALETTE[i]))
+    fig.update_layout(**styled_layout(title=dict(text="Regional Demand Growth — Domestic vs International"), barmode="group", height=max(420, len(wide)*42)))
+    fig.update_xaxes(title="Growth (%)")
+    fig.update_yaxes(autorange="reversed")
+    return fig
+
+def build_synthetic_scores_chart() -> go.Figure:
+    df = read_market_data(True)
+    wide = pivot_metrics(df, section="synthetic_features")
+    score_cols = [c for c in ["growth_score", "market_attractiveness_score", "investment_potential_score", "risk_score"] if c in wide.columns]
+    if wide.empty or not score_cols:
+        return empty_chart("Synthetic Scores")
+    fig = go.Figure()
+    for i, col in enumerate(score_cols):
+        fig.add_trace(go.Bar(x=wide["location"], y=wide[col], name=col.replace("_", " ").title(), marker_color=CHART_PALETTE[i % len(CHART_PALETTE)]))
+    fig.update_layout(**styled_layout(title=dict(text="Synthetic Market Scores by Location"), barmode="group", height=470))
+    fig.update_yaxes(title="Score (0–100)", range=[0, 105])
+    return fig
+
+def build_risk_chart() -> go.Figure:
+    df = read_market_data(True)
+    wide = pivot_metrics(df, section="synthetic_features")
+    if wide.empty or "risk_score" not in wide.columns:
+        return empty_chart("Risk Score")
+    wide = wide.sort_values("risk_score", ascending=True)
+    fig = go.Figure(go.Bar(
+        y=wide["location"],
+        x=wide["risk_score"],
+        orientation="h",
+        text=[f"{v:.1f}" for v in wide["risk_score"]],
+        marker=dict(color=wide["risk_score"], colorscale=[[0, "#2ec4a0"], [0.5, "#e8a230"], [1, "#e8537a"]]),
+    ))
+    fig.update_layout(**styled_layout(title=dict(text="Risk Score by Location"), showlegend=False, height=max(420, len(wide)*35)))
+    fig.update_xaxes(title="Risk score (0–100)", range=[0, 105])
+    return fig
+
+def build_investment_chart() -> go.Figure:
+    df = read_market_data(True)
+    wide = pivot_metrics(df, section="synthetic_features")
+    if wide.empty or "investment_potential_score" not in wide.columns:
+        return empty_chart("Investment Potential")
+    wide = wide.sort_values("investment_potential_score", ascending=True)
+    fig = go.Figure(go.Bar(
+        y=wide["location"],
+        x=wide["investment_potential_score"],
+        orientation="h",
+        text=[f"{v:.1f}" for v in wide["investment_potential_score"]],
+        marker=dict(color=wide["investment_potential_score"], colorscale=[[0, "#c5b4f0"], [1, "#7c5cbf"]]),
+    ))
+    fig.update_layout(**styled_layout(title=dict(text="Investment Potential Score by Location"), showlegend=False, height=max(420, len(wide)*35)))
+    fig.update_xaxes(title="Investment potential score (0–100)", range=[0, 105])
+    return fig
+
+def build_opportunity_table() -> pd.DataFrame:
+    df = read_market_data(True)
+    wide = pivot_metrics(df, section="synthetic_features")
+    if wide.empty:
+        return pd.DataFrame([{"hint": "No synthetic features found yet."}])
+    keep = [c for c in ["location", "entity", "growth_score", "market_attractiveness_score", "investment_potential_score", "risk_score", "risk_level", "opportunity_category"] if c in wide.columns]
+    out = wide[keep].copy()
+    for col in ["growth_score", "market_attractiveness_score", "investment_potential_score", "risk_score"]:
+        if col in out:
+            out[col] = out[col].round(1)
+    return out.sort_values(["entity", "investment_potential_score"], ascending=[True, False], na_position="last") if "investment_potential_score" in out else out
+
+def refresh_dashboard():
+    figs, dd, df = refresh_gallery()
+    return (
+        render_kpi_cards(),
+        build_city_performance_chart(),
+        build_region_demand_chart(),
+        build_synthetic_scores_chart(),
+        build_risk_chart(),
+        build_investment_chart(),
+        build_opportunity_table(),
+        figs,
+        dd,
+        df,
+    )
 
 # =========================================================
-# AI DASHBOARD -- LLM picks what to display
+# AI DASHBOARD — N8N / HUGGING FACE / KEYWORD FALLBACK
 # =========================================================
 
-DASHBOARD_SYSTEM = """You are an AI dashboard assistant for a book-sales analytics app.
-The user asks questions or requests about their data. You have access to pre-computed
-artifacts from a Python analysis pipeline.
+DASHBOARD_SYSTEM = """You are the AI assistant for an Italy Hospitality Market Insight Assistant.
+The app uses a real-world PwC Italy Hospitality Market Snapshot dataset and an enriched synthetic dataset.
+The dataset has long-format columns: section, location, entity, metric_name, value, unit, period, source_page, note.
 
-AVAILABLE ARTIFACTS (only reference ones that exist):
+Available artifacts:
 {artifacts_json}
 
-KPI SUMMARY: {kpis_json}
-
-YOUR JOB:
-1. Answer the user's question conversationally using the KPIs and your knowledge of the artifacts.
-2. At the END of your response, output a JSON block (fenced with ```json ... ```) that tells
-   the dashboard which artifact to display. The JSON must have this shape:
-   {{"show": "figure"|"table"|"none", "scope": "python", "filename": "..."}}
-
-   - Use "show": "figure" to display a chart image.
-   - Use "show": "table" to display a CSV/JSON table.
-   - Use "show": "none" if no artifact is relevant.
-
-RULES:
-- If the user asks about sales trends or forecasting by title, show sales_trends or arima figures.
-- If the user asks about sentiment, show sentiment figure or sentiment_counts table.
-- If the user asks about forecast accuracy or ARIMA, show arima figures.
-- If the user asks about top sellers, show top_titles_by_units_sold.csv.
-- If the user asks a general data question, pick the most relevant artifact.
-- Keep your answer concise (2-4 sentences), then the JSON block.
+KPI summary:
+{kpis_json}
+
+Key concepts:
+- city performance: occupancy_yoy, adr_yoy, revpar_yoy for Milan, Rome, Florence, Venice.
+- regional demand: domestic_demand_growth and international_demand_growth.
+- synthetic features: growth_score, market_attractiveness_score, investment_potential_score, risk_score, risk_level, opportunity_category.
+
+Answer briefly and practically. At the END, output a JSON block exactly like:
+```json
+{{"show": "chart"|"table"|"none", "chart": "city|region|scores|risk|investment|none", "table": "opportunities|raw|none"}}
+```
+Choose:
+- city for occupancy / ADR / RevPAR / city performance questions.
+- region for domestic/international regional demand questions.
+- scores for comparing synthetic scores.
+- risk for risk score or risk level.
+- investment for investment potential / attractiveness / opportunity.
+- opportunities table for opportunity categories or strategic recommendations.
 """
 
 JSON_BLOCK_RE = re.compile(r"```json\s*(\{.*?\})\s*```", re.DOTALL)
 FALLBACK_JSON_RE = re.compile(r"\{[^{}]*\"show\"[^{}]*\}", re.DOTALL)
 
+def parse_display_directive(text: str) -> Dict[str, str]:
+    for regex in [JSON_BLOCK_RE, FALLBACK_JSON_RE]:
+        m = regex.search(text)
+        if m:
+            try:
+                return json.loads(m.group(1) if regex is JSON_BLOCK_RE else m.group(0))
+            except Exception:
+                continue
+    return {"show": "none", "chart": "none", "table": "none"}
 
-def _parse_display_directive(text: str) -> Dict[str, str]:
-    m = JSON_BLOCK_RE.search(text)
-    if m:
-        try:
-            return json.loads(m.group(1))
-        except json.JSONDecodeError:
-            pass
-    m = FALLBACK_JSON_RE.search(text)
-    if m:
-        try:
-            return json.loads(m.group(0))
-        except json.JSONDecodeError:
-            pass
-    return {"show": "none"}
-
-
-def _clean_response(text: str) -> str:
-    """Strip the JSON directive block from the displayed response."""
+def clean_response(text: str) -> str:
     return JSON_BLOCK_RE.sub("", text).strip()
 
-
-def _n8n_call(msg: str) -> Tuple[str, Dict]:
-    """Call the student's n8n webhook and return (reply, directive)."""
-    import requests as req
+def n8n_call(msg: str) -> Tuple[str, Optional[Dict[str, str]]]:
+    import requests
     try:
-        resp = req.post(N8N_WEBHOOK_URL, json={"question": msg}, timeout=20)
+        resp = requests.post(N8N_WEBHOOK_URL, json={"question": msg, "project": "italy_hospitality_market"}, timeout=25)
+        resp.raise_for_status()
         data = resp.json()
-        answer = data.get("answer", "No response from n8n workflow.")
+        answer = data.get("answer") or data.get("reply") or "No answer returned by n8n."
         chart = data.get("chart", "none")
-        if chart and chart != "none":
-            return answer, {"show": "figure", "chart": chart}
-        return answer, {"show": "none"}
+        table = data.get("table", "none")
+        return answer, {"show": "chart" if chart != "none" else ("table" if table != "none" else "none"), "chart": chart, "table": table}
     except Exception as e:
-        return f"n8n error: {e}. Falling back to keyword matching.", None
+        return f"n8n error: {e}. Falling back to local logic.", None
+
+def keyword_fallback(msg: str, kpis: Dict[str, Any]) -> Tuple[str, Dict[str, str]]:
+    m = msg.lower()
+    kpi_text = ""
+    if kpis:
+        kpi_text = f"The dataset covers {kpis.get('locations', '?')} locations and {kpis.get('metrics', '?')} metrics."
+
+    if any(w in m for w in ["occupancy", "adr", "revpar", "city", "milan", "rome", "florence", "venice"]):
+        return f"Here is the city performance view for occupancy, ADR, and RevPAR. {kpi_text}", {"show": "chart", "chart": "city", "table": "none"}
+    if any(w in m for w in ["region", "regional", "domestic", "international", "demand", "lazio", "puglia", "sicilia"]):
+        return f"Here is the regional demand comparison between domestic and international growth. {kpi_text}", {"show": "chart", "chart": "region", "table": "none"}
+    if any(w in m for w in ["risk", "risky", "safe", "low risk", "high risk"]):
+        return f"Here is the risk score view. Lower scores indicate safer or more stable opportunities. {kpi_text}", {"show": "chart", "chart": "risk", "table": "opportunities"}
+    if any(w in m for w in ["investment", "potential", "attractive", "attractiveness", "opportunity", "recommend"]):
+        return f"Here is the investment potential view, supported by the opportunity-category table. {kpi_text}", {"show": "chart", "chart": "investment", "table": "opportunities"}
+    if any(w in m for w in ["score", "scores", "growth", "synthetic", "compare"]):
+        return f"Here is the synthetic score comparison across locations. {kpi_text}", {"show": "chart", "chart": "scores", "table": "opportunities"}
+    if any(w in m for w in ["table", "data", "raw", "dataset"]):
+        return f"Here is the enriched hospitality dataset table preview. {kpi_text}", {"show": "table", "chart": "none", "table": "raw"}
+
+    return (
+        f"You can ask about city performance, regional demand, risk, investment potential, synthetic scores, or opportunity categories. {kpi_text}",
+        {"show": "none", "chart": "none", "table": "none"},
+    )
 
+def resolve_chart(name: str):
+    return {
+        "city": build_city_performance_chart,
+        "region": build_region_demand_chart,
+        "scores": build_synthetic_scores_chart,
+        "risk": build_risk_chart,
+        "investment": build_investment_chart,
+    }.get(name, lambda: None)()
+
+def resolve_table(name: str):
+    if name == "opportunities":
+        return build_opportunity_table()
+    if name == "raw":
+        return read_market_data(True).head(MAX_PREVIEW_ROWS)
+    return None
 
 def ai_chat(user_msg: str, history: list):
-    """Chat function for the AI Dashboard tab."""
     if not user_msg or not user_msg.strip():
         return history, "", None, None
 
     idx = artifacts_index()
     kpis = load_kpis()
 
-    # Priority: n8n webhook > HF LLM > keyword fallback
     if N8N_WEBHOOK_URL:
-        reply, directive = _n8n_call(user_msg)
+        reply, directive = n8n_call(user_msg)
         if directive is None:
-            reply_fb, directive = _keyword_fallback(user_msg, idx, kpis)
-            reply += "\n\n" + reply_fb
-    elif not LLM_ENABLED:
-        reply, directive = _keyword_fallback(user_msg, idx, kpis)
-    else:
+            reply_fb, directive = keyword_fallback(user_msg, kpis)
+            reply = reply + "\n\n" + reply_fb
+    elif LLM_ENABLED:
         system = DASHBOARD_SYSTEM.format(
             artifacts_json=json.dumps(idx, indent=2),
-            kpis_json=json.dumps(kpis, indent=2) if kpis else "(no KPIs yet, run the pipeline first)",
+            kpis_json=json.dumps(kpis, indent=2) if kpis else "No KPIs available yet.",
         )
         msgs = [{"role": "system", "content": system}]
         for entry in (history or [])[-6:]:
             msgs.append(entry)
         msgs.append({"role": "user", "content": user_msg})
-
         try:
             r = llm_client.chat_completion(
                 model=MODEL_NAME,
                 messages=msgs,
-                temperature=0.3,
-                max_tokens=600,
+                temperature=0.25,
+                max_tokens=650,
                 stream=False,
             )
-            raw = (
-                r["choices"][0]["message"]["content"]
-                if isinstance(r, dict)
-                else r.choices[0].message.content
-            )
-            directive = _parse_display_directive(raw)
-            reply = _clean_response(raw)
+            raw = r["choices"][0]["message"]["content"] if isinstance(r, dict) else r.choices[0].message.content
+            directive = parse_display_directive(raw)
+            reply = clean_response(raw)
         except Exception as e:
-            reply = f"LLM error: {e}. Falling back to keyword matching."
-            reply_fb, directive = _keyword_fallback(user_msg, idx, kpis)
-            reply += "\n\n" + reply_fb
-
-    # Resolve artifacts — build interactive Plotly charts when possible
-    chart_out = None
-    tab_out = None
-    show = directive.get("show", "none")
-    fname = directive.get("filename", "")
-    chart_name = directive.get("chart", "")
-
-    # Interactive chart builders keyed by name
-    chart_builders = {
-        "sales": build_sales_chart,
-        "sentiment": build_sentiment_chart,
-        "top_sellers": build_top_sellers_chart,
-    }
+            reply_fb, directive = keyword_fallback(user_msg, kpis)
+            reply = f"Hugging Face error: {e}. Falling back to local logic.\n\n{reply_fb}"
+    else:
+        reply, directive = keyword_fallback(user_msg, kpis)
 
-    if chart_name and chart_name in chart_builders:
-        chart_out = chart_builders[chart_name]()
-    elif show == "figure" and fname:
-        # Fallback: try to match filename to a chart builder
-        if "sales_trend" in fname:
-            chart_out = build_sales_chart()
-        elif "sentiment" in fname:
-            chart_out = build_sentiment_chart()
-        elif "arima" in fname or "forecast" in fname:
-            chart_out = build_sales_chart()  # closest interactive equivalent
-        else:
-            chart_out = _empty_chart(f"No interactive chart for {fname}")
-
-    if show == "table" and fname:
-        fp = PY_TAB_DIR / fname
-        if fp.exists():
-            tab_out = _load_table_safe(fp)
-        else:
-            reply += f"\n\n*(Could not find table: {fname})*"
+    chart_out = resolve_chart(directive.get("chart", "none")) if directive.get("show") in ["chart", "figure"] or directive.get("chart") != "none" else None
+    table_out = resolve_table(directive.get("table", "none")) if directive.get("table") != "none" else None
 
     new_history = (history or []) + [
         {"role": "user", "content": user_msg},
         {"role": "assistant", "content": reply},
     ]
-
-    return new_history, "", chart_out, tab_out
-
-
-def _keyword_fallback(msg: str, idx: Dict, kpis: Dict) -> Tuple[str, Dict]:
-    """Simple keyword matcher when LLM is unavailable."""
-    msg_lower = msg.lower()
-
-    if not idx["python"]["figures"] and not idx["python"]["tables"]:
-        return (
-            "No artifacts found yet. Please run the pipeline first (Tab 1), "
-            "then come back here to explore the results.",
-            {"show": "none"},
-        )
-
-    kpi_text = ""
-    if kpis:
-        total = kpis.get("total_units_sold", 0)
-        kpi_text = (
-            f"Quick summary: **{kpis.get('n_titles', '?')}** book titles across "
-            f"**{kpis.get('n_months', '?')}** months, with **{total:,.0f}** total units sold."
-        )
-
-    if any(w in msg_lower for w in ["trend", "sales trend", "monthly sale"]):
-        return (
-            f"Here are the sales trends. {kpi_text}",
-            {"show": "figure", "chart": "sales"},
-        )
-
-    if any(w in msg_lower for w in ["sentiment", "review", "positive", "negative"]):
-        return (
-            f"Here is the sentiment distribution across sampled book titles. {kpi_text}",
-            {"show": "figure", "chart": "sentiment"},
-        )
-
-    if any(w in msg_lower for w in ["arima", "forecast", "predict"]):
-        return (
-            f"Here are the sales trends and forecasts. {kpi_text}",
-            {"show": "figure", "chart": "sales"},
-        )
-
-    if any(w in msg_lower for w in ["top", "best sell", "popular", "rank"]):
-        return (
-            f"Here are the top-selling titles by units sold. {kpi_text}",
-            {"show": "table", "scope": "python", "filename": "top_titles_by_units_sold.csv"},
-        )
-
-    if any(w in msg_lower for w in ["price", "pricing", "decision"]):
-        return (
-            f"Here are the pricing decisions. {kpi_text}",
-            {"show": "table", "scope": "python", "filename": "pricing_decisions.csv"},
-        )
-
-    if any(w in msg_lower for w in ["dashboard", "overview", "summary", "kpi"]):
-        return (
-            f"Dashboard overview: {kpi_text}\n\nAsk me about sales trends, sentiment, forecasts, "
-            "pricing, or top sellers to see specific visualizations.",
-            {"show": "table", "scope": "python", "filename": "df_dashboard.csv"},
-        )
-
-    # Default
-    return (
-        f"I can show you various analyses. {kpi_text}\n\n"
-        "Try asking about: **sales trends**, **sentiment**, **ARIMA forecasts**, "
-        "**pricing decisions**, **top sellers**, or **dashboard overview**.",
-        {"show": "none"},
-    )
-
-
-# =========================================================
-# KPI CARDS (BubbleBusters style)
-# =========================================================
-
-def render_kpi_cards() -> str:
-    kpis = load_kpis()
-    if not kpis:
-        return (
-            '<div style="background:rgba(255,255,255,.65);backdrop-filter:blur(16px);'
-            'border-radius:20px;padding:28px;text-align:center;'
-            'border:1.5px solid rgba(255,255,255,.7);'
-            'box-shadow:0 8px 32px rgba(124,92,191,.08);">'
-            '<div style="font-size:36px;margin-bottom:10px;">📊</div>'
-            '<div style="color:#a48de8;font-size:14px;'
-            'font-weight:800;margin-bottom:6px;">No data yet</div>'
-            '<div style="color:#9d8fc4;font-size:12px;">'
-            'Run the pipeline to populate these cards.</div>'
-            '</div>'
-        )
-
-    def card(icon, label, value, colour):
-        return f"""
-        <div style="background:rgba(255,255,255,.72);backdrop-filter:blur(16px);
-                    border-radius:20px;padding:18px 14px 16px;text-align:center;
-                    border:1.5px solid rgba(255,255,255,.8);
-                    box-shadow:0 4px 16px rgba(124,92,191,.08);
-                    border-top:3px solid {colour};">
-            <div style="font-size:26px;margin-bottom:7px;line-height:1;">{icon}</div>
-            <div style="color:#9d8fc4;font-size:9.5px;text-transform:uppercase;
-                        letter-spacing:1.8px;margin-bottom:7px;font-weight:800;">{label}</div>
-            <div style="color:#2d1f4e;font-size:16px;font-weight:800;">{value}</div>
-        </div>"""
-
-    kpi_config = [
-        ("n_titles",         "📚", "Book Titles",  "#a48de8"),
-        ("n_months",         "📅", "Time Periods", "#7aa6f8"),
-        ("total_units_sold", "📦", "Units Sold",   "#6ee7c7"),
-        ("total_revenue",    "💰", "Revenue",      "#3dcba8"),
-    ]
-
-    html = (
-        '<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(140px,1fr));'
-        'gap:12px;margin-bottom:24px;">'
-    )
-    for key, icon, label, colour in kpi_config:
-        val = kpis.get(key)
-        if val is None:
-            continue
-        if isinstance(val, (int, float)) and val > 100:
-            val = f"{val:,.0f}"
-        html += card(icon, label, str(val), colour)
-    # Extra KPIs not in config
-    known = {k for k, *_ in kpi_config}
-    for key, val in kpis.items():
-        if key not in known:
-            label = key.replace("_", " ").title()
-            if isinstance(val, (int, float)) and val > 100:
-                val = f"{val:,.0f}"
-            html += card("📈", label, str(val), "#8fa8f8")
-    html += "</div>"
-    return html
-
-
-# =========================================================
-# INTERACTIVE PLOTLY CHARTS (BubbleBusters style)
-# =========================================================
-
-CHART_PALETTE = ["#7c5cbf", "#2ec4a0", "#e8537a", "#e8a230", "#5e8fef",
-                 "#c45ea8", "#3dbacc", "#a0522d", "#6aaa3a", "#d46060"]
-
-def _styled_layout(**kwargs) -> dict:
-    defaults = dict(
-        template="plotly_white",
-        paper_bgcolor="rgba(255,255,255,0.95)",
-        plot_bgcolor="rgba(255,255,255,0.98)",
-        font=dict(family="system-ui, sans-serif", color="#2d1f4e", size=12),
-        margin=dict(l=60, r=20, t=70, b=70),
-        legend=dict(
-            orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1,
-            bgcolor="rgba(255,255,255,0.92)",
-            bordercolor="rgba(124,92,191,0.35)", borderwidth=1,
-        ),
-        title=dict(font=dict(size=15, color="#4b2d8a")),
-    )
-    defaults.update(kwargs)
-    return defaults
-
-
-def _empty_chart(title: str) -> go.Figure:
-    fig = go.Figure()
-    fig.update_layout(
-        title=title, height=420, template="plotly_white",
-        paper_bgcolor="rgba(255,255,255,0.95)",
-        annotations=[dict(text="Run the pipeline to generate data",
-            x=0.5, y=0.5, xref="paper", yref="paper", showarrow=False,
-            font=dict(size=14, color="rgba(124,92,191,0.5)"))],
-    )
-    return fig
-
-
-def build_sales_chart() -> go.Figure:
-    path = PY_TAB_DIR / "df_dashboard.csv"
-    if not path.exists():
-        return _empty_chart("Sales Trends — run the pipeline first")
-    df = pd.read_csv(path)
-    date_col = next((c for c in df.columns if "month" in c.lower() or "date" in c.lower()), None)
-    val_cols = [c for c in df.columns if c != date_col and df[c].dtype in ("float64", "int64")]
-    if not date_col or not val_cols:
-        return _empty_chart("Could not auto-detect columns in df_dashboard.csv")
-    df[date_col] = pd.to_datetime(df[date_col], errors="coerce")
-    fig = go.Figure()
-    for i, col in enumerate(val_cols):
-        fig.add_trace(go.Scatter(
-            x=df[date_col], y=df[col], name=col.replace("_", " ").title(),
-            mode="lines+markers", line=dict(color=CHART_PALETTE[i % len(CHART_PALETTE)], width=2),
-            marker=dict(size=4),
-            hovertemplate=f"<b>{col.replace('_',' ').title()}</b><br>%{{x|%b %Y}}: %{{y:,.0f}}<extra></extra>",
-        ))
-    fig.update_layout(**_styled_layout(height=450, hovermode="x unified",
-                                        title=dict(text="Monthly Overview")))
-    fig.update_xaxes(gridcolor="rgba(124,92,191,0.15)", showgrid=True)
-    fig.update_yaxes(gridcolor="rgba(124,92,191,0.15)", showgrid=True)
-    return fig
-
-
-def build_sentiment_chart() -> go.Figure:
-    path = PY_TAB_DIR / "sentiment_counts_sampled.csv"
-    if not path.exists():
-        return _empty_chart("Sentiment Distribution — run the pipeline first")
-    df = pd.read_csv(path)
-    title_col = df.columns[0]
-    sent_cols = [c for c in ["negative", "neutral", "positive"] if c in df.columns]
-    if not sent_cols:
-        return _empty_chart("No sentiment columns found in CSV")
-    colors = {"negative": "#e8537a", "neutral": "#5e8fef", "positive": "#2ec4a0"}
-    fig = go.Figure()
-    for col in sent_cols:
-        fig.add_trace(go.Bar(
-            name=col.title(), y=df[title_col], x=df[col],
-            orientation="h", marker_color=colors.get(col, "#888"),
-            hovertemplate=f"<b>{col.title()}</b>: %{{x}}<extra></extra>",
-        ))
-    fig.update_layout(**_styled_layout(
-        height=max(400, len(df) * 28), barmode="stack",
-        title=dict(text="Sentiment Distribution by Book"),
-    ))
-    fig.update_xaxes(title="Number of Reviews")
-    fig.update_yaxes(autorange="reversed")
-    return fig
-
-
-def build_top_sellers_chart() -> go.Figure:
-    path = PY_TAB_DIR / "top_titles_by_units_sold.csv"
-    if not path.exists():
-        return _empty_chart("Top Sellers — run the pipeline first")
-    df = pd.read_csv(path).head(15)
-    title_col = next((c for c in df.columns if "title" in c.lower()), df.columns[0])
-    val_col = next((c for c in df.columns if "unit" in c.lower() or "sold" in c.lower()), df.columns[-1])
-    fig = go.Figure(go.Bar(
-        y=df[title_col], x=df[val_col], orientation="h",
-        marker=dict(color=df[val_col], colorscale=[[0, "#c5b4f0"], [1, "#7c5cbf"]]),
-        hovertemplate="<b>%{y}</b><br>Units: %{x:,.0f}<extra></extra>",
-    ))
-    fig.update_layout(**_styled_layout(
-        height=max(400, len(df) * 30),
-        title=dict(text="Top Selling Titles"), showlegend=False,
-    ))
-    fig.update_yaxes(autorange="reversed")
-    fig.update_xaxes(title="Total Units Sold")
-    return fig
-
-
-def refresh_dashboard():
-    return render_kpi_cards(), build_sales_chart(), build_sentiment_chart(), build_top_sellers_chart()
-
+    return new_history, "", chart_out, table_out
 
 # =========================================================
 # UI
@@ -617,142 +557,82 @@ def load_css() -> str:
     css_path = BASE_DIR / "style.css"
     return css_path.read_text(encoding="utf-8") if css_path.exists() else ""
 
-
-with gr.Blocks(title="AIBDM 2026 Workshop App") as demo:
-
+with gr.Blocks(title="Italy Hospitality Market Insight Assistant") as demo:
     gr.Markdown(
-        "# SE21 App Template\n"
-        "*This is an app template for SE21 students*",
+        "# Italy Hospitality Market Insight Assistant\n"
+        "*A Gradio app for PwC-based hospitality indicators, synthetic market scores, n8n automation and Hugging Face AI Q&A.*",
         elem_id="escp_title",
     )
 
-    # ===========================================================
-    # TAB 1 -- Pipeline Runner
-    # ===========================================================
     with gr.Tab("Pipeline Runner"):
-        gr.Markdown()
-
+        gr.Markdown("Run the project notebooks. Step 1 creates/cleans the dataset; Step 2 creates analysis outputs and synthetic insights.")
         with gr.Row():
-            with gr.Column(scale=1):
-                btn_nb1 = gr.Button("Step 1: Data Creation", variant="secondary")
-            with gr.Column(scale=1):
-                btn_nb2 = gr.Button("Step 2: Python Analysis", variant="secondary")
-
-        with gr.Row():
-            btn_all = gr.Button("Run Full Pipeline (Both Steps)", variant="primary")
-
-        run_log = gr.Textbox(
-            label="Execution Log",
-            lines=18,
-            max_lines=30,
-            interactive=False,
-        )
-
+            btn_nb1 = gr.Button("Step 1: Data Creation", variant="secondary")
+            btn_nb2 = gr.Button("Step 2: Python Analysis", variant="secondary")
+        btn_all = gr.Button("Run Full Pipeline", variant="primary")
+        run_log = gr.Textbox(label="Execution Log", lines=18, max_lines=30, interactive=False)
         btn_nb1.click(run_datacreation, outputs=[run_log])
         btn_nb2.click(run_pythonanalysis, outputs=[run_log])
         btn_all.click(run_full_pipeline, outputs=[run_log])
 
-    # ===========================================================
-    # TAB 2 -- Dashboard (KPIs + Interactive Charts + Gallery)
-    # ===========================================================
     with gr.Tab("Dashboard"):
         kpi_html = gr.HTML(value=render_kpi_cards)
-
         refresh_btn = gr.Button("Refresh Dashboard", variant="primary")
 
-        gr.Markdown("#### Interactive Charts")
-        chart_sales = gr.Plot(label="Monthly Overview")
-        chart_sentiment = gr.Plot(label="Sentiment Distribution")
-        chart_top = gr.Plot(label="Top Sellers")
-
-        gr.Markdown("#### Static Figures (from notebooks)")
-        gallery = gr.Gallery(
-            label="Generated Figures",
-            columns=2,
-            height=480,
-            object_fit="contain",
-        )
+        gr.Markdown("#### Interactive Hospitality Charts")
+        with gr.Row():
+            chart_city = gr.Plot(label="City Performance")
+            chart_region = gr.Plot(label="Regional Demand")
+        with gr.Row():
+            chart_scores = gr.Plot(label="Synthetic Scores")
+            chart_risk = gr.Plot(label="Risk Score")
+        chart_investment = gr.Plot(label="Investment Potential")
 
-        gr.Markdown("#### Data Tables")
-        table_dropdown = gr.Dropdown(
-            label="Select a table to view",
-            choices=[],
-            interactive=True,
-        )
-        table_display = gr.Dataframe(
-            label="Table Preview",
-            interactive=False,
-        )
+        gr.Markdown("#### Opportunity Categories")
+        opportunity_table = gr.Dataframe(label="Synthetic Strategy Table", interactive=False)
 
-        def _on_refresh():
-            kpi, c1, c2, c3 = refresh_dashboard()
-            figs, dd, df = refresh_gallery()
-            return kpi, c1, c2, c3, figs, dd, df
+        gr.Markdown("#### Static Figures and Data Tables")
+        gallery = gr.Gallery(label="Generated Figures", columns=2, height=430, object_fit="contain")
+        table_dropdown = gr.Dropdown(label="Select a table to view", choices=[], interactive=True)
+        table_display = gr.Dataframe(label="Table Preview", interactive=False)
 
         refresh_btn.click(
-            _on_refresh,
-            outputs=[kpi_html, chart_sales, chart_sentiment, chart_top,
-                     gallery, table_dropdown, table_display],
-        )
-        table_dropdown.change(
-            on_table_select,
-            inputs=[table_dropdown],
-            outputs=[table_display],
+            refresh_dashboard,
+            outputs=[kpi_html, chart_city, chart_region, chart_scores, chart_risk, chart_investment, opportunity_table, gallery, table_dropdown, table_display],
         )
+        table_dropdown.change(on_table_select, inputs=[table_dropdown], outputs=[table_display])
 
-    # ===========================================================
-    # TAB 3 -- AI Dashboard
-    # ===========================================================
     with gr.Tab('"AI" Dashboard'):
-        _ai_status = (
-            "Connected to your **n8n workflow**." if N8N_WEBHOOK_URL
-            else "**LLM active.**" if LLM_ENABLED
-            else "Using **keyword matching**. Upgrade options: "
-                 "set `N8N_WEBHOOK_URL` to connect your n8n workflow, "
-                 "or set `HF_API_KEY` for direct LLM access."
+        ai_status = (
+            "Connected to your **n8n workflow**." if N8N_WEBHOOK_URL else
+            "**Hugging Face LLM active.**" if LLM_ENABLED else
+            "Using **local keyword matching**. To activate AI, set `HF_API_KEY`; to activate automations, set `N8N_WEBHOOK_URL`."
         )
         gr.Markdown(
-            "### Ask questions, get interactive visualisations\n\n"
-            f"Type a question and the system will pick the right interactive chart or table. {_ai_status}"
+            "### Ask questions about the Italy hospitality market\n\n"
+            f"{ai_status}\n\n"
+            "Examples: *Which city has the strongest RevPAR?*, *Show risk scores*, *Which regions are investment opportunities?*"
         )
-
         with gr.Row(equal_height=True):
             with gr.Column(scale=1):
-                chatbot = gr.Chatbot(
-                    label="Conversation",
-                    height=380,
-                )
-                user_input = gr.Textbox(
-                    label="Ask about your data",
-                    placeholder="e.g. Show me sales trends / What are the top sellers? / Sentiment analysis",
-                    lines=1,
-                )
+                chatbot = gr.Chatbot(label="Conversation", height=400, type="messages")
+                user_input = gr.Textbox(label="Ask about your data", placeholder="e.g. Show me investment potential by location", lines=1)
                 gr.Examples(
                     examples=[
-                        "Show me the sales trends",
-                        "What does the sentiment look like?",
-                        "Which titles sell the most?",
-                        "Show the ARIMA forecasts",
-                        "What are the pricing decisions?",
-                        "Give me a dashboard overview",
+                        "Show me city performance for occupancy, ADR and RevPAR",
+                        "Which locations have the highest risk?",
+                        "Show investment potential by location",
+                        "Compare synthetic scores",
+                        "What is regional domestic vs international demand?",
+                        "Give me strategic recommendations",
                     ],
                     inputs=user_input,
                 )
-
             with gr.Column(scale=1):
-                ai_figure = gr.Plot(
-                    label="Interactive Chart",
-                )
-                ai_table = gr.Dataframe(
-                    label="Data Table",
-                    interactive=False,
-                )
-
-        user_input.submit(
-            ai_chat,
-            inputs=[user_input, chatbot],
-            outputs=[chatbot, user_input, ai_figure, ai_table],
-        )
+                ai_figure = gr.Plot(label="Interactive Chart")
+                ai_table = gr.Dataframe(label="Relevant Table", interactive=False)
 
+        user_input.submit(ai_chat, inputs=[user_input, chatbot], outputs=[chatbot, user_input, ai_figure, ai_table])
 
-demo.launch(css=load_css(), allowed_paths=[str(BASE_DIR)])
+if __name__ == "__main__":
+    demo.launch(css=load_css(), allowed_paths=[str(BASE_DIR)])