Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,27 +1,33 @@
-import streamlit as st
-import pandas as pd
+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
-import time
 from faker import Faker
 from datetime import datetime, timedelta
-import random
-import json
-from typing import Dict, List, Any
-import os
 
-# Page configuration
+# =============================
+# Page / Theme Configuration
+# =============================
 st.set_page_config(
     page_title="SAP S/4HANA Agentic AI Procurement Analytics",
     page_icon="🤖",
     layout="wide",
-    initial_sidebar_state="expanded"
+    initial_sidebar_state="expanded",
 )
 
-# Custom CSS (same as before)
-st.markdown("""
+# --- CSS ---
+st.markdown(
+    """
 <style>
     :root {
         --primary-color: #0066cc;
@@ -31,11 +37,11 @@ st.markdown("""
         --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;
@@ -44,481 +50,477 @@ st.markdown("""
         color: white;
         text-align: center;
     }
-    
+
     .metric-card {
         background: white;
-        padding: 1.5rem;
-        border-radius: 10px;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        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: 10px;
-        margin: 1rem 0;
-    }
-    
-    .alert {
-        padding: 1rem;
-        border-radius: 8px;
+        border-radius: 12px;
         margin: 1rem 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.3s ease;
-    }
-    
-    .stButton > button:hover {
-        transform: translateY(-2px);
-        box-shadow: 0 4px 8px rgba(0,0,0,0.2);
     }
+
+    .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)
-
-# Safe OpenAI integration that works with ANY version
-def get_openai_api_key():
-    """Get API key from environment variables (Hugging Face Spaces compatible)"""
-    return (
-        os.getenv('OPENAI_API_KEY') or 
-        os.getenv('OPENAI_API_TOKEN') or 
-        os.getenv('OPENAI_KEY')
-    )
+""",
+    unsafe_allow_html=True,
+)
 
-def safe_openai_chat(api_key, messages, model="gpt-3.5-turbo", max_tokens=400):
-    """Universal OpenAI chat function that works with any OpenAI version"""
-    
-    if not api_key:
-        return None, "No API key available"
-    
-    try:
-        # Try using requests directly (most reliable method)
-        import requests
-        
-        headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json"
-        }
-        
-        data = {
-            "model": model,
+# =============================
+# 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": 0.7
+            "temperature": self.cfg.temperature,
         }
-        
-        response = requests.post(
-            "https://api.openai.com/v1/chat/completions",
-            headers=headers,
-            json=data,
-            timeout=30
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            return result['choices'][0]['message']['content'], "Success"
-        elif response.status_code == 401:
-            return None, "Invalid API key"
-        elif response.status_code == 429:
-            return None, "Rate limit exceeded"
-        else:
-            return None, f"API error: {response.status_code}"
-            
-    except requests.exceptions.RequestException as e:
-        return None, f"Network error: {str(e)}"
-    except Exception as e:
-        return None, f"Request failed: {str(e)}"
-
-# Data generation function
-@st.cache_data
-def generate_synthetic_procurement_data():
-    """Generate synthetic SAP S/4HANA procurement data"""
+
+        # 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(42)
-    random.seed(42)
-    
+    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"
+        "ThyssenKrupp", "Bayer AG", "Continental AG", "Henkel AG", "SAP SE",
     ]
-    
-    material_categories = [
-        "Raw Materials", "Components", "Packaging", "Services", 
-        "IT Equipment", "Office Supplies", "Machinery", "Chemicals"
+
+    categories = [
+        "Raw Materials", "Components", "Packaging", "Services",
+        "IT Equipment", "Office Supplies", "Machinery", "Chemicals",
     ]
-    
-    purchase_orders = []
-    for i in range(500):
-        order_date = fake.date_between(start_date='-2y', end_date='today')
-        delivery_date = order_date + timedelta(days=random.randint(1, 30))
-        
+
+    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(material_categories),
+            'material_category': random.choice(categories),
             'order_date': order_date,
+            'promised_date': promised_date,
             'delivery_date': delivery_date,
-            'order_value': round(random.uniform(1000, 100000), 2),
-            'quantity': random.randint(1, 1000),
-            'unit_price': round(random.uniform(10, 500), 2),
+            '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', '60 Days', '90 Days']),
-            'on_time_delivery': random.choice([True, False]),
-            'quality_score': round(random.uniform(7, 10), 1)
+            '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_data = []
-    for vendor in vendors:
-        for category in material_categories:
-            spend = {
-                'vendor': vendor,
-                'category': category,
-                'total_spend': round(random.uniform(10000, 500000), 2),
-                'contract_compliance': round(random.uniform(80, 100), 1),
+
+    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)
-            }
-            spend_data.append(spend)
-    
-    return pd.DataFrame(purchase_orders), pd.DataFrame(spend_data)
+                'savings_potential': round(random.uniform(5, 25), 1),
+            })
 
-# Updated AI Agent with bulletproof OpenAI integration
-class UniversalProcurementAgent:
-    """AI Agent with universal OpenAI compatibility"""
-    
-    def __init__(self, po_data: pd.DataFrame, spend_data: pd.DataFrame):
-        self.po_data = po_data
-        self.spend_data = spend_data
-        self.api_key = get_openai_api_key()
-        self.llm_available = bool(self.api_key)
-        
-        # Test connection if API key exists
-        if self.llm_available:
-            self._test_connection()
-    
-    def _test_connection(self):
-        """Test OpenAI connection using direct API call"""
-        test_response, status = safe_openai_chat(
-            self.api_key,
-            [{"role": "user", "content": "Hello"}],
-            max_tokens=5
+    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)
         )
-        
-        if test_response is None:
-            self.llm_available = False
-            self.connection_error = status
-        else:
-            self.connection_error = "Connected successfully"
-    
-    def get_status_info(self) -> Dict[str, Any]:
-        """Get connection status information"""
+
+    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.api_key),
-            "api_key_length": len(self.api_key) if self.api_key else 0,
-            "llm_available": self.llm_available,
-            "connection_status": getattr(self, 'connection_error', 'Not tested'),
-            "method": "Direct API calls (version-agnostic)"
+            "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 test_llm_connection(self) -> Dict[str, Any]:
-        """Test LLM connection with detailed status"""
-        if not self.api_key:
-            return {
-                "status": "❌ No API Key",
-                "details": "Add OPENAI_API_KEY to your Hugging Face Space secrets",
-                "recommendation": "Go to Settings → Variables & Secrets → Add OPENAI_API_KEY"
-            }
-        
-        response, status = safe_openai_chat(
-            self.api_key,
-            [{"role": "user", "content": "Test connection"}],
-            max_tokens=10
+
+    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."
         )
-        
-        if response:
-            return {
-                "status": "✅ Connected",
-                "details": "OpenAI API responding normally",
-                "method": "Direct API calls (universal compatibility)"
-            }
-        else:
-            return {
-                "status": "⚠️ Connection Failed",
-                "details": status,
-                "recommendation": "Check API key validity or try regenerating it"
-            }
-    
-    def generate_executive_summary(self) -> str:
-        """Generate executive summary with AI or fallback"""
-        
-        if not self.llm_available:
-            return self._generate_rule_based_summary()
-        
-        # Prepare data for AI analysis
+
+    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": len(self.po_data),
-            "vendor_count": len(self.po_data['vendor'].unique()),
+            "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['on_time_delivery'].mean()),
-            "avg_quality": float(self.po_data['quality_score'].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 systems. Provide professional, actionable insights."
-            },
-            {
-                "role": "user", 
-                "content": f"""Analyze this procurement data and provide an executive summary:
-
-{json.dumps(data_summary, indent=2)}
-
-Include:
-1. Executive overview (2-3 sentences)
-2. Key performance highlights with metrics
-3. Areas needing attention
-4. Strategic recommendations (3-4 actionable items)
-
-Keep it professional and actionable for C-level executives."""
-            }
+            {"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)}"
+            )},
         ]
-        
-        ai_response, status = safe_openai_chat(self.api_key, messages, max_tokens=600)
-        
-        if ai_response:
-            return f"🧠 **[AI-Powered Analysis - OpenAI GPT]**\n\n{ai_response}"
-        else:
-            fallback = self._generate_rule_based_summary()
-            return f"⚠️ **[AI Temporarily Unavailable]**\n\n{fallback}\n\n*Error: {status}*"
-    
-    def _generate_rule_based_summary(self) -> str:
-        """Enhanced rule-based summary"""
-        total_spend = self.po_data['order_value'].sum()
-        total_orders = len(self.po_data)
-        on_time_rate = self.po_data['on_time_delivery'].mean() * 100
-        quality_avg = self.po_data['quality_score'].mean()
-        top_category = self.po_data.groupby('material_category')['order_value'].sum().idxmax()
-        top_vendor = self.po_data.groupby('vendor')['order_value'].sum().idxmax()
-        
-        return f"""🤖 **[Smart Analysis - Rule-Based Engine]**
-
-**🎯 Executive Summary - Procurement Performance Dashboard**
-
-📊 **Portfolio Overview**
-• Total spend: €{total_spend:,.0f} across {total_orders:,} purchase orders
-• Active suppliers: {len(self.po_data['vendor'].unique())} strategic partners
-• Average order value: €{self.po_data['order_value'].mean():,.0f}
-
-🏆 **Performance Metrics**
-• On-time delivery: {on_time_rate:.1f}% (Industry benchmark: 85%)
-• Quality score: {quality_avg:.1f}/10 (Excellent: >8.5)
-• Top category: {top_category}
-• Leading partner: {top_vendor}
-
-⚡ **Strategic Opportunities**
-• Vendor consolidation from {len(self.po_data['vendor'].unique())} to 6-7 strategic partners
-• Contract optimization with high-performing suppliers
-• Process automation for routine purchases
-
-💡 **Recommended Actions**
-• Implement strategic sourcing for {top_category}
-• Develop KPI-driven vendor agreements
-• Deploy automated approval workflows
-
-*🔧 Advanced AI analysis available with OpenAI connection*"""
-    
-    def chat_with_data(self, user_question: str) -> str:
-        """Chat interface with universal compatibility"""
-        
-        if not self.llm_available:
-            return self._get_rule_based_response(user_question)
-        
-        # Prepare context for AI
+        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()),
-            "order_count": len(self.po_data),
-            "vendor_count": len(self.po_data['vendor'].unique()),
-            "avg_quality": float(self.po_data['quality_score'].mean()),
-            "on_time_rate": float(self.po_data['on_time_delivery'].mean())
+            "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 analyst. Answer questions about procurement data professionally with specific metrics when relevant."
-            },
-            {
-                "role": "user",
-                "content": f"User Question: {user_question}\n\nProcurement Data Context: {json.dumps(context, indent=2)}\n\nProvide a helpful, professional response."
-            }
+            {"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)}"},
         ]
-        
-        ai_response, status = safe_openai_chat(self.api_key, messages, max_tokens=400)
-        
-        if ai_response:
-            return f"🧠 **[AI Response - OpenAI GPT]**\n\n{ai_response}"
-        else:
-            fallback = self._get_rule_based_response(user_question)
-            return f"⚠️ **[Smart Fallback]** AI temporarily unavailable\n\n{fallback}\n\n*Error: {status}*"
-    
-    def _get_rule_based_response(self, question: str) -> str:
-        """Enhanced rule-based responses"""
-        question_lower = question.lower()
-        
-        if any(word in question_lower for word in ["spend", "cost", "money", "budget"]):
-            total_spend = self.po_data['order_value'].sum()
-            top_category = self.po_data.groupby('material_category')['order_value'].sum().idxmax()
-            monthly_avg = total_spend / 24
-            
-            return f"""🤖 **[Smart Analysis Engine]**
-
-💰 **Spend Analysis**
-• **Total spend**: €{total_spend:,.0f}
-• **Monthly average**: €{monthly_avg:,.0f}
-• **Top category**: {top_category}
-• **Order average**: €{self.po_data['order_value'].mean():,.0f}
-
-**Distribution**: Spend spans {len(self.po_data['material_category'].unique())} categories with {top_category} leading investment.
-
-*🚀 Connect OpenAI for advanced spend optimization strategies*"""
-        
-        elif any(word in question_lower for word in ["vendor", "supplier", "partner"]):
-            top_vendor = self.po_data.groupby('vendor')['order_value'].sum().idxmax()
-            vendor_count = len(self.po_data['vendor'].unique())
-            performance = self.po_data[self.po_data['vendor'] == top_vendor]['on_time_delivery'].mean() * 100
-            
-            return f"""🤖 **[Smart Analysis Engine]**
-
-🤝 **Vendor Portfolio**
-• **Active suppliers**: {vendor_count}
-• **Top partner**: {top_vendor}
-• **Performance**: {performance:.1f}% on-time delivery
-• **Portfolio health**: Well-diversified supply base
-
-**Strategic insight**: {top_vendor} represents your strongest partnership with excellent delivery performance.
-
-*🚀 Connect OpenAI for detailed vendor relationship strategies*"""
-        
-        else:
-            return f"""🤖 **[Smart Analysis Engine]**
-
-**Available Analysis:**
-• 💰 **Spending insights**: "What are my biggest costs?"
-• 🤝 **Vendor performance**: "How are my suppliers doing?"
-• ⚠️ **Risk assessment**: "What risks should I monitor?"
-• 📈 **Trend analysis**: "Show me spending patterns"
-
-**Current scope**: {len(self.po_data):,} orders • {len(self.po_data['vendor'].unique())} vendors • €{self.po_data['order_value'].sum():,.0f} total spend
-
-*🚀 Connect OpenAI for natural language conversations and advanced insights*"""
-    
-    def analyze_spend_patterns(self) -> Dict[str, Any]:
-        """Analyze spending patterns"""
-        total_spend = self.po_data['order_value'].sum()
-        avg_order_value = self.po_data['order_value'].mean()
-        
-        category_spend = self.po_data.groupby('material_category')['order_value'].sum().sort_values(ascending=False)
-        vendor_performance = self.po_data.groupby('vendor').agg({
-            'order_value': 'sum',
-            'on_time_delivery': 'mean',
-            'quality_score': 'mean'
-        }).round(2)
-        
-        return {
-            'total_spend': total_spend,
-            'avg_order_value': avg_order_value,
-            'top_categories': category_spend.to_dict(),
-            'vendor_performance': vendor_performance.to_dict('index')
-        }
+        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%?\""
+        )
+
 
-# Initialize session state and data
+# =============================
+# 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
 
-# Initialize AI agent
-analytics_agent = UniversalProcurementAgent(st.session_state.po_df, st.session_state.spend_df)
+@st.cache_resource(show_spinner=False)
+def get_llm_client() -> UniversalLLMClient:
+    return UniversalLLMClient(LLMConfig())
 
-# Get status
-status_info = analytics_agent.get_status_info()
-api_key_status = "🟢 Connected" if status_info['llm_available'] else "🔴 Not Connected"
+client = get_llm_client()
+agent = UniversalProcurementAgent(st.session_state.po_df, st.session_state.spend_df, client)
+analytics = ProcurementAnalytics(st.session_state.po_df)
 
-# Main header
-st.markdown(f"""
+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 Status: {api_key_status} | Data: {len(st.session_state.po_df):,} Purchase Orders</small>
+  <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)
+""",
+    unsafe_allow_html=True,
+)
 
-# Sidebar with status and navigation
+# =============================
+# Sidebar
+# =============================
 with st.sidebar:
     st.markdown("### 🤖 AI System Status")
-    st.markdown(f"**Connection:** {api_key_status}")
-    st.markdown(f"**Method:** {status_info.get('method', 'N/A')}")
-    
-    # Enhanced debug info
+    st.markdown(f"**Connection:** {api_status}")
+    st.markdown(f"**Provider:** {status['provider']}  ")
+    st.markdown(f"**Model:** {status['model']}")
+
     with st.expander("🔍 System Information"):
-        st.json(status_info)
-    
-    # Connection test
+        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"):
-        test_result = analytics_agent.test_llm_connection()
-        st.markdown(f"**Status:** {test_result['status']}")
-        st.markdown(f"**Details:** {test_result['details']}")
-        if 'recommendation' in test_result:
-            st.info(test_result['recommendation'])
-    
-    if not status_info['llm_available']:
-        st.markdown("""
-        <div class="alert alert-info">
-            <small><strong>💡 Enable AI Features</strong><br>
-            Add your OpenAI API key as OPENAI_API_KEY in Hugging Face Space secrets for advanced AI capabilities!</small>
-        </div>
-        """, unsafe_allow_html=True)
-    
+        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", "🎯 Recommendations"],
-        icons=['house', 'chat', 'graph-up', 'target'],
+        ["🏠 Dashboard", "💬 AI Chat", "📊 Analytics", "🧪 What‑If", "🎯 Recommendations"],
+        icons=['house', 'chat', 'bar-chart', 'beaker', 'target'],
         menu_icon="cast",
         default_index=0,
         styles={
@@ -526,186 +528,169 @@ with st.sidebar:
             "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 content sections
+# =============================
+# Main Views
+# =============================
 if selected == "🏠 Dashboard":
     st.markdown("### 🧠 AI Executive Summary")
-    
     with st.spinner('🤖 Analyzing procurement data...'):
-        executive_summary = analytics_agent.generate_executive_summary()
-    
+        summary = agent.executive_summary()
     st.markdown(f"""
     <div class="ai-insight">
         <h4>📊 Intelligent Analysis</h4>
-        <div style="white-space: pre-line; line-height: 1.6;">{executive_summary}</div>
+        <div style="white-space: pre-line; line-height: 1.55;">{summary}</div>
     </div>
     """, unsafe_allow_html=True)
-    
-    # Key metrics
-    insights = analytics_agent.analyze_spend_patterns()
-    
-    col1, col2, col3, col4 = st.columns(4)
-    
-    with col1:
-        st.markdown(f"""
-        <div class="metric-card">
-            <h3 style="color: var(--primary-color); margin: 0;">Total Spend</h3>
-            <h2 style="margin: 0.5rem 0;">€{insights['total_spend']:,.0f}</h2>
-            <p style="color: #28a745; margin: 0;">📈 Active Portfolio</p>
-        </div>
-        """, unsafe_allow_html=True)
-    
-    with col2:
-        st.markdown(f"""
-        <div class="metric-card">
-            <h3 style="color: var(--primary-color); margin: 0;">Avg Order Value</h3>
-            <h2 style="margin: 0.5rem 0;">€{insights['avg_order_value']:,.0f}</h2>
-            <p style="color: #17a2b8; margin: 0;">📊 Order Efficiency</p>
-        </div>
-        """, unsafe_allow_html=True)
-    
-    with col3:
-        active_vendors = len(st.session_state.po_df['vendor'].unique())
-        st.markdown(f"""
-        <div class="metric-card">
-            <h3 style="color: var(--primary-color); margin: 0;">Active Vendors</h3>
-            <h2 style="margin: 0.5rem 0;">{active_vendors}</h2>
-            <p style="color: #6f42c1; margin: 0;">🤝 Strategic Partners</p>
-        </div>
-        """, unsafe_allow_html=True)
-    
-    with col4:
-        on_time_delivery = st.session_state.po_df['on_time_delivery'].mean() * 100
-        st.markdown(f"""
-        <div class="metric-card">
-            <h3 style="color: var(--primary-color); margin: 0;">On-Time Delivery</h3>
-            <h2 style="margin: 0.5rem 0;">{on_time_delivery:.1f}%</h2>
-            <p style="color: #28a745; margin: 0;">⏰ Performance</p>
-        </div>
-        """, unsafe_allow_html=True)
-    
-    # Charts
+
+    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")
-    
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        category_spend = st.session_state.po_df.groupby('material_category')['order_value'].sum().reset_index()
-        fig_pie = px.pie(
-            category_spend, 
-            values='order_value', 
-            names='material_category',
-            title='Spend Distribution by Category'
-        )
-        fig_pie.update_layout(title_font_size=16, title_x=0.5, height=400)
-        st.plotly_chart(fig_pie, use_container_width=True)
-    
-    with col2:
-        vendor_spend = st.session_state.po_df.groupby('vendor')['order_value'].sum().reset_index()
-        vendor_spend = vendor_spend.nlargest(8, 'order_value')
-        
-        fig_bar = px.bar(
-            vendor_spend,
-            x='vendor',
-            y='order_value',
-            title='Top Vendors by Spend'
-        )
-        fig_bar.update_layout(title_font_size=16, title_x=0.5, xaxis_tickangle=45, height=400)
-        st.plotly_chart(fig_bar, use_container_width=True)
+    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 use direct API calls for maximum compatibility.</p>
-        <p><small>Status: {api_key_status} | Method: Universal Compatibility</small></p>
+        <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)
-    
-    # Chat interface
+
     if "messages" not in st.session_state:
         st.session_state.messages = [
-            {"role": "assistant", "content": "Hello! I'm your universal procurement analyst. I've loaded your data and I'm ready to help with any questions!"}
+            {"role": "assistant", "content": "Hello! I loaded your data and I'm ready to help—try asking about spend, vendors, or risk."}
         ]
-    
-    # Display chat messages
-    for message in st.session_state.messages:
-        with st.chat_message(message["role"]):
-            st.markdown(message["content"])
-    
-    # Chat input
-    if prompt := st.chat_input("Ask about your procurement data..."):
+
+    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..."):
-                response = analytics_agent.chat_with_data(prompt)
-            st.markdown(response)
-        
-        st.session_state.messages.append({"role": "assistant", "content": response})
-    
-    # Sample questions
-    st.markdown("#### 💡 Try these questions:")
-    col1, col2, col3 = st.columns(3)
-    
-    questions = [
-        "What are my biggest spending areas?",
-        "How are my vendors performing?", 
-        "What optimization opportunities exist?"
-    ]
-    
-    for i, (col, question) in enumerate(zip([col1, col2, col3], questions)):
-        with col:
-            if st.button(f"💭 {question}", key=f"q_{i}"):
-                st.session_state.messages.append({"role": "user", "content": question})
-                response = analytics_agent.chat_with_data(question)
-                st.session_state.messages.append({"role": "assistant", "content": response})
+            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")
-    
-    vendor_performance = st.session_state.po_df.groupby('vendor').agg({
-        'order_value': 'sum',
-        'on_time_delivery': 'mean',
-        'quality_score': 'mean',
-        'po_number': 'count'
-    }).round(2)
-    vendor_performance.columns = ['Total Spend (€)', 'On-Time Delivery', 'Quality Score', 'Order Count']
-    vendor_performance['On-Time Delivery'] = (vendor_performance['On-Time Delivery'] * 100).round(1)
-    
-    st.dataframe(vendor_performance.sort_values('Total Spend (€)', ascending=False), use_container_width=True)
+    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")
-    
-    recommendations = [
-        "🎯 **Vendor Consolidation**: Reduce supplier base for 12-18% cost reduction",
-        "⚡ **Process Automation**: Implement automated approval workflows",
-        "📊 **Performance Contracts**: Establish KPI-driven vendor agreements",
-        "🛡️ **Risk Monitoring**: Deploy real-time supplier assessment tools",
-        "🚀 **Digital Platform**: Upgrade to AI-powered procurement system"
+    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(recommendations, 1):
-        st.markdown(f"""
-        <div class="alert alert-success">
-            <h4>Recommendation #{i}</h4>
-            <p>{rec}</p>
-        </div>
-        """, unsafe_allow_html=True)
+    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,
+        )
 
+# =============================
 # Footer
+# =============================
 st.markdown("---")
-st.markdown(f"""
-<div style="text-align: center; padding: 1rem; color: #666;">
-    <p>🤖 <strong>Universal AI Procurement Analytics</strong> | Built with Direct API Integration</p>
-    <p><em>Demo with synthetic data • {len(st.session_state.po_df):,} orders • OpenAI {api_key_status}</em></p>
+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)
+""",
+    unsafe_allow_html=True,
+)