Update src/streamlit_app.py

src/streamlit_app.py

@@ -23,7 +23,6 @@ st.set_page_config(
 # Custom CSS (same as before)
 st.markdown("""
 <style>
-    /* Main theme colors */
     :root {
         --primary-color: #0066cc;
         --secondary-color: #f0f8ff;
@@ -33,12 +32,10 @@ st.markdown("""
         --danger-color: #dc3545;
     }
     
-    /* Hide Streamlit branding */
     #MainMenu {visibility: hidden;}
     footer {visibility: hidden;}
     header {visibility: hidden;}
     
-    /* Custom header styling */
     .main-header {
         background: linear-gradient(90deg, #0066cc, #004c99);
         padding: 1rem;
@@ -48,7 +45,6 @@ st.markdown("""
         text-align: center;
     }
     
-    /* Metric cards styling */
     .metric-card {
         background: white;
         padding: 1.5rem;
@@ -58,7 +54,6 @@ st.markdown("""
         margin-bottom: 1rem;
     }
     
-    /* AI insights styling */
     .ai-insight {
         background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
         color: white;
@@ -67,7 +62,6 @@ st.markdown("""
         margin: 1rem 0;
     }
     
-    /* Alert styling */
     .alert {
         padding: 1rem;
         border-radius: 8px;
@@ -93,7 +87,6 @@ st.markdown("""
         color: #0c5460;
     }
     
-    /* Button styling */
     .stButton > button {
         background: linear-gradient(90deg, #0066cc, #004c99);
         color: white;
@@ -111,50 +104,58 @@ st.markdown("""
 </style>
 """, unsafe_allow_html=True)
 
-# Function to safely get OpenAI API key
-# Function to safely get OpenAI API key (UPDATED)
+# Safe OpenAI integration that works with ANY version
 def get_openai_api_key():
-    """Safely retrieve OpenAI API key from various sources"""
-    api_key = None
-    
-    # Method 1: Try from environment variables first (for HF Spaces)
-    api_key = os.getenv('OPENAI_API_KEY')
-    
-    # Method 2: Try alternative environment variable names
-    if not api_key:
-        api_key = os.getenv('OPENAI_API_TOKEN')
+    """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')
+    )
+
+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"""
     
-    # Method 3: Try from Streamlit secrets (only if secrets exist)
-    if not api_key:
-        try:
-            # Check if secrets file exists before accessing
-            import streamlit as st
-            if hasattr(st, 'secrets') and st.secrets:
-                if 'OPENAI_API_KEY' in st.secrets:
-                    api_key = st.secrets["OPENAI_API_KEY"]
-        except (FileNotFoundError, Exception):
-            # Silently continue if secrets file doesn't exist
-            pass
-    
-    return api_key
-
-# Function to safely initialize OpenAI client
-def create_openai_client(api_key):
-    """Safely create OpenAI client with proper error handling"""
     if not api_key:
         return None, "No API key available"
     
     try:
-        import openai
-        # Try creating client with minimal parameters
-        client = openai.OpenAI(api_key=api_key)
-        # Test the client with a simple call
-        client.models.list()
-        return client, "Connected successfully"
-    except ImportError:
-        return None, "OpenAI package not installed"
+        # Try using requests directly (most reliable method)
+        import requests
+        
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "model": model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": 0.7
+        }
+        
+        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"Connection failed: {str(e)}"
+        return None, f"Request failed: {str(e)}"
 
 # Data generation function
 @st.cache_data
@@ -213,180 +214,189 @@ def generate_synthetic_procurement_data():
     
     return pd.DataFrame(purchase_orders), pd.DataFrame(spend_data)
 
-# AI Agent Class with improved error handling
-class LLMPoweredProcurementAgent:
-    """AI Agent with robust OpenAI integration and fallback capabilities"""
+# 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
-        
-        # Initialize OpenAI client safely
         self.api_key = get_openai_api_key()
-        self.client, self.connection_status = create_openai_client(self.api_key)
-        self.llm_available = self.client is not None
+        self.llm_available = bool(self.api_key)
         
-        # Store connection details for debugging
-        self.debug_info = {
+        # 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
+        )
+        
+        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"""
+        return {
             "api_key_available": bool(self.api_key),
             "api_key_length": len(self.api_key) if self.api_key else 0,
-            "connection_status": self.connection_status,
-            "llm_available": self.llm_available
+            "llm_available": self.llm_available,
+            "connection_status": getattr(self, 'connection_error', 'Not tested'),
+            "method": "Direct API calls (version-agnostic)"
         }
     
-    def get_status_info(self) -> Dict[str, Any]:
-        """Get detailed status information for debugging"""
-        return self.debug_info
-    
     def test_llm_connection(self) -> Dict[str, Any]:
         """Test LLM connection with detailed status"""
-        if not self.llm_available:
+        if not self.api_key:
             return {
-                "status": "❌ Disconnected",
-                "details": self.connection_status,
-                "recommendation": "Add OPENAI_API_KEY to your Hugging Face Space secrets"
+                "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"
             }
         
-        try:
-            # Test with minimal API call
-            response = self.client.chat.completions.create(
-                model="gpt-3.5-turbo",
-                messages=[{"role": "user", "content": "Test"}],
-                max_tokens=5
-            )
+        response, status = safe_openai_chat(
+            self.api_key,
+            [{"role": "user", "content": "Test connection"}],
+            max_tokens=10
+        )
+        
+        if response:
             return {
                 "status": "✅ Connected",
                 "details": "OpenAI API responding normally",
-                "model": "gpt-3.5-turbo"
+                "method": "Direct API calls (universal compatibility)"
             }
-        except Exception as e:
+        else:
             return {
-                "status": "⚠️ Error",
-                "details": f"API call failed: {str(e)}",
-                "recommendation": "Check API key validity"
+                "status": "⚠️ Connection Failed",
+                "details": status,
+                "recommendation": "Check API key validity or try regenerating it"
             }
     
     def generate_executive_summary(self) -> str:
-        """Generate executive summary with clear status indicators"""
+        """Generate executive summary with AI or fallback"""
         
         if not self.llm_available:
-            # 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]**
-
-**🎯 Executive Summary - Procurement Performance Dashboard**
-
-📊 **Current Portfolio Overview**
-• Total procurement spend: €{total_spend:,.0f} across {total_orders:,} purchase orders
-• Active vendor network: {len(self.po_data['vendor'].unique())} strategic suppliers
-• Average order value: €{self.po_data['order_value'].mean():,.0f}
-
-🏆 **Performance Highlights**
-• On-time delivery performance: {on_time_rate:.1f}% (Industry benchmark: 85%)
-• Average supplier quality score: {quality_avg:.1f}/10
-• Leading spend category: {top_category}
-• Top strategic partner: {top_vendor}
-
-⚡ **Strategic Opportunities**
-• Vendor consolidation potential identified in {len(self.po_data['vendor'].unique())} supplier base
-• Contract optimization opportunities with top-tier vendors
-• Digital procurement automation possibilities for routine purchases
-
-💡 **AI-Powered Recommendations**
-• Implement strategic sourcing for {top_category} category
-• Develop performance-based contracts with high-performing suppliers
-• Establish automated approval workflows for orders under €10,000
-
-*🔧 Status: Using intelligent rule-based analysis. {self.connection_status}*"""
+            return self._generate_rule_based_summary()
         
-        # LLM-powered summary
+        # Prepare data for AI analysis
         data_summary = {
             "total_spend": float(self.po_data['order_value'].sum()),
             "total_orders": len(self.po_data),
-            "unique_vendors": len(self.po_data['vendor'].unique()),
+            "vendor_count": len(self.po_data['vendor'].unique()),
             "avg_order_value": float(self.po_data['order_value'].mean()),
-            "on_time_delivery_rate": float(self.po_data['on_time_delivery'].mean()),
-            "quality_score_avg": float(self.po_data['quality_score'].mean())
+            "on_time_delivery": float(self.po_data['on_time_delivery'].mean()),
+            "avg_quality": float(self.po_data['quality_score'].mean())
         }
         
-        prompt = f"""
-        As a senior procurement analyst, provide an executive summary based on this data:
-        {json.dumps(data_summary, indent=2)}
-        
-        Include:
-        1. Executive overview (2-3 sentences)
-        2. Key performance highlights
-        3. Areas needing attention
-        4. Strategic recommendations (3-4 actionable items)
+        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."""
+            }
+        ]
         
-        Keep it professional and actionable for executives.
-        """
+        ai_response, status = safe_openai_chat(self.api_key, messages, max_tokens=600)
         
-        try:
-            response = self.client.chat.completions.create(
-                model="gpt-3.5-turbo",
-                messages=[
-                    {"role": "system", "content": "You are a senior procurement analyst with SAP S/4HANA expertise."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=600,
-                temperature=0.7
-            )
-            
-            ai_response = response.choices[0].message.content
+        if ai_response:
             return f"🧠 **[AI-Powered Analysis - OpenAI GPT]**\n\n{ai_response}"
-            
-        except Exception as e:
-            fallback = self.generate_executive_summary()  # Recursive call will use rule-based
-            return f"⚠️ **[AI Temporarily Unavailable - Using Smart Fallback]**\n\n{fallback}\n\n*Error: {str(e)}*"
+        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:
-        """Enhanced chat with clear response type indicators"""
+        """Chat interface with universal compatibility"""
         
         if not self.llm_available:
             return self._get_rule_based_response(user_question)
         
-        try:
-            data_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())
+        # Prepare context for AI
+        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())
+        }
+        
+        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."
             }
-            
-            prompt = f"""
-            User Question: {user_question}
-            Procurement Data: {json.dumps(data_context, indent=2)}
-            
-            Answer professionally with specific metrics where relevant.
-            """
-            
-            response = self.client.chat.completions.create(
-                model="gpt-3.5-turbo",
-                messages=[
-                    {"role": "system", "content": "You are an expert procurement analyst assistant."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=400,
-                temperature=0.7
-            )
-            
-            ai_response = response.choices[0].message.content
-            return f"🧠 **[AI Response]**\n\n{ai_response}"
-            
-        except Exception as e:
-            fallback_response = self._get_rule_based_response(user_question)
-            return f"⚠️ **[Smart Fallback]** AI temporarily unavailable\n\n{fallback_response}\n\n*Error details: {str(e)}*"
+        ]
+        
+        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 with detailed analysis"""
+        """Enhanced rule-based responses"""
         question_lower = question.lower()
         
         if any(word in question_lower for word in ["spend", "cost", "money", "budget"]):
@@ -394,44 +404,47 @@ class LLMPoweredProcurementAgent:
             top_category = self.po_data.groupby('material_category')['order_value'].sum().idxmax()
             monthly_avg = total_spend / 24
             
-            return f"""🤖 **[Rule-Based Analysis]**
+            return f"""🤖 **[Smart Analysis Engine]**
 
-💰 **Spend Analysis:**
-• **Total procurement spend**: €{total_spend:,.0f}
+💰 **Spend Analysis**
+• **Total spend**: €{total_spend:,.0f}
 • **Monthly average**: €{monthly_avg:,.0f}
-• **Largest spend category**: {top_category} 
-• **Average order size**: €{self.po_data['order_value'].mean():,.0f}
+• **Top category**: {top_category}
+• **Order average**: €{self.po_data['order_value'].mean():,.0f}
 
-The spending is distributed across {len(self.po_data['material_category'].unique())} categories with {top_category} representing the highest investment area.
+**Distribution**: Spend spans {len(self.po_data['material_category'].unique())} categories with {top_category} leading investment.
 
-*💡 Connect OpenAI for advanced AI analysis!*"""
+*🚀 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())
-            top_vendor_performance = self.po_data[self.po_data['vendor'] == top_vendor]['on_time_delivery'].mean() * 100
+            performance = self.po_data[self.po_data['vendor'] == top_vendor]['on_time_delivery'].mean() * 100
             
-            return f"""🤖 **[Rule-Based Analysis]**
+            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
 
-🤝 **Vendor Analysis:**
-• **Total active vendors**: {vendor_count}
-• **Top strategic partner**: {top_vendor}
-• **{top_vendor} performance**: {top_vendor_performance:.1f}% on-time delivery
-• **Vendor diversity**: Well-distributed across multiple suppliers
+**Strategic insight**: {top_vendor} represents your strongest partnership with excellent delivery performance.
 
-*💡 Connect OpenAI for detailed vendor insights!*"""
+*🚀 Connect OpenAI for detailed vendor relationship strategies*"""
         
         else:
-            return f"""🤖 **[Rule-Based Analysis]**
+            return f"""🤖 **[Smart Analysis Engine]**
 
-I can analyze your procurement data! Try asking about:
-• 💰 **Spending patterns**: "What are my biggest costs?"
+**Available Analysis:**
+• 💰 **Spending insights**: "What are my biggest costs?"
 • 🤝 **Vendor performance**: "How are my suppliers doing?"
-• ⚠️ **Risk factors**: "What should I worry about?"
+• ⚠️ **Risk assessment**: "What risks should I monitor?"
+• 📈 **Trend analysis**: "Show me spending patterns"
 
-**Current data**: {len(self.po_data):,} orders across {len(self.po_data['vendor'].unique())} vendors
+**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 API for natural language conversations!*"""
+*🚀 Connect OpenAI for natural language conversations and advanced insights*"""
     
     def analyze_spend_patterns(self) -> Dict[str, Any]:
         """Analyze spending patterns"""
@@ -458,15 +471,10 @@ if 'data_loaded' not in st.session_state:
         st.session_state.po_df, st.session_state.spend_df = generate_synthetic_procurement_data()
         st.session_state.data_loaded = True
 
-# Initialize AI agents with safe caching
-def initialize_agents():
-    """Initialize agents without caching to avoid errors"""
-    analytics_agent = LLMPoweredProcurementAgent(st.session_state.po_df, st.session_state.spend_df)
-    return analytics_agent
+# Initialize AI agent
+analytics_agent = UniversalProcurementAgent(st.session_state.po_df, st.session_state.spend_df)
 
-analytics_agent = initialize_agents()
-
-# Get connection status
+# Get status
 status_info = analytics_agent.get_status_info()
 api_key_status = "🟢 Connected" if status_info['llm_available'] else "🔴 Not Connected"
 
@@ -479,16 +487,17 @@ st.markdown(f"""
 </div>
 """, unsafe_allow_html=True)
 
-# Sidebar with enhanced status
+# Sidebar with status and navigation
 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')}")
     
-    # Debug information
-    with st.expander("🔍 Debug Information"):
+    # Enhanced debug info
+    with st.expander("🔍 System Information"):
         st.json(status_info)
     
-    # Connection test button
+    # Connection test
     if st.button("🔄 Test AI Connection"):
         test_result = analytics_agent.test_llm_connection()
         st.markdown(f"**Status:** {test_result['status']}")
@@ -500,7 +509,7 @@ with st.sidebar:
         st.markdown("""
         <div class="alert alert-info">
             <small><strong>💡 Enable AI Features</strong><br>
-            Add OPENAI_API_KEY to your Hugging Face Space settings for enhanced AI capabilities!</small>
+            Add your OpenAI API key as OPENAI_API_KEY in Hugging Face Space secrets for advanced AI capabilities!</small>
         </div>
         """, unsafe_allow_html=True)
     
@@ -520,7 +529,7 @@ with st.sidebar:
         }
     )
 
-# Dashboard section
+# Main content sections
 if selected == "🏠 Dashboard":
     st.markdown("### 🧠 AI Executive Summary")
     
@@ -540,42 +549,42 @@ if selected == "🏠 Dashboard":
     col1, col2, col3, col4 = st.columns(4)
     
     with col1:
-        st.markdown("""
+        st.markdown(f"""
         <div class="metric-card">
             <h3 style="color: var(--primary-color); margin: 0;">Total Spend</h3>
-            <h2 style="margin: 0.5rem 0;">€{:,.0f}</h2>
+            <h2 style="margin: 0.5rem 0;">€{insights['total_spend']:,.0f}</h2>
             <p style="color: #28a745; margin: 0;">📈 Active Portfolio</p>
         </div>
-        """.format(insights['total_spend']), unsafe_allow_html=True)
+        """, unsafe_allow_html=True)
     
     with col2:
-        st.markdown("""
+        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;">€{:,.0f}</h2>
+            <h2 style="margin: 0.5rem 0;">€{insights['avg_order_value']:,.0f}</h2>
             <p style="color: #17a2b8; margin: 0;">📊 Order Efficiency</p>
         </div>
-        """.format(insights['avg_order_value']), unsafe_allow_html=True)
+        """, unsafe_allow_html=True)
     
     with col3:
         active_vendors = len(st.session_state.po_df['vendor'].unique())
-        st.markdown("""
+        st.markdown(f"""
         <div class="metric-card">
             <h3 style="color: var(--primary-color); margin: 0;">Active Vendors</h3>
-            <h2 style="margin: 0.5rem 0;">{}</h2>
+            <h2 style="margin: 0.5rem 0;">{active_vendors}</h2>
             <p style="color: #6f42c1; margin: 0;">🤝 Strategic Partners</p>
         </div>
-        """.format(active_vendors), unsafe_allow_html=True)
+        """, unsafe_allow_html=True)
     
     with col4:
         on_time_delivery = st.session_state.po_df['on_time_delivery'].mean() * 100
-        st.markdown("""
+        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;">{:.1f}%</h2>
+            <h2 style="margin: 0.5rem 0;">{on_time_delivery:.1f}%</h2>
             <p style="color: #28a745; margin: 0;">⏰ Performance</p>
         </div>
-        """.format(on_time_delivery), unsafe_allow_html=True)
+        """, unsafe_allow_html=True)
     
     # Charts
     st.markdown("### 📊 Executive Dashboard")
@@ -588,8 +597,7 @@ if selected == "🏠 Dashboard":
             category_spend, 
             values='order_value', 
             names='material_category',
-            title='Spend Distribution by Category',
-            color_discrete_sequence=px.colors.qualitative.Set3
+            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)
@@ -602,9 +610,7 @@ if selected == "🏠 Dashboard":
             vendor_spend,
             x='vendor',
             y='order_value',
-            title='Top Vendors by Spend',
-            color='order_value',
-            color_continuous_scale='Blues'
+            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)
@@ -614,16 +620,16 @@ elif selected == "💬 AI Chat":
     
     st.markdown(f"""
     <div class="ai-insight">
-        <h4>🤖 Intelligent Procurement Assistant</h4>
-        <p>Ask me anything about your procurement data! I can analyze trends, vendor performance, and provide strategic recommendations.</p>
-        <p><small>Status: {api_key_status} | Response Mode: {'AI-Powered' if status_info['llm_available'] else 'Rule-Based Analysis'}</small></p>
+        <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>
     </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 procurement analyst. I've loaded your data and I'm ready to help! What would you like to explore?"}
+            {"role": "assistant", "content": "Hello! I'm your universal procurement analyst. I've loaded your data and I'm ready to help with any questions!"}
         ]
     
     # Display chat messages
@@ -680,10 +686,10 @@ elif selected == "🎯 Recommendations":
     st.markdown("### 🚀 Strategic Recommendations")
     
     recommendations = [
-        "🎯 **Vendor Consolidation**: Reduce supplier base from 10 to 6-7 strategic partners for 12-18% cost reduction",
-        "⚡ **Process Automation**: Implement automated approval for orders under €5,000 to save 40+ hours weekly",
-        "📊 **Performance Contracts**: Establish KPI-driven agreements with top vendors",
-        "🛡️ **Risk Monitoring**: Deploy real-time supplier risk assessment tools",
+        "🎯 **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"
     ]
     
@@ -699,7 +705,7 @@ elif selected == "🎯 Recommendations":
 st.markdown("---")
 st.markdown(f"""
 <div style="text-align: center; padding: 1rem; color: #666;">
-    <p>🤖 <strong>Agentic AI Procurement Analytics</strong> | Built with Streamlit & Python</p>
+    <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>
 </div>
 """, unsafe_allow_html=True)