Update app.py

app.py

@@ -1,40 +1,696 @@
-import altair as alt
+import os
+import time
+import json
+import math
+import random
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+
 import numpy as np
 import pandas as pd
 import streamlit as st
+import plotly.express as px
+import plotly.graph_objects as go
+from streamlit_option_menu import option_menu
+from faker import Faker
+from datetime import datetime, timedelta
+
+# =============================
+# Page / Theme Configuration
+# =============================
+st.set_page_config(
+    page_title="SAP S/4HANA Agentic AI Procurement Analytics",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# --- CSS ---
+st.markdown(
+    """
+<style>
+    :root {
+        --primary-color: #0066cc;
+        --secondary-color: #f0f8ff;
+        --accent-color: #ff6b35;
+        --success-color: #28a745;
+        --warning-color: #ffc107;
+        --danger-color: #dc3545;
+    }
+
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    header {visibility: hidden;}
+
+    .main-header {
+        background: linear-gradient(90deg, #0066cc, #004c99);
+        padding: 1rem;
+        border-radius: 10px;
+        margin-bottom: 2rem;
+        color: white;
+        text-align: center;
+    }
+
+    .metric-card {
+        background: white;
+        padding: 1.25rem;
+        border-radius: 12px;
+        box-shadow: 0 2px 10px rgba(0,0,0,0.08);
+        border-left: 4px solid var(--primary-color);
+        margin-bottom: 1rem;
+    }
+
+    .ai-insight {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 1rem;
+        border-radius: 12px;
+        margin: 1rem 0;
+    }
+
+    .alert { padding: 1rem; border-radius: 10px; margin: 0.6rem 0; border-left: 4px solid; }
+    .alert-success { background-color: #d4edda; border-color: var(--success-color); color: #155724; }
+    .alert-warning { background-color: #fff3cd; border-color: var(--warning-color); color: #856404; }
+    .alert-info { background-color: #d1ecf1; border-color: #17a2b8; color: #0c5460; }
+
+    .stButton > button { background: linear-gradient(90deg, #0066cc, #004c99); color: white; border: none; border-radius: 8px; padding: 0.5rem 1rem; font-weight: 600; transition: all 0.2s ease; }
+    .stButton > button:hover { transform: translateY(-1px); box-shadow: 0 6px 14px rgba(0,0,0,0.15); }
+</style>
+""",
+    unsafe_allow_html=True,
+)
+
+# =============================
+# Config & LLM Client (robust, version-agnostic)
+# =============================
+@dataclass
+class LLMConfig:
+    provider: str = os.getenv("LLM_PROVIDER", "openai").lower()  # openai | azure | compatible
+    base_url: Optional[str] = os.getenv("OPENAI_BASE_URL")  # for compatible endpoints
+    api_key: Optional[str] = (
+        os.getenv("OPENAI_API_KEY")
+        or os.getenv("OPENAI_API_TOKEN")
+        or os.getenv("OPENAI_KEY")
+    )
+    model: str = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+    timeout: int = int(os.getenv("OPENAI_TIMEOUT", "45"))
+    max_retries: int = int(os.getenv("OPENAI_MAX_RETRIES", "5"))
+    temperature: float = float(os.getenv("OPENAI_TEMPERATURE", "0.6"))
+
+
+def _post_json(url: str, headers: Dict[str, str], payload: Dict[str, Any], timeout: int):
+    import requests
+    return requests.post(url, headers=headers, json=payload, timeout=timeout)
+
+
+class UniversalLLMClient:
+    """A resilient client that works with OpenAI, Azure OpenAI, and compatible APIs.
+    - Prefers /chat/completions
+    - Falls back to /responses if available
+    - Retries with exponential backoff and respects Retry-After
+    """
+
+    def __init__(self, cfg: LLMConfig):
+        self.cfg = cfg
+        self.available = bool(cfg.api_key)
+        self.last_error: Optional[str] = None
+        if self.available:
+            self._smoke_test()
+
+    def _headers(self) -> Dict[str, str]:
+        return {"Authorization": f"Bearer {self.cfg.api_key}", "Content-Type": "application/json"}
+
+    def _base_url(self) -> str:
+        if self.cfg.provider == "azure":
+            # Use Azure env format if provided
+            endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
+            api_version = os.getenv("AZURE_OPENAI_API_VERSION", "2024-02-15-preview")
+            deployment = os.getenv("AZURE_OPENAI_DEPLOYMENT", self.cfg.model)
+            # Azure uses deployment name in path
+            return f"{endpoint}/openai/deployments/{deployment}?api-version={api_version}"
+        return (self.cfg.base_url or "https://api.openai.com/v1").rstrip("/")
+
+    def _smoke_test(self):
+        try:
+            _ = self.chat([
+                {"role": "user", "content": "ping"}
+            ], max_tokens=4)
+        except Exception as e:
+            self.available = False
+            self.last_error = str(e)
+
+    def chat(self, messages: List[Dict[str, str]], max_tokens: int = 400) -> str:
+        if not self.available:
+            raise RuntimeError("No API key configured")
+
+        headers = self._headers()
+        base = self._base_url()
+
+        # Endpoint selection
+        chat_url = f"{base}/chat/completions" if self.cfg.provider != "azure" else f"{base}&api-version-override=false"  # azure path already includes params
+        responses_url = f"{base}/responses"
+
+        payload = {
+            "model": self.cfg.model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": self.cfg.temperature,
+        }
+
+        # Retry with backoff
+        delay = 1.0
+        for attempt in range(self.cfg.max_retries):
+            try:
+                resp = _post_json(chat_url, headers, payload, self.cfg.timeout)
+                if resp.status_code == 200:
+                    data = resp.json()
+                    return data["choices"][0]["message"]["content"].strip()
+                # Try /responses fallback for some providers
+                if resp.status_code in (404, 400):
+                    alt = _post_json(
+                        responses_url,
+                        headers,
+                        {"model": self.cfg.model, "input": messages, "max_output_tokens": max_tokens, "temperature": self.cfg.temperature},
+                        self.cfg.timeout,
+                    )
+                    if alt.status_code == 200:
+                        return alt.json()["output"][0]["content"][0]["text"].strip()
+
+                if resp.status_code in (429, 500, 502, 503, 504):
+                    retry_after = float(resp.headers.get("Retry-After", delay))
+                    time.sleep(retry_after)
+                    delay = min(delay * 2, 8.0)
+                    continue
+                # Other errors → raise
+                try:
+                    j = resp.json()
+                    msg = j.get("error", {}).get("message", str(j))
+                except Exception:
+                    msg = resp.text
+                raise RuntimeError(f"API error {resp.status_code}: {msg}")
+            except Exception as e:
+                if attempt == self.cfg.max_retries - 1:
+                    self.last_error = str(e)
+                    raise
+                time.sleep(delay)
+                delay = min(delay * 2, 8.0)
+        raise RuntimeError("Exhausted retries")
+
+
+# =============================
+# Data Generation & Utils
+# =============================
+@st.cache_data(show_spinner=False)
+def generate_synthetic_procurement_data(seed: int = 42) -> Tuple[pd.DataFrame, pd.DataFrame]:
+    """Generate richer synthetic SAP S/4HANA procurement data, including lead times and late flags."""
+    fake = Faker()
+    np.random.seed(seed)
+    random.seed(seed)
+
+    vendors = [
+        "Siemens AG", "BASF SE", "BMW Group", "Mercedes-Benz", "Bosch GmbH",
+        "ThyssenKrupp", "Bayer AG", "Continental AG", "Henkel AG", "SAP SE",
+    ]
+
+    categories = [
+        "Raw Materials", "Components", "Packaging", "Services",
+        "IT Equipment", "Office Supplies", "Machinery", "Chemicals",
+    ]
+
+    purchase_orders: List[Dict[str, Any]] = []
+    today = datetime.utcnow().date()
+
+    for i in range(900):
+        order_date = fake.date_between(start_date='-24m', end_date='today')
+        promised_days = random.randint(3, 30)
+        promised_date = order_date + timedelta(days=promised_days)
+        actual_lag = max(1, int(np.random.normal(promised_days, 5)))
+        delivery_date = order_date + timedelta(days=actual_lag)
+        late = delivery_date > promised_date
+
+        unit_price = round(random.uniform(10, 500), 2)
+        qty = random.randint(1, 1200)
+        order_value = round(unit_price * qty, 2)
+
+        po = {
+            'po_number': f"PO{str(i+1).zfill(6)}",
+            'vendor': random.choice(vendors),
+            'material_category': random.choice(categories),
+            'order_date': order_date,
+            'promised_date': promised_date,
+            'delivery_date': delivery_date,
+            'lead_time_days': (delivery_date - order_date).days,
+            'promised_days': promised_days,
+            'late_delivery': late,
+            'order_value': order_value,
+            'quantity': qty,
+            'unit_price': unit_price,
+            'status': random.choice(['Open', 'Delivered', 'Invoiced', 'Paid']),
+            'plant': random.choice(['Plant_001', 'Plant_002', 'Plant_003']),
+            'buyer': fake.name(),
+            'currency': 'EUR',
+            'payment_terms': random.choice(['30 Days', '45 Days', '60 Days', '90 Days']),
+            'quality_score': round(np.clip(np.random.normal(8.5, 0.8), 5.0, 10.0), 1),
+        }
+        purchase_orders.append(po)
+
+    spend_rows = []
+    for v in vendors:
+        for c in categories:
+            spend_rows.append({
+                'vendor': v,
+                'category': c,
+                'total_spend': round(random.uniform(10000, 700000), 2),
+                'contract_compliance': round(random.uniform(78, 100), 1),
+                'risk_score': round(random.uniform(1, 10), 1),
+                'savings_potential': round(random.uniform(5, 25), 1),
+            })
+
+    po_df = pd.DataFrame(purchase_orders)
+    spend_df = pd.DataFrame(spend_rows)
+    return po_df, spend_df
+
+
+def eur(x: float) -> str:
+    return f"€{x:,.0f}"
+
+
+# =============================
+# Analytics Engine
+# =============================
+class ProcurementAnalytics:
+    def __init__(self, po_df: pd.DataFrame):
+        self.df = po_df.copy()
+        self.df['order_date'] = pd.to_datetime(self.df['order_date'])
+        self.df['month'] = self.df['order_date'].dt.to_period('M').dt.to_timestamp()
+
+    @st.cache_data(show_spinner=False)
+    def kpis(_self, df_hash: int) -> Dict[str, Any]:
+        df = _self.df
+        return {
+            'total_spend': float(df['order_value'].sum()),
+            'avg_order_value': float(df['order_value'].mean()),
+            'active_vendors': int(df['vendor'].nunique()),
+            'on_time_rate': float((~df['late_delivery']).mean()),
+            'quality_avg': float(df['quality_score'].mean()),
+        }
+
+    def category_spend(self) -> pd.DataFrame:
+        return (
+            self.df.groupby('material_category', as_index=False)['order_value'].sum()
+            .sort_values('order_value', ascending=False)
+        )
+
+    def vendor_spend(self, top_n: int = 8) -> pd.DataFrame:
+        g = self.df.groupby('vendor', as_index=False)['order_value'].sum()
+        return g.sort_values('order_value', ascending=False).head(top_n)
+
+    def monthly_spend(self) -> pd.DataFrame:
+        return self.df.groupby('month', as_index=False)['order_value'].sum().sort_values('month')
+
+    def vendor_performance(self) -> pd.DataFrame:
+        g = self.df.groupby('vendor').agg(
+            total_spend=('order_value', 'sum'),
+            on_time=('late_delivery', lambda s: 1 - s.mean()),
+            quality=('quality_score', 'mean'),
+            orders=('po_number', 'count'),
+            lead_time=('lead_time_days', 'mean'),
+        )
+        g['on_time'] = (g['on_time'] * 100).round(1)
+        g['quality'] = g['quality'].round(2)
+        g['lead_time'] = g['lead_time'].round(1)
+        g['total_spend'] = g['total_spend'].round(2)
+        return g.sort_values('total_spend', ascending=False)
+
+    def anomalies(self) -> pd.DataFrame:
+        # Simple IQR for order_value anomalies
+        q1, q3 = self.df['order_value'].quantile([0.25, 0.75])
+        iqr = q3 - q1
+        hi = q3 + 1.5 * iqr
+        lo = max(0, q1 - 1.5 * iqr)
+        a = self.df[(self.df['order_value'] > hi) | (self.df['order_value'] < lo)].copy()
+        a['anomaly_reason'] = np.where(a['order_value'] > hi, 'High value', 'Low value')
+        return a.sort_values('order_value', ascending=False).head(50)
+
+    def simulate_vendor_consolidation(self, keep_top: int) -> Dict[str, Any]:
+        g = self.df.groupby('vendor')['order_value'].sum().sort_values(ascending=False)
+        kept_vendors = list(g.head(keep_top).index)
+        kept_spend = self.df[self.df['vendor'].isin(kept_vendors)]['order_value'].sum()
+        total_spend = self.df['order_value'].sum()
+        share = kept_spend / total_spend if total_spend else 0
+        est_savings = 0.05 + (0.12 * (1 - share))  # heuristic: better leverage when consolidating
+        return {
+            'kept_vendors': kept_vendors,
+            'kept_share': share,
+            'estimated_savings_pct': max(0.03, min(0.18, est_savings)),
+        }
+
+
+# =============================
+# Agent (uses UniversalLLMClient with safe fallback)
+# =============================
+class UniversalProcurementAgent:
+    def __init__(self, po_df: pd.DataFrame, spend_df: pd.DataFrame, client: UniversalLLMClient):
+        self.po_data = po_df
+        self.spend_data = spend_df
+        self.llm = client
+
+    def llm_status(self) -> Dict[str, Any]:
+        return {
+            "api_key_available": bool(self.llm.cfg.api_key),
+            "llm_available": self.llm.available,
+            "last_error": self.llm.last_error or "Connected successfully" if self.llm.available else "Unavailable",
+            "provider": self.llm.cfg.provider,
+            "model": self.llm.cfg.model,
+            "base_url": self.llm.cfg.base_url or "https://api.openai.com/v1",
+        }
+
+    def _rule_summary(self) -> str:
+        total_spend = float(self.po_data['order_value'].sum())
+        on_time = float((~self.po_data['late_delivery']).mean()) * 100
+        quality = float(self.po_data['quality_score'].mean())
+        top_cat = self.po_data.groupby('material_category')['order_value'].sum().idxmax()
+        top_vendor = self.po_data.groupby('vendor')['order_value'].sum().idxmax()
+        return (
+            "🤖 **[Smart Analysis - Rule-Based Engine]**\n"
+            "**Executive Snapshot**\n"
+            f"• Total spend: {eur(total_spend)} across {len(self.po_data):,} POs\n"
+            f"• On-time delivery: {on_time:.1f}%  • Avg quality: {quality:.1f}/10\n"
+            f"• Top category: {top_cat}  • Lead vendor: {top_vendor}\n\n"
+            "**Opportunities**\n"
+            "• Consolidate long tail vendors to improve pricing power (5–12% potential).\n"
+            "• Tighten SLAs for late deliveries and extend performance-based contracts.\n"
+            "• Automate low-value buys to reduce cycle time."
+        )
+
+    def executive_summary(self) -> str:
+        if not self.llm.available:
+            return self._rule_summary()
+        data_summary = {
+            "total_spend": float(self.po_data['order_value'].sum()),
+            "total_orders": int(len(self.po_data)),
+            "vendor_count": int(self.po_data['vendor'].nunique()),
+            "avg_order_value": float(self.po_data['order_value'].mean()),
+            "on_time_delivery": float((~self.po_data['late_delivery']).mean()),
+            "avg_quality": float(self.po_data['quality_score'].mean()),
+        }
+        messages = [
+            {"role": "system", "content": "You are a senior procurement analyst with expertise in SAP S/4HANA. Be concise, metric-driven, and actionable."},
+            {"role": "user", "content": (
+                "Create an executive summary covering: 1) overview (2-3 sentences), 2) KPI highlights, 3) risks/alerts, 4) 3-4 strategic recommendations with quantified impact.\n"
+                f"Data: {json.dumps(data_summary)}"
+            )},
+        ]
+        try:
+            return "🧠 **[AI-Powered Analysis]**\n\n" + self.llm.chat(messages, max_tokens=650)
+        except Exception as e:
+            return self._rule_summary() + f"\n\n*AI fallback due to: {e}*"
+
+    def chat_with_data(self, question: str) -> str:
+        if not self.llm.available:
+            return self._rule_answer(question)
+        context = {
+            "total_spend": float(self.po_data['order_value'].sum()),
+            "orders": int(len(self.po_data)),
+            "vendors": int(self.po_data['vendor'].nunique()),
+            "on_time": float((~self.po_data['late_delivery']).mean()),
+            "quality": float(self.po_data['quality_score'].mean()),
+        }
+        messages = [
+            {"role": "system", "content": "You are an expert procurement co-pilot. Use the provided context and respond with precise metrics and concrete actions."},
+            {"role": "user", "content": f"Question: {question}\nContext: {json.dumps(context)}"},
+        ]
+        try:
+            return "🧠 **[AI Response]**\n\n" + self.llm.chat(messages, max_tokens=450)
+        except Exception as e:
+            return self._rule_answer(question) + f"\n\n*AI fallback due to: {e}*"
+
+    def _rule_answer(self, question: str) -> str:
+        q = question.lower()
+        if any(w in q for w in ["spend", "cost", "budget"]):
+            total = float(self.po_data['order_value'].sum())
+            monthly = total / max(1, self.po_data['order_date'].nunique()/30)
+            top_cat = self.po_data.groupby('material_category')['order_value'].sum().idxmax()
+            return (
+                "🤖 **[Smart Analysis] Spend**\n"
+                f"• Total spend: {eur(total)}\n"
+                f"• Monthly average (approx): {eur(monthly)}\n"
+                f"• Top category: {top_cat}\n"
+                "Tip: prioritize competitive events for the top 2 categories to unlock 4–8% savings."
+            )
+        if any(w in q for w in ["vendor", "supplier", "partner"]):
+            vp = self.po_data.groupby('vendor').agg(
+                spend=('order_value','sum'),
+                on_time=('late_delivery', lambda s: 1 - s.mean()),
+            ).sort_values('spend', ascending=False).head(1)
+            top = vp.index[0]
+            on_time = float(vp.iloc[0]['on_time'])*100
+            return (
+                "🤖 **[Smart Analysis] Vendor**\n"
+                f"• Top vendor: {top} • On-time: {on_time:.1f}%\n"
+                "Action: lock in volume tiers and add delivery penalties to the contract."
+            )
+        if any(w in q for w in ["risk", "late", "delay"]):
+            late_rate = float(self.po_data['late_delivery'].mean())*100
+            return (
+                "🤖 **[Smart Analysis] Risk**\n"
+                f"• Late delivery rate: {late_rate:.1f}%\n"
+                "Action: add buffer to planning lead times and escalate chronic late suppliers."
+            )
+        return (
+            "🤖 **[Smart Analysis]** I can help with spend, vendor performance, risk, savings, and trends. Try: \"Where can I save 10%?\""
+        )
+
+
+# =============================
+# App State & Initialization
+# =============================
+if 'data_loaded' not in st.session_state:
+    with st.spinner('🔄 Generating synthetic SAP S/4HANA procurement data...'):
+        st.session_state.po_df, st.session_state.spend_df = generate_synthetic_procurement_data()
+        st.session_state.data_loaded = True
+
+@st.cache_resource(show_spinner=False)
+def get_llm_client() -> UniversalLLMClient:
+    return UniversalLLMClient(LLMConfig())
+
+client = get_llm_client()
+agent = UniversalProcurementAgent(st.session_state.po_df, st.session_state.spend_df, client)
+analytics = ProcurementAnalytics(st.session_state.po_df)
+
+status = agent.llm_status()
+api_status = "🟢 Connected" if status['llm_available'] else "🔴 Not Connected"
+
+# =============================
+# Header
+# =============================
+st.markdown(
+    f"""
+<div class="main-header">
+  <h1>🤖 SAP S/4HANA Agentic AI Procurement Analytics</h1>
+  <p>Autonomous Intelligence for Procurement Excellence</p>
+  <small>OpenAI: {api_status} · Data: {len(st.session_state.po_df):,} POs</small>
+</div>
+""",
+    unsafe_allow_html=True,
+)
+
+# =============================
+# Sidebar
+# =============================
+with st.sidebar:
+    st.markdown("### 🤖 AI System Status")
+    st.markdown(f"**Connection:** {api_status}")
+    st.markdown(f"**Provider:** {status['provider']}  ")
+    st.markdown(f"**Model:** {status['model']}")
+
+    with st.expander("🔍 System Information"):
+        safe = status.copy()
+        # Do not expose API key
+        st.json({k: v for k, v in safe.items() if k != 'api_key'})
+
+    if st.button("🔄 Test AI Connection"):
+        if status['llm_available']:
+            st.success("LLM is reachable and ready.")
+        else:
+            st.error(f"LLM unavailable: {status['last_error']}")
+
+    st.markdown("---")
+
+    selected = option_menu(
+        "Navigation",
+        ["🏠 Dashboard", "💬 AI Chat", "📊 Analytics", "🧪 What‑If", "🎯 Recommendations"],
+        icons=['house', 'chat', 'bar-chart', 'beaker', 'target'],
+        menu_icon="cast",
+        default_index=0,
+        styles={
+            "container": {"padding": "0!important", "background-color": "#fafafa"},
+            "icon": {"color": "#0066cc", "font-size": "18px"},
+            "nav-link": {"font-size": "16px", "text-align": "left", "margin": "0px", "--hover-color": "#eee"},
+            "nav-link-selected": {"background-color": "#0066cc"},
+        },
+    )
+
+# =============================
+# Main Views
+# =============================
+if selected == "🏠 Dashboard":
+    st.markdown("### 🧠 AI Executive Summary")
+    with st.spinner('🤖 Analyzing procurement data...'):
+        summary = agent.executive_summary()
+    st.markdown(f"""
+    <div class="ai-insight">
+        <h4>📊 Intelligent Analysis</h4>
+        <div style="white-space: pre-line; line-height: 1.55;">{summary}</div>
+    </div>
+    """, unsafe_allow_html=True)
+
+    k = analytics.kpis(hash(tuple(st.session_state.po_df['po_number'])))
+
+    c1, c2, c3, c4 = st.columns(4)
+    with c1:
+        st.markdown(f"<div class='metric-card'><h3 style='color: var(--primary-color); margin:0;'>Total Spend</h3><h2 style='margin: .5rem 0;'>{eur(k['total_spend'])}</h2><p style='color:#28a745;margin:0;'>📈 Active Portfolio</p></div>", unsafe_allow_html=True)
+    with c2:
+        st.markdown(f"<div class='metric-card'><h3 style='color: var(--primary-color); margin:0;'>Avg Order Value</h3><h2 style='margin: .5rem 0;'>{eur(k['avg_order_value'])}</h2><p style='color:#17a2b8;margin:0;'>📊 Order Efficiency</p></div>", unsafe_allow_html=True)
+    with c3:
+        st.markdown(f"<div class='metric-card'><h3 style='color: var(--primary-color); margin:0;'>Active Vendors</h3><h2 style='margin: .5rem 0;'>{k['active_vendors']}</h2><p style='color:#6f42c1;margin:0;'>🤝 Strategic Partners</p></div>", unsafe_allow_html=True)
+    with c4:
+        st.markdown(f"<div class='metric-card'><h3 style='color: var(--primary-color); margin:0;'>On‑Time Delivery</h3><h2 style='margin: .5rem 0;'>{k['on_time_rate']*100:.1f}%</h2><p style='color:#28a745;margin:0;'>⏱ Performance</p></div>", unsafe_allow_html=True)
+
+    st.markdown("### 📊 Executive Dashboard")
+    colA, colB = st.columns(2)
+
+    with colA:
+        cat = analytics.category_spend()
+        fig = px.pie(cat, values='order_value', names='material_category', title='Spend Distribution by Category')
+        fig.update_layout(title_font_size=16, title_x=0.5, height=420)
+        st.plotly_chart(fig, use_container_width=True)
+
+    with colB:
+        vend = analytics.vendor_spend(top_n=8)
+        fig2 = px.bar(vend, x='vendor', y='order_value', title='Top Vendors by Spend')
+        fig2.update_layout(title_font_size=16, title_x=0.5, xaxis_tickangle=45, height=420)
+        st.plotly_chart(fig2, use_container_width=True)
+
+    colC, colD = st.columns(2)
+    with colC:
+        ms = analytics.monthly_spend()
+        fig3 = px.line(ms, x='month', y='order_value', markers=True, title='Monthly Spend Trend')
+        fig3.update_layout(title_font_size=16, title_x=0.5, height=420)
+        st.plotly_chart(fig3, use_container_width=True)
+
+    with colD:
+        ano = analytics.anomalies()
+        st.markdown("#### 🔎 High/Low Value Anomalies (Top 50)")
+        st.dataframe(ano[['po_number','vendor','material_category','order_value','anomaly_reason']].reset_index(drop=True), use_container_width=True, height=380)
+
+elif selected == "💬 AI Chat":
+    st.markdown("### 💬 Chat with Your Procurement Data")
+    st.markdown(f"""
+    <div class="ai-insight">
+        <h4>🤖 Universal AI Assistant</h4>
+        <p>Ask me anything about your procurement data! I'm provider-agnostic and resilient to API versions.</p>
+        <p><small>Status: {api_status} | Provider: {status['provider']} | Model: {status['model']}</small></p>
+    </div>
+    """, unsafe_allow_html=True)
+
+    if "messages" not in st.session_state:
+        st.session_state.messages = [
+            {"role": "assistant", "content": "Hello! I loaded your data and I'm ready to help—try asking about spend, vendors, or risk."}
+        ]
+
+    for m in st.session_state.messages:
+        with st.chat_message(m["role"]):
+            st.markdown(m["content"])
+
+    if prompt := st.chat_input("Ask about your procurement data…"):
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.markdown(prompt)
+        with st.chat_message("assistant"):
+            with st.spinner("🤖 Analyzing…"):
+                reply = agent.chat_with_data(prompt)
+            st.markdown(reply)
+        st.session_state.messages.append({"role": "assistant", "content": reply})
+
+    st.markdown("#### 💡 Try quick questions:")
+    c1, c2, c3 = st.columns(3)
+    qs = ["What are my biggest spending areas?", "How are my vendors performing?", "Where can I save 10%?"]
+    for i, (c, q) in enumerate(zip([c1, c2, c3], qs)):
+        with c:
+            if st.button(f"💭 {q}", key=f"q_{i}"):
+                st.session_state.messages.append({"role": "user", "content": q})
+                st.session_state.messages.append({"role": "assistant", "content": agent.chat_with_data(q)})
+                st.rerun()
+
+elif selected == "📊 Analytics":
+    st.markdown("### 📈 Advanced Analytics Dashboard")
+    vp = analytics.vendor_performance()
+    st.dataframe(vp.rename(columns={
+        'total_spend': 'Total Spend (€)',
+        'on_time': 'On-Time Delivery %',
+        'quality': 'Quality Score',
+        'orders': 'Order Count',
+        'lead_time': 'Avg Lead Time (days)'
+    }), use_container_width=True)
+
+    st.download_button(
+        label="⬇️ Download Vendor Performance (CSV)",
+        data=vp.to_csv().encode('utf-8'),
+        file_name="vendor_performance.csv",
+        mime="text/csv",
+    )
+
+elif selected == "🧪 What‑If":
+    st.markdown("### 🧪 What‑If: Vendor Consolidation Simulator")
+    top_n = st.slider("Keep top N vendors by spend", min_value=2, max_value=10, value=6, step=1)
+    sim = analytics.simulate_vendor_consolidation(keep_top=top_n)
+
+    kept_names = ", ".join(sim['kept_vendors'])
+    st.markdown(
+        f"""
+        <div class='alert alert-info'>
+            <strong>Scenario:</strong> Keep top <b>{top_n}</b> vendors. Estimated addressable spend share: <b>{sim['kept_share']*100:.1f}%</b>.<br/>
+            <strong>Potential savings:</strong> <b>{sim['estimated_savings_pct']*100:.1f}%</b> (heuristic).<br/>
+            <small>Kept Vendors:</small> {kept_names}
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    if st.checkbox("Show detailed vendor spend"):
+        st.dataframe(analytics.vendor_spend(top_n=999), use_container_width=True)
+
+elif selected == "🎯 Recommendations":
+    st.markdown("### 🚀 Strategic Recommendations")
+    recs = [
+        "🎯 **Vendor Consolidation**: Reduce long-tail suppliers; target 8–15% price improvement via volume tiers.",
+        "⚡ **Process Automation**: Auto-approve low-value POs to cut cycle time by 35–50%.",
+        "📊 **Performance Contracts**: KPI-linked clauses for on-time delivery; add service credits for misses.",
+        "🛡️ **Risk Monitoring**: Score suppliers on late rate, quality, and concentration; escalate chronic offenders.",
+        "🧠 **AI Copilot**: Use LLM to draft RFQs, summarize bids, and propose award scenarios.",
+    ]
+    for i, rec in enumerate(recs, start=1):
+        st.markdown(
+            f"""
+            <div class="alert alert-success">
+                <h4>Recommendation #{i}</h4>
+                <p>{rec}</p>
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# =============================
+# Footer
+# =============================
+st.markdown("---")
+st.markdown(
+    f"""
+<div style="text-align:center; padding: 1rem; color:#666;">
+  <p>🤖 <strong>Universal AI Procurement Analytics</strong> | Provider‑agnostic LLM integration with resilient fallbacks</p>
+  <p><em>Demo with synthetic data • {len(st.session_state.po_df):,} orders • OpenAI {api_status}</em></p>
+</div>
+""",
+    unsafe_allow_html=True,
+)