Update src/chat.py

src/chat.py

@@ -1,10 +1,510 @@
 # src/chat.py
+import json
+import re
 import time
+import logging
 from datetime import datetime
+
 import pandas as pd
 import streamlit as st
+import dateparser
+import sqlite3
+
+from openai import OpenAI
+
 from src.utils import get_connection
 
+logger = logging.getLogger(__name__)
+if not logger.handlers:
+    logging.basicConfig(level=logging.INFO)
+
+# OpenAI client (expects OPENAI_API_KEY in env)
+_client = OpenAI()
+
+# =========================
+# INTENT TEMPLATES (SQL)
+# =========================
+INTENTS = {
+    # --- Orders ---
+    "order_status": {
+        "required": ["order_id"],
+        "optional": [],
+        "sql": """
+            SELECT o.order_id, o.order_status,
+                   o.order_purchase_timestamp,
+                   o.order_delivered_customer_date,
+                   o.order_estimated_delivery_date
+            FROM olist_orders o
+            WHERE o.order_id = :order_id
+            LIMIT 1;
+        """
+    },
+    "orders_by_city": {
+        "required": ["city"],
+        "optional": ["start_date","end_date"],
+        "sql": """
+            SELECT c.customer_city AS city, COUNT(*) AS orders_count
+            FROM olist_orders o
+            JOIN olist_customers c USING(customer_id)
+            WHERE LOWER(c.customer_city) = LOWER(:city)
+              AND (:start_date IS NULL OR o.order_purchase_timestamp >= :start_date)
+              AND (:end_date   IS NULL OR o.order_purchase_timestamp <  :end_date)
+            GROUP BY c.customer_city;
+        """
+    },
+    "delivery_delay_metrics": {
+        "required": [],
+        "optional": ["start_date","end_date"],
+        "sql": """
+            SELECT ROUND(AVG(JULIANDAY(o.order_delivered_customer_date) -
+                             JULIANDAY(o.order_estimated_delivery_date)), 2) AS avg_delay_days,
+                   ROUND(SUM(CASE WHEN o.order_delivered_customer_date IS NOT NULL
+                                   AND o.order_estimated_delivery_date IS NOT NULL
+                                   AND JULIANDAY(o.order_delivered_customer_date) >
+                                       JULIANDAY(o.order_estimated_delivery_date)
+                             THEN 1 ELSE 0 END)*1.0 /
+                         SUM(CASE WHEN o.order_delivered_customer_date IS NOT NULL
+                                   AND o.order_estimated_delivery_date IS NOT NULL
+                             THEN 1 ELSE 0 END), 3) AS late_ratio
+            FROM olist_orders o
+            WHERE o.order_delivered_customer_date IS NOT NULL
+              AND o.order_estimated_delivery_date IS NOT NULL
+              AND (:start_date IS NULL OR o.order_purchase_timestamp >= :start_date)
+              AND (:end_date   IS NULL OR o.order_purchase_timestamp <  :end_date);
+        """
+    },
+    "late_orders_list": {
+        "required": [],
+        "optional": ["start_date","end_date","limit"],
+        "sql": """
+            SELECT o.order_id, o.order_purchase_timestamp,
+                   o.order_delivered_customer_date, o.order_estimated_delivery_date,
+                   ROUND(JULIANDAY(o.order_delivered_customer_date) -
+                         JULIANDAY(o.order_estimated_delivery_date), 2) AS delay_days
+            FROM olist_orders o
+            WHERE o.order_delivered_customer_date IS NOT NULL
+              AND o.order_estimated_delivery_date IS NOT NULL
+              AND JULIANDAY(o.order_delivered_customer_date) >
+                  JULIANDAY(o.order_estimated_delivery_date)
+              AND (:start_date IS NULL OR o.order_purchase_timestamp >= :start_date)
+              AND (:end_date   IS NULL OR o.order_purchase_timestamp <  :end_date)
+            ORDER BY delay_days DESC
+            LIMIT :limit;
+        """
+    },
+
+    # --- Products ---
+    "top_products_revenue": {
+        "required": [],
+        "optional": ["start_date","end_date","k"],
+        "sql": """
+            SELECT i.product_id,
+                   ROUND(SUM(i.price), 2) AS revenue,
+                   COUNT(*) AS quantity_sold
+            FROM olist_order_items i
+            JOIN olist_orders o  USING(order_id)
+            WHERE (:start_date IS NULL OR o.order_purchase_timestamp >= :start_date)
+              AND (:end_date   IS NULL OR o.order_purchase_timestamp <  :end_date)
+            GROUP BY i.product_id
+            ORDER BY revenue DESC
+            LIMIT :k;
+        """
+    },
+    "top_products_quantity": {
+        "required": [],
+        "optional": ["start_date","end_date","k"],
+        "sql": """
+            SELECT i.product_id,
+                   COUNT(*) AS quantity_sold,
+                   ROUND(SUM(i.price), 2) AS revenue
+            FROM olist_order_items i
+            JOIN olist_orders o  USING(order_id)
+            WHERE (:start_date IS NULL OR o.order_purchase_timestamp >= :start_date)
+              AND (:end_date   IS NULL OR o.order_purchase_timestamp <  :end_date)
+            GROUP BY i.product_id
+            ORDER BY quantity_sold DESC
+            LIMIT :k;
+        """
+    },
+    "category_sales": {
+        "required": [],
+        "optional": ["category","start_date","end_date"],
+        "sql": """
+            SELECT p.product_category_name, p.product_category_name_english,
+                   ROUND(SUM(i.price), 2) AS revenue,
+                   COUNT(*) AS lines
+            FROM olist_order_items i
+            JOIN olist_orders o  USING(order_id)
+            JOIN olist_products p USING(product_id)
+            WHERE (:category IS NULL
+                   OR LOWER(p.product_category_name) = LOWER(:category)
+                   OR LOWER(p.product_category_name_english) = LOWER(:category))
+              AND (:start_date IS NULL OR o.order_purchase_timestamp >= :start_date)
+              AND (:end_date   IS NULL OR o.order_purchase_timestamp <  :end_date)
+            GROUP BY p.product_category_name, p.product_category_name_english
+            ORDER BY revenue DESC;
+        """
+    },
+    "seller_performance": {
+        "required": ["seller_id"],
+        "optional": ["start_date","end_date"],
+        "sql": """
+            SELECT i.seller_id,
+                   ROUND(SUM(i.price),2) AS revenue,
+                   COUNT(*) AS items_sold,
+                   ROUND(AVG(i.freight_value),2) AS avg_freight
+            FROM olist_order_items i
+            JOIN olist_orders o USING(order_id)
+            WHERE i.seller_id = :seller_id
+              AND (:start_date IS NULL OR o.order_purchase_timestamp >= :start_date)
+              AND (:end_date   IS NULL OR o.order_purchase_timestamp <  :end_date)
+            GROUP BY i.seller_id;
+        """
+    },
+
+    # --- Customers & Geo ---
+    "orders_by_state": {
+        "required": [],
+        "optional": ["start_date","end_date","k"],
+        "sql": """
+            SELECT c.customer_state, COUNT(*) AS orders_count
+            FROM olist_orders o
+            JOIN olist_customers c USING(customer_id)
+            WHERE (:start_date IS NULL OR o.order_purchase_timestamp >= :start_date)
+              AND (:end_date   IS NULL OR o.order_purchase_timestamp <  :end_date)
+            GROUP BY c.customer_state
+            ORDER BY orders_count DESC
+            LIMIT :k;
+        """
+    },
+    "repeat_rate": {
+        "required": [],
+        "optional": ["start_date","end_date"],
+        "sql": """
+            WITH cust_orders AS (
+              SELECT c.customer_unique_id AS cuid, COUNT(*) AS n
+              FROM olist_orders o
+              JOIN olist_customers c USING(customer_id)
+              WHERE (:start_date IS NULL OR o.order_purchase_timestamp >= :start_date)
+                AND (:end_date   IS NULL OR o.order_purchase_timestamp <  :end_date)
+              GROUP BY c.customer_unique_id
+            )
+            SELECT ROUND(SUM(CASE WHEN n>=2 THEN 1 ELSE 0 END)*1.0 / COUNT(*), 3) AS repeat_customer_ratio
+            FROM cust_orders;
+        """
+    },
+
+    # --- Payments ---
+    "payments_breakdown": {
+        "required": [],
+        "optional": ["start_date","end_date"],
+        "sql": """
+            SELECT p.payment_type,
+                   COUNT(*) AS payments_count,
+                   ROUND(SUM(p.payment_value),2) AS total_value,
+                   ROUND(AVG(p.payment_installments),2) AS avg_installments
+            FROM olist_order_payments p
+            JOIN olist_orders o USING(order_id)
+            WHERE (:start_date IS NULL OR o.order_purchase_timestamp >= :start_date)
+              AND (:end_date   IS NULL OR o.order_purchase_timestamp <  :end_date)
+            GROUP BY p.payment_type
+            ORDER BY total_value DESC;
+        """
+    },
+
+    # --- AOV Trend ---
+    "aov_trend_monthly": {
+        "required": [],
+        "optional": ["start_date","end_date"],
+        "sql": """
+            WITH order_value AS (
+              SELECT o.order_id,
+                     DATE(o.order_purchase_timestamp, 'start of month') AS month,
+                     SUM(i.price) AS order_value
+              FROM olist_orders o
+              JOIN olist_order_items i USING(order_id)
+              WHERE (:start_date IS NULL OR o.order_purchase_timestamp >= :start_date)
+                AND (:end_date   IS NULL OR o.order_purchase_timestamp <  :end_date)
+              GROUP BY o.order_id, month
+            )
+            SELECT month, ROUND(AVG(order_value), 2) AS avg_order_value
+            FROM order_value
+            GROUP BY month
+            ORDER BY month;
+        """
+    },
+
+    # --- Reviews ---
+    "latest_reviews": {
+        "required": [],
+        "optional": ["product_id","category","limit"],
+        "sql": """
+            SELECT r.order_id, r.review_score, r.review_creation_date, r.review_comment_message
+            FROM olist_order_reviews r
+            WHERE (:product_id IS NULL OR EXISTS (
+                     SELECT 1 FROM olist_order_items i
+                     WHERE i.order_id = r.order_id AND i.product_id = :product_id))
+              AND (:category IS NULL OR EXISTS (
+                     SELECT 1 FROM olist_order_items i
+                     JOIN olist_products p USING(product_id)
+                     WHERE i.order_id = r.order_id
+                       AND (LOWER(p.product_category_name) = LOWER(:category)
+                         OR LOWER(p.product_category_name_english) = LOWER(:category))
+                   ))
+            ORDER BY r.review_creation_date DESC
+            LIMIT :limit;
+        """
+    },
+    "rating_summary": {
+        "required": [],
+        "optional": ["product_id","category","start_date","end_date"],
+        "sql": """
+            SELECT ROUND(AVG(r.review_score),2) AS avg_rating,
+                   COUNT(*) AS n_reviews
+            FROM olist_order_reviews r
+            JOIN olist_orders o ON o.order_id = r.order_id
+            WHERE (:start_date IS NULL OR r.review_creation_date >= :start_date)
+              AND (:end_date   IS NULL OR r.review_creation_date <  :end_date)
+              AND (:product_id IS NULL OR EXISTS (
+                    SELECT 1 FROM olist_order_items i
+                    WHERE i.order_id = r.order_id AND i.product_id = :product_id))
+              AND (:category IS NULL OR EXISTS (
+                    SELECT 1 FROM olist_order_items i
+                    JOIN olist_products p USING(product_id)
+                    WHERE i.order_id = r.order_id
+                      AND (LOWER(p.product_category_name) = LOWER(:category)
+                        OR LOWER(p.product_category_name_english) = LOWER(:category))
+                  ));
+        """
+    },
+}
+
+INTENT_KEYWORDS = {
+    "order_status": ["order", "status", "track", "tracking", "delivered", "delivery", "estimate", "order id"],
+    "orders_by_city": ["city", "town", "municipality"],
+    "delivery_delay_metrics": ["delay", "late", "delivery time", "estimated", "sla"],
+    "late_orders_list": ["late", "delayed", "overdue"],
+    "top_products_revenue": ["top", "revenue", "sales", "gross", "gmv"],
+    "top_products_quantity": ["top", "quantity", "units", "sold", "bestseller"],
+    "category_sales": ["category", "department", "sales by category"],
+    "seller_performance": ["seller", "merchant", "vendor", "performance"],
+    "orders_by_state": ["state", "region", "province"],
+    "repeat_rate": ["repeat", "retention", "returning"],
+    "payments_breakdown": ["payment", "installments", "card", "boleto", "pix", "method"],
+    "aov_trend_monthly": ["aov", "average order value", "trend", "monthly"],
+    "latest_reviews": ["review", "comment", "feedback", "opinion", "rating"],
+    "rating_summary": ["rating", "score", "stars", "nps", "csat"],
+}
+
+def _has_overlap(intent: str, text: str) -> bool:
+    kws = INTENT_KEYWORDS.get(intent, [])
+    if not kws:
+        return True
+    t = text.lower()
+    return any(re.search(r"\b" + re.escape(kw.lower()) + r"\b", t) for kw in kws)
+
+# =========================
+# GPT HELPERS
+# =========================
+def gpt_classify_intent(user_text: str) -> dict:
+    options = list(INTENTS.keys())
+    system = (
+        "You are an intent classifier for an e-commerce analytics chatbot. "
+        "You MUST return strict JSON. If none of the intents clearly applies, return UNMAPPED."
+    )
+    user = (
+        "Available intents (keys): " + ", ".join(options) + "\n"
+        "Task: Choose the single BEST matching intent key OR 'UNMAPPED' if none clearly fits.\n"
+        "Output STRICT JSON with fields: intent (string), confidence (0.0-1.0), reason (short string).\n"
+        "Do NOT guess. If the message is unrelated, return UNMAPPED.\n\n"
+        f"Message: {user_text}"
+    )
+    resp = _client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[{"role":"system","content": system},
+                  {"role":"user","content": user}],
+        temperature=0
+    )
+    txt = resp.choices[0].message.content.strip()
+    try:
+        data = json.loads(txt)
+        raw_intent = str(data.get("intent","")).strip().lower()
+        if raw_intent == "" or raw_intent in ("none","n/a","unknown"):
+            data["intent"] = "UNMAPPED"
+        else:
+            if raw_intent not in [k.lower() for k in INTENTS.keys()] and raw_intent != "unmapped":
+                data["intent"] = "UNMAPPED"
+            else:
+                for k in INTENTS.keys():
+                    if k.lower() == raw_intent:
+                        data["intent"] = k
+                        break
+        try:
+            c = float(data.get("confidence", 0))
+            data["confidence"] = max(0.0, min(1.0, c))
+        except Exception:
+            data["confidence"] = 0.0
+        data["reason"] = str(data.get("reason","")).strip()
+        return data
+    except Exception:
+        return {"intent":"UNMAPPED","confidence":0.0,"reason":"parse_error"}
+
+def gpt_classify_sentiment(user_text: str) -> str:
+    prompt = "Classify sentiment as Positive, Negative, or Neutral.\n\nMessage: " + user_text
+    resp = _client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"role":"system","content":"You are a sentiment classifier."},
+            {"role":"user","content": prompt}
+        ],
+        temperature=0
+    )
+    return resp.choices[0].message.content.strip()
+
+def gpt_extract_params(intent_key: str, user_text: str) -> dict:
+    if intent_key not in INTENTS:
+        return {}
+    cfg = INTENTS[intent_key]
+    param_list = cfg["required"] + cfg["optional"]
+    prompt = (
+        "Extract the following parameters from the user's query and return STRICT JSON only.\n"
+        f"Keys: {param_list}. If a parameter is missing set it to null. "
+        "Dates may be natural language; return them as-is.\n\n"
+        f"User query: {user_text}"
+    )
+    resp = _client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"role":"system","content":"You extract parameters and ONLY output valid JSON."},
+            {"role":"user","content": prompt}
+        ],
+        temperature=0
+    )
+    txt = resp.choices[0].message.content.strip()
+    try:
+        params = json.loads(txt)
+    except Exception:
+        params = {p: None for p in param_list}
+    return params
+
+def gpt_fallback_response(user_text: str) -> str:
+    options = list(INTENTS.keys())
+    system = (
+        "You are a helpful support agent for an e-commerce analytics chatbot. "
+        "The app could not map the user's request to any known intent/SQL template. "
+        "Be helpful: either answer conversationally, gather missing details with specific "
+        "questions, or suggest the closest capability."
+    )
+    user = (
+        "No matching intent was found for the following message.\n"
+        f"Known intents are: {options}\n\n"
+        f"User message: {user_text}\n\n"
+        "Provide a concise, helpful response. If appropriate, suggest the nearest "
+        "matching capability from the list or ask one or two targeted follow-up questions."
+    )
+    resp = _client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[{"role":"system","content": system},
+                  {"role":"user","content": user}],
+        temperature=0.3
+    )
+    return resp.choices[0].message.content.strip()
+
+def gpt_label_unmapped(user_text: str) -> str:
+    system = (
+        "You label short messages into one category: "
+        "greeting | clarification | thanks | complaint | small_talk | farewell | other. "
+        "Return ONLY the label, nothing else."
+    )
+    user = f"Message: {user_text}"
+    resp = _client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[{"role":"system","content": system},
+                  {"role":"user","content": user}],
+        temperature=0
+    )
+    label = resp.choices[0].message.content.strip().lower()
+    allowed = {"greeting","clarification","thanks","complaint","small_talk","farewell","other"}
+    return label if label in allowed else "other"
+
+# =========================
+# PARAM PROCESSING
+# =========================
+def process_params(intent_key: str, params: dict) -> dict:
+    if params is None:
+        params = {}
+    cfg = INTENTS[intent_key]
+    required = cfg.get("required", [])
+    optional = cfg.get("optional", [])
+    allowed_keys = set(required + optional)
+
+    clean = {k: params.get(k) for k in allowed_keys}
+
+    # integer defaults
+    if "k" in allowed_keys:
+        v = clean.get("k")
+        try:
+            clean["k"] = int(str(v).strip()) if v not in (None, "", "null", "None") else 10
+        except Exception:
+            clean["k"] = 10
+    if "limit" in allowed_keys:
+        v = clean.get("limit")
+        try:
+            clean["limit"] = int(str(v).strip()) if v not in (None, "", "null", "None") else 50
+        except Exception:
+            clean["limit"] = 50
+
+    # defaults for common keys
+    for k in ("start_date", "end_date", "category", "product_id", "city", "seller_id", "order_id"):
+        if k in allowed_keys and k not in clean:
+            clean[k] = None
+
+    # parse natural language dates to YYYY-MM-DD
+    for k in ("start_date", "end_date"):
+        if k in clean:
+            v = clean.get(k)
+            if v and str(v).strip().lower() not in ("none", "null", ""):
+                parsed = dateparser.parse(str(v))
+                clean[k] = parsed.strftime("%Y-%m-%d") if parsed else None
+            else:
+                clean[k] = None
+    return clean
+
+# =========================
+# EXECUTE INTENT (SQLite)
+# =========================
+def run_intent(conn: sqlite3.Connection, intent_key: str, params: dict):
+    cfg = INTENTS[intent_key]
+    sql = cfg["sql"]
+    required = cfg.get("required", [])
+    optional = cfg.get("optional", [])
+    allowed_keys = set(required + optional)
+
+    bound = {k: params.get(k) for k in allowed_keys}
+    if "k" in allowed_keys:
+        try: bound["k"] = int(bound.get("k", 10))
+        except Exception: bound["k"] = 10
+    if "limit" in allowed_keys:
+        try: bound["limit"] = int(bound.get("limit", 50))
+        except Exception: bound["limit"] = 50
+    for k in ("start_date","end_date"):
+        if k in bound:
+            v = bound[k]
+            if v is not None and not isinstance(v, str):
+                try: bound[k] = v.strftime("%Y-%m-%d")
+                except Exception: bound[k] = None
+
+    logger.info(f"SQL intent={intent_key} | params={bound}")
+
+    cur = conn.cursor()
+    cur.execute(sql, bound)
+    rows = cur.fetchall()
+    col_names = [d[0] for d in cur.description]
+    return rows, col_names, sql, bound
+
+# =========================
+# DB SAVE
+# =========================
 def ensure_chat_schema():
     with get_connection() as conn:
         conn.execute("""
@@ -34,39 +534,176 @@ def save_chat_to_db(conn, user_id, user_message, bot_reply,
     """, (
         user_id, datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
         user_message, bot_reply, intent, sentiment, resolution, ftr_ms,
-        sql_query, sql_params
+        sql_query, json.dumps(sql_params or {})
     ))
     conn.commit()
 
+# =========================
+# CHAT UI
+# =========================
 def render_chat_tab(conn):
-    """Simple demo chat to prove wiring; replace with your LLM/intents later."""
-    st.title("💬 Chat")
-    if "chat_session" not in st.session_state:
-        st.session_state.chat_session = []
-
-    text = st.text_input("You:")
-    if st.button("Send"):
-        if text.strip():
-            t0 = time.time()
-            # TODO: replace with your real chatbot logic
-            reply = f"Echo: {text}"
-            ftr_ms = round((time.time() - t0) * 1000, 2)
-
-            # append session and persist with user_id
-            st.session_state.chat_session.append({
-                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                "user": text, "bot": reply
-            })
-            user_id = st.session_state["user"]["id"]
-            save_chat_to_db(conn, user_id, text, reply, intent=None, sentiment=None,
-                            resolution="Responded", ftr_ms=ftr_ms, sql_query=None, sql_params=None)
-            st.experimental_rerun()
-
-    # Show recent (session)
-    for turn in st.session_state.chat_session[-50:]:
-        st.markdown(f"**You:** {turn['user']}")
-        st.markdown(f"**Bot:** {turn['bot']}")
-        st.markdown("---")
+    """Full Olist chatbot with intents + SQL, scoped to current user."""
+    st.title("💬 Olist E-commerce Chatbot")
+
+    # session state for on-screen history (UI only)
+    if "history" not in st.session_state:
+        st.session_state.history = []
+    if "clear_input" not in st.session_state:
+        st.session_state.clear_input = False
+    if "user_input" not in st.session_state:
+        st.session_state.user_input = ""
+
+    # clear input after submit
+    if st.session_state.clear_input:
+        st.session_state.user_input = ""
+        st.session_state.clear_input = False
+
+    user_input = st.text_input("You:", key="user_input")
+    show_hist = st.checkbox("Show conversation history (this session)")
+
+    if st.button("Submit"):
+        if st.session_state.user_input.strip():
+            user_text = st.session_state.user_input
+            start_time = time.time()
+            current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+            # 1) intent + sentiment
+            cls = gpt_classify_intent(user_text)
+            intent = cls.get("intent", "UNMAPPED")
+            confidence = cls.get("confidence", 0.0)
+            reason = cls.get("reason", "")
+            logger.info(f"intent={intent} conf={confidence} reason={reason}")
+
+            sentiment = gpt_classify_sentiment(user_text)
+
+            # keyword guardrail
+            if intent != "UNMAPPED" and not _has_overlap(intent, user_text):
+                intent = "UNMAPPED"
+
+            sql_query, sql_params = "", {}
+            table_cols, table_rows = None, None
+
+            if intent == "UNMAPPED":
+                meta = gpt_label_unmapped(user_text)
+                intent = meta  # store meta label
+                bot_reply = gpt_fallback_response(user_text)
+                resolution = "Responded"
+            else:
+                # 2) extract + process params
+                params = gpt_extract_params(intent, user_text)
+                params = process_params(intent, params)
+
+                # 3) required params check
+                required = INTENTS[intent]["required"]
+                missing = [p for p in required if not params.get(p)]
+
+                if missing:
+                    bot_reply = f"Could you please provide the following information: {', '.join(missing)}"
+                    resolution = "Unresolved"
+                else:
+                    rows, col_names, sql_query, sql_params = run_intent(conn, intent, params)
+                    if rows:
+                        table_cols, table_rows = col_names, rows
+                        bot_reply = "Please see the table above for results."
+                        resolution = "Resolved"
+                    else:
+                        bot_reply = "No data found."
+                        resolution = "Unresolved"
+
+            ftr_ms = round((time.time() - start_time) * 1000, 2)
+
+            # 4) show + save
+            entry = {
+                "timestamp": current_time,
+                "user": user_text,
+                "intent": intent,
+                "sentiment": sentiment,
+                "resolution": resolution,
+                "reply": bot_reply,
+                "ftr_ms": ftr_ms,
+                "table_cols": table_cols,
+                "table_rows": table_rows,
+            }
+            st.session_state.history.append(entry)
+            if len(st.session_state.history) > 50:
+                st.session_state.history.pop(0)
+
+            # persist with user_id
+            uid = st.session_state["user"]["id"]
+            try:
+                save_chat_to_db(
+                    conn,
+                    user_id=uid,
+                    user_message=user_text,
+                    bot_reply=bot_reply,
+                    intent=intent,
+                    sentiment=sentiment,
+                    resolution=resolution,
+                    ftr_ms=ftr_ms,
+                    sql_query=sql_query,
+                    sql_params=sql_params if intent in INTENTS else {}
+                )
+            except Exception as e:
+                logger.exception("Failed to save chat: %s", e)
+
+            # clear input next render
+            st.session_state.clear_input = True
+            try:
+                st.rerun()
+            except Exception:
+                st.experimental_rerun()
+
+    # renderer
+    def _render_turn(turn):
+        ts = turn["timestamp"]
+        user_text = turn["user"]
+        intent_display = turn["intent"] if turn["intent"] else "UNMAPPED"
+        sentiment = turn["sentiment"]
+        resolution = turn["resolution"]
+        bot_reply = turn["reply"]
+        table_cols = turn.get("table_cols")
+        table_rows = turn.get("table_rows")
+
+        st.markdown(
+            f"""
+            <div style='background-color:#e6f2ff;padding:10px;border-radius:10px;max-width:80%;margin-bottom:5px;'>
+              <div style='font-size:0.8em;color:gray;'>{ts}</div>
+              <b>Customer:</b> {user_text}
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
+        st.markdown(
+            f"""
+            <div style='background-color:#ffffff;padding:10px;border-radius:10px;max-width:80%;margin-bottom:5px;'>
+              <b>Platform Analysis:</b><br>
+              <b>Intent:</b> {intent_display}<br>
+              <b>Sentiment:</b> {sentiment}<br>
+              <b>Resolution:</b> {resolution}
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
+        if table_cols and table_rows:
+            df_result = pd.DataFrame(table_rows, columns=table_cols)
+            st.table(df_result)
+        st.markdown(
+            f"""
+            <div style='background-color:#e6ffe6;padding:10px;border-radius:10px;max-width:80%;margin-left:auto;'>
+              <div style='font-size:0.8em;color:gray;'>{ts}</div>
+              <b>Support Agent:</b> {bot_reply}
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
+
+    if st.session_state.history:
+        st.subheader("Conversation")
+        if show_hist:
+            for turn in st.session_state.history[-50:]:
+                _render_turn(turn)
+        else:
+            _render_turn(st.session_state.history[-1])
 
 def render_user_export_tab(conn, user_id: int):
     st.subheader("Export My Chats")