Update src/streamlit_app.py

src/streamlit_app.py

@@ -20,7 +20,7 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# Custom CSS
+# Custom CSS (same as before)
 st.markdown("""
 <style>
     /* Main theme colors */
@@ -129,31 +129,46 @@ def get_openai_api_key():
     
     # Method 3: Try from Hugging Face Spaces environment
     if not api_key:
-        api_key = os.getenv('OPENAI_API_TOKEN')  # Sometimes HF uses this
+        api_key = os.getenv('OPENAI_API_TOKEN')
     
     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"
+    except Exception as e:
+        return None, f"Connection failed: {str(e)}"
+
 # Data generation function
 @st.cache_data
 def generate_synthetic_procurement_data():
     """Generate synthetic SAP S/4HANA procurement data"""
     fake = Faker()
-    np.random.seed(42)  # For reproducible data
+    np.random.seed(42)
     random.seed(42)
     
-    # Vendors data
     vendors = [
         "Siemens AG", "BASF SE", "BMW Group", "Mercedes-Benz", "Bosch GmbH",
         "ThyssenKrupp", "Bayer AG", "Continental AG", "Henkel AG", "SAP SE"
     ]
     
-    # Material categories
     material_categories = [
         "Raw Materials", "Components", "Packaging", "Services", 
         "IT Equipment", "Office Supplies", "Machinery", "Chemicals"
     ]
     
-    # Generate purchase orders
     purchase_orders = []
     for i in range(500):
         order_date = fake.date_between(start_date='-2y', end_date='today')
@@ -178,7 +193,6 @@ def generate_synthetic_procurement_data():
         }
         purchase_orders.append(po)
     
-    # Generate spend analytics data
     spend_data = []
     for vendor in vendors:
         for category in material_categories:
@@ -194,33 +208,64 @@ def generate_synthetic_procurement_data():
     
     return pd.DataFrame(purchase_orders), pd.DataFrame(spend_data)
 
-# AI Agent Classes
+# AI Agent Class with improved error handling
 class LLMPoweredProcurementAgent:
-    """AI Agent powered by OpenAI GPT for intelligent procurement analysis"""
+    """AI Agent with robust OpenAI integration and fallback capabilities"""
     
     def __init__(self, po_data: pd.DataFrame, spend_data: pd.DataFrame):
         self.po_data = po_data
         self.spend_data = spend_data
         
-        # Safely get OpenAI API key
+        # Initialize OpenAI client safely
         self.api_key = get_openai_api_key()
-        self.llm_available = bool(self.api_key)
+        self.client, self.connection_status = create_openai_client(self.api_key)
+        self.llm_available = self.client is not None
         
-        if self.llm_available:
-            try:
-                import openai
-                self.client = openai.OpenAI(api_key=self.api_key)
-            except ImportError:
-                self.llm_available = False
-                self.client = None
-        else:
-            self.client = None
+        # Store connection details for debugging
+        self.debug_info = {
+            "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
+        }
+    
+    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:
+            return {
+                "status": "❌ Disconnected",
+                "details": self.connection_status,
+                "recommendation": "Add OPENAI_API_KEY to your Hugging Face Space secrets"
+            }
+        
+        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
+            )
+            return {
+                "status": "✅ Connected",
+                "details": "OpenAI API responding normally",
+                "model": "gpt-3.5-turbo"
+            }
+        except Exception as e:
+            return {
+                "status": "⚠️ Error",
+                "details": f"API call failed: {str(e)}",
+                "recommendation": "Check API key validity"
+            }
     
     def generate_executive_summary(self) -> str:
-        """Generate an executive summary using GPT or fallback"""
+        """Generate executive summary with clear status indicators"""
         
         if not self.llm_available:
-            # Enhanced rule-based summary if no API key
+            # 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
@@ -228,7 +273,9 @@ class LLMPoweredProcurementAgent:
             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"""**🎯 Executive Summary - Procurement Performance Dashboard**
+            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
@@ -251,61 +298,100 @@ class LLMPoweredProcurementAgent:
 • Develop performance-based contracts with high-performing suppliers
 • Establish automated approval workflows for orders under €10,000
 
-*🔧 Note: Connect OpenAI API for advanced AI insights and natural language analysis*"""
+*🔧 Status: Using intelligent rule-based analysis. {self.connection_status}*"""
         
-        # Prepare data summary for LLM
+        # LLM-powered summary
         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()),
             "avg_order_value": float(self.po_data['order_value'].mean()),
             "on_time_delivery_rate": float(self.po_data['on_time_delivery'].mean()),
-            "top_vendors": self.po_data.groupby('vendor')['order_value'].sum().nlargest(3).to_dict(),
-            "top_categories": self.po_data.groupby('material_category')['order_value'].sum().nlargest(3).to_dict(),
             "quality_score_avg": float(self.po_data['quality_score'].mean())
         }
         
         prompt = f"""
-        As a senior procurement analyst with expertise in SAP S/4HANA systems, provide an executive summary of procurement performance:
-        
-        Data: {json.dumps(data_summary, indent=2)}
+        As a senior procurement analyst, provide an executive summary based on this data:
+        {json.dumps(data_summary, indent=2)}
         
-        Provide:
+        Include:
         1. Executive overview (2-3 sentences)
-        2. Key performance highlights with specific metrics
-        3. Critical areas needing attention
+        2. Key performance highlights
+        3. Areas needing attention
         4. Strategic recommendations (3-4 actionable items)
         
-        Keep it professional, metrics-focused, and actionable for C-level executives.
+        Keep it professional and actionable for executives.
         """
         
         try:
             response = self.client.chat.completions.create(
-                model="gpt-4",
+                model="gpt-3.5-turbo",
                 messages=[
-                    {"role": "system", "content": "You are a senior procurement analyst with 15+ years of SAP S/4HANA experience."},
+                    {"role": "system", "content": "You are a senior procurement analyst with SAP S/4HANA expertise."},
                     {"role": "user", "content": prompt}
                 ],
                 max_tokens=600,
                 temperature=0.7
             )
-            return response.choices[0].message.content
+            
+            ai_response = response.choices[0].message.content
+            return f"🧠 **[AI-Powered Analysis - OpenAI GPT]**\n\n{ai_response}"
+            
         except Exception as e:
-            return f"🤖 AI Analysis temporarily unavailable. Using rule-based insights instead.\n\n{self.generate_executive_summary()}"
+            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)}*"
     
     def chat_with_data(self, user_question: str) -> str:
-        """Natural language interface to query procurement data"""
+        """Enhanced chat with clear response type indicators"""
         
         if not self.llm_available:
-            # Enhanced rule-based responses
-            question_lower = user_question.lower()
+            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())
+            }
+            
+            prompt = f"""
+            User Question: {user_question}
+            Procurement Data: {json.dumps(data_context, indent=2)}
+            
+            Answer professionally with specific metrics where relevant.
+            """
             
-            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  # Assuming 2 years of data
-                return f"""💰 **Spend Analysis:**
+            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)}*"
+    
+    def _get_rule_based_response(self, question: str) -> str:
+        """Enhanced rule-based responses with detailed analysis"""
+        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"""🤖 **[Rule-Based Analysis]**
 
+💰 **Spend Analysis:**
 • **Total procurement spend**: €{total_spend:,.0f}
 • **Monthly average**: €{monthly_avg:,.0f}
 • **Largest spend category**: {top_category} 
@@ -313,114 +399,41 @@ class LLMPoweredProcurementAgent:
 
 The spending is distributed across {len(self.po_data['material_category'].unique())} categories with {top_category} representing the highest investment area.
 
-*💡 Connect OpenAI API for detailed spend optimization strategies!*"""
+*💡 Connect OpenAI for advanced AI analysis!*"""
+        
+        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
             
-            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
-                return f"""🤝 **Vendor Analysis:**
+            return f"""🤖 **[Rule-Based Analysis]**
 
+🤝 **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
 
-Your vendor portfolio shows good diversification with {top_vendor} as the leading partner.
-
-*💡 Connect OpenAI API for detailed vendor relationship strategies!*"""
-            
-            elif any(word in question_lower for word in ["risk", "compliance", "quality"]):
-                avg_quality = self.po_data['quality_score'].mean()
-                on_time_rate = self.po_data['on_time_delivery'].mean() * 100
-                return f"""⚠️ **Risk & Quality Analysis:**
-
-• **Average quality score**: {avg_quality:.1f}/10 
-• **On-time delivery rate**: {on_time_rate:.1f}%
-• **Performance status**: {'Excellent' if avg_quality > 8.5 else 'Good' if avg_quality > 7.5 else 'Needs Improvement'}
-
-Overall risk profile appears {'low' if on_time_rate > 85 else 'moderate'} based on delivery performance metrics.
-
-*💡 Connect OpenAI API for comprehensive risk assessment!*"""
-            
-            elif any(word in question_lower for word in ["trend", "pattern", "analysis"]):
-                return f"""📈 **Trend Analysis:**
-
-• **Data period**: {self.po_data['order_date'].min()} to {self.po_data['order_date'].max()}
-• **Total orders processed**: {len(self.po_data):,}
-• **Peak category**: {self.po_data.groupby('material_category')['order_value'].sum().idxmax()}
-• **Seasonal patterns**: Data shows consistent procurement activity
-
-Historical data indicates stable procurement operations with opportunities for optimization.
-
-*💡 Connect OpenAI API for advanced trend forecasting!*"""
-            
-            else:
-                return f"""🤖 **Procurement Assistant Ready!**
-
-I can help you analyze:
-• 💰 **Spending patterns** and budget optimization
-• 🤝 **Vendor performance** and relationship management  
-• ⚠️ **Risk assessment** and quality metrics
-• 📈 **Trends and forecasting** for strategic planning
-
-**Current data scope**: {len(self.po_data):,} orders across {len(self.po_data['vendor'].unique())} vendors
+*💡 Connect OpenAI for detailed vendor insights!*"""
+        
+        else:
+            return f"""🤖 **[Rule-Based Analysis]**
 
-Try asking: "What are my biggest spending areas?" or "How are my vendors performing?"
+I can analyze your procurement data! Try asking about:
+• 💰 **Spending patterns**: "What are my biggest costs?"
+• 🤝 **Vendor performance**: "How are my suppliers doing?"
+• ⚠️ **Risk factors**: "What should I worry about?"
 
-*💡 Connect OpenAI API for natural language conversations and advanced insights!*"""
-        
-        # LLM-powered response
-        data_context = {
-            "procurement_summary": {
-                "total_spend": float(self.po_data['order_value'].sum()),
-                "order_count": len(self.po_data),
-                "vendor_count": len(self.po_data['vendor'].unique()),
-                "date_range": f"{self.po_data['order_date'].min()} to {self.po_data['order_date'].max()}",
-                "categories": self.po_data['material_category'].unique().tolist(),
-                "vendors": self.po_data['vendor'].unique().tolist()
-            },
-            "performance_metrics": {
-                "avg_quality_score": float(self.po_data['quality_score'].mean()),
-                "on_time_delivery_rate": float(self.po_data['on_time_delivery'].mean()),
-                "avg_order_value": float(self.po_data['order_value'].mean())
-            }
-        }
-        
-        prompt = f"""
-        User Question: {user_question}
-        
-        Procurement Data Context:
-        {json.dumps(data_context, indent=2)}
-        
-        Answer the user's question based on the procurement data. Be conversational yet professional. 
-        Include specific metrics when relevant and relate findings to business impact.
-        If you need additional data not available in the context, suggest what analysis would be helpful.
-        """
-        
-        try:
-            response = self.client.chat.completions.create(
-                model="gpt-4",
-                messages=[
-                    {"role": "system", "content": "You are an expert procurement analyst assistant. Provide helpful, professional responses about procurement data and strategy."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=500,
-                temperature=0.7
-            )
-            return response.choices[0].message.content
-        except Exception as e:
-            return f"I'm having trouble accessing advanced AI right now. Here's what I can tell you based on the data:\n\n{self.chat_with_data(user_question)}"
+**Current data**: {len(self.po_data):,} orders across {len(self.po_data['vendor'].unique())} vendors
 
+*💡 Connect OpenAI API for natural language conversations!*"""
+    
     def analyze_spend_patterns(self) -> Dict[str, Any]:
-        """Analyze spending patterns and generate insights"""
+        """Analyze spending patterns"""
         total_spend = self.po_data['order_value'].sum()
         avg_order_value = self.po_data['order_value'].mean()
         
-        # Top spending categories
         category_spend = self.po_data.groupby('material_category')['order_value'].sum().sort_values(ascending=False)
-        
-        # Vendor performance analysis
         vendor_performance = self.po_data.groupby('vendor').agg({
             'order_value': 'sum',
             'on_time_delivery': 'mean',
@@ -440,17 +453,17 @@ 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
-@st.cache_resource
+# 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
 
 analytics_agent = initialize_agents()
 
-# API Key status check
-api_key = get_openai_api_key()
-api_key_status = "🟢 Connected" if api_key else "🔴 Not Connected"
+# Get connection status
+status_info = analytics_agent.get_status_info()
+api_key_status = "🟢 Connected" if status_info['llm_available'] else "🔴 Not Connected"
 
 # Main header
 st.markdown(f"""
@@ -461,16 +474,28 @@ st.markdown(f"""
 </div>
 """, unsafe_allow_html=True)
 
-# Sidebar navigation
+# Sidebar with enhanced status
 with st.sidebar:
-    st.markdown("### 🤖 AI-Powered Analytics")
-    st.markdown(f"**OpenAI Status:** {api_key_status}")
-    
-    if not api_key:
+    st.markdown("### 🤖 AI System Status")
+    st.markdown(f"**Connection:** {api_key_status}")
+    
+    # Debug information
+    with st.expander("🔍 Debug Information"):
+        st.json(status_info)
+    
+    # Connection test button
+    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>💡 Enhanced AI Features</strong><br>
-            Add OpenAI API key as OPENAI_API_KEY in your Hugging Face Space settings for advanced AI conversations and insights!</small>
+            <small><strong>💡 Enable AI Features</strong><br>
+            Add OPENAI_API_KEY to your Hugging Face Space settings for enhanced AI capabilities!</small>
         </div>
         """, unsafe_allow_html=True)
     
@@ -489,18 +514,12 @@ with st.sidebar:
             "nav-link-selected": {"background-color": "#0066cc"},
         }
     )
-    
-    st.markdown("---")
-    st.markdown("### 📊 Quick Stats")
-    st.metric("Total Orders", f"{len(st.session_state.po_df):,}")
-    st.metric("Active Vendors", f"{len(st.session_state.po_df['vendor'].unique())}")
-    st.metric("Categories", f"{len(st.session_state.po_df['material_category'].unique())}")
 
+# Dashboard section
 if selected == "🏠 Dashboard":
-    # AI-generated insights at the top
     st.markdown("### 🧠 AI Executive Summary")
     
-    with st.spinner('🤖 AI analyzing procurement data...'):
+    with st.spinner('🤖 Analyzing procurement data...'):
         executive_summary = analytics_agent.generate_executive_summary()
     
     st.markdown(f"""
@@ -559,7 +578,6 @@ if selected == "🏠 Dashboard":
     col1, col2 = st.columns(2)
     
     with col1:
-        # Spend by category
         category_spend = st.session_state.po_df.groupby('material_category')['order_value'].sum().reset_index()
         fig_pie = px.pie(
             category_spend, 
@@ -568,16 +586,10 @@ if selected == "🏠 Dashboard":
             title='Spend Distribution by Category',
             color_discrete_sequence=px.colors.qualitative.Set3
         )
-        fig_pie.update_layout(
-            title_font_size=16,
-            title_x=0.5,
-            showlegend=True,
-            height=400
-        )
+        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:
-        # Top vendors
         vendor_spend = st.session_state.po_df.groupby('vendor')['order_value'].sum().reset_index()
         vendor_spend = vendor_spend.nlargest(8, 'order_value')
         
@@ -589,12 +601,7 @@ if selected == "🏠 Dashboard":
             color='order_value',
             color_continuous_scale='Blues'
         )
-        fig_bar.update_layout(
-            title_font_size=16,
-            title_x=0.5,
-            xaxis_tickangle=45,
-            height=400
-        )
+        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)
 
 elif selected == "💬 AI Chat":
@@ -603,15 +610,15 @@ 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, spending patterns, and provide strategic recommendations.</p>
-        <p><small>Status: {api_key_status}</small></p>
+        <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>
     </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 AI procurement analyst. I've analyzed your procurement portfolio and I'm ready to help! What would you like to explore?"}
+            {"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?"}
         ]
     
     # Display chat messages
@@ -621,220 +628,73 @@ elif selected == "💬 AI Chat":
     
     # Chat input
     if prompt := st.chat_input("Ask about your procurement data..."):
-        # Add user message to chat history
         st.session_state.messages.append({"role": "user", "content": prompt})
         with st.chat_message("user"):
             st.markdown(prompt)
         
-        # Generate AI response
         with st.chat_message("assistant"):
-            with st.spinner("🤖 Analyzing your question..."):
+            with st.spinner("🤖 Analyzing..."):
                 response = analytics_agent.chat_with_data(prompt)
             st.markdown(response)
         
-        # Add assistant response to chat history
         st.session_state.messages.append({"role": "assistant", "content": response})
     
-    # Suggested questions
-    st.markdown("#### 💡 Try these sample questions:")
-    
+    # Sample questions
+    st.markdown("#### 💡 Try these questions:")
     col1, col2, col3 = st.columns(3)
     
-    sample_questions = [
+    questions = [
         "What are my biggest spending areas?",
-        "How are my vendors performing?",
-        "What risks should I be concerned about?"
+        "How are my vendors performing?", 
+        "What optimization opportunities exist?"
     ]
     
-    for i, (col, question) in enumerate(zip([col1, col2, col3], sample_questions)):
+    for i, (col, question) in enumerate(zip([col1, col2, col3], questions)):
         with col:
             if st.button(f"💭 {question}", key=f"q_{i}"):
-                # Add the question to chat
                 st.session_state.messages.append({"role": "user", "content": question})
-                with st.spinner("🤖 Analyzing..."):
-                    response = analytics_agent.chat_with_data(question)
+                response = analytics_agent.chat_with_data(question)
                 st.session_state.messages.append({"role": "assistant", "content": response})
                 st.rerun()
-    
-    # Clear chat button
-    if st.button("🗑️ Clear Chat History"):
-        st.session_state.messages = [
-            {"role": "assistant", "content": "Chat cleared! What would you like to know about your procurement data?"}
-        ]
-        st.rerun()
 
 elif selected == "📊 Analytics":
     st.markdown("### 📈 Advanced Analytics Dashboard")
     
-    # Vendor performance analysis
-    st.markdown("#### 🏆 Vendor Performance Scorecard")
-    
     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)
-    vendor_performance = vendor_performance.sort_values('Total Spend (€)', ascending=False)
-    
-    st.dataframe(
-        vendor_performance.head(10), 
-        use_container_width=True,
-        column_config={
-            "Total Spend (€)": st.column_config.NumberColumn(
-                "Total Spend (€)",
-                help="Total procurement spend with vendor",
-                format="€%.0f",
-            ),
-            "On-Time Delivery (%)": st.column_config.NumberColumn(
-                "On-Time Delivery (%)",
-                help="Percentage of on-time deliveries",
-                format="%.1f%%",
-            ),
-            "Quality Score": st.column_config.NumberColumn(
-                "Quality Score",
-                help="Average quality rating (1-10)",
-                format="%.1f/10",
-            )
-        }
-    )
+    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)
     
-    # Performance charts
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        # Performance scatter plot
-        fig_scatter = px.scatter(
-            st.session_state.po_df,
-            x='on_time_delivery',
-            y='quality_score',
-            size='order_value',
-            color='vendor',
-            title='Vendor Performance Matrix',
-            labels={'on_time_delivery': 'On-Time Delivery Rate', 'quality_score': 'Quality Score (1-10)'},
-            hover_data=['vendor', 'order_value']
-        )
-        fig_scatter.update_layout(height=500, showlegend=False)
-        st.plotly_chart(fig_scatter, use_container_width=True)
-    
-    with col2:
-        # Monthly trend
-        st.session_state.po_df['order_month'] = pd.to_datetime(st.session_state.po_df['order_date']).dt.to_period('M')
-        monthly_trend = st.session_state.po_df.groupby('order_month')['order_value'].sum().reset_index()
-        monthly_trend['order_month'] = monthly_trend['order_month'].astype(str)
-        
-        fig_trend = px.line(
-            monthly_trend,
-            x='order_month',
-            y='order_value',
-            title='Monthly Procurement Spend Trend',
-            markers=True
-        )
-        fig_trend.update_layout(
-            height=500,
-            xaxis_tickangle=45
-        )
-        fig_trend.update_traces(line_color='#0066cc', line_width=3, marker_size=8)
-        st.plotly_chart(fig_trend, use_container_width=True)
+    st.dataframe(vendor_performance.sort_values('Total Spend (€)', ascending=False), use_container_width=True)
 
 elif selected == "��� Recommendations":
-    st.markdown("### 🚀 Strategic Procurement Recommendations")
-    
-    st.markdown("""
-    <div class="ai-insight">
-        <h3>🎯 AI-Powered Strategic Optimization</h3>
-        <p>Based on comprehensive data analysis, here are prioritized recommendations to enhance your procurement strategy and drive business value.</p>
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Calculate some metrics for recommendations
-    vendor_count = len(st.session_state.po_df['vendor'].unique())
-    avg_order_value = st.session_state.po_df['order_value'].mean()
-    low_value_orders = len(st.session_state.po_df[st.session_state.po_df['order_value'] < 5000])
-    total_orders = len(st.session_state.po_df)
+    st.markdown("### 🚀 Strategic Recommendations")
     
     recommendations = [
-        {
-            "priority": "🔥 High Priority",
-            "title": "Vendor Consolidation Strategy",
-            "description": f"With {vendor_count} active vendors, consolidating to 5-7 strategic partners could reduce costs by 12-18% and improve relationship management.",
-            "impact": "💰 Cost Reduction: €50K-75K annually",
-            "timeline": "3-6 months"
-        },
-        {
-            "priority": "⚡ Quick Win", 
-            "title": "Procurement Process Automation",
-            "description": f"{low_value_orders}/{total_orders} orders ({low_value_orders/total_orders*100:.1f}%) are under €5,000. Implementing automated approval workflows could save 40+ hours weekly.",
-            "impact": "⏱️ Efficiency Gain: 160 hours/month",
-            "timeline": "4-8 weeks"
-        },
-        {
-            "priority": "📈 Strategic",
-            "title": "Performance-Based Contracts",
-            "description": "Implement KPI-driven contracts with top 5 vendors focusing on quality scores >8.5 and delivery performance >90%.",
-            "impact": "📊 Performance Improvement: 15-25%",
-            "timeline": "6-9 months"
-        },
-        {
-            "priority": "🛡️ Risk Management",
-            "title": "Supplier Risk Monitoring",
-            "description": "Deploy real-time risk assessment tools to monitor supplier financial health, compliance, and performance metrics.",
-            "impact": "⚠️ Risk Reduction: 30-40%",
-            "timeline": "2-4 months"
-        },
-        {
-            "priority": "🎯 Innovation",
-            "title": "Digital Procurement Platform",
-            "description": "Upgrade to AI-powered procurement platform with predictive analytics, spend optimization, and automated sourcing capabilities.",
-            "impact": "🚀 Digital Transformation: 25-35% efficiency",
-            "timeline": "9-12 months"
-        }
+        "🎯 **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",
+        "🚀 **Digital Platform**: Upgrade to AI-powered procurement system"
     ]
     
     for i, rec in enumerate(recommendations, 1):
-        priority_color = {"🔥 High Priority": "#dc3545", "⚡ Quick Win": "#28a745", "📈 Strategic": "#0066cc", "🛡️ Risk Management": "#ffc107", "🎯 Innovation": "#6f42c1"}
-        
         st.markdown(f"""
         <div class="alert alert-success">
-            <h4 style="color: {priority_color[rec['priority']]};">{rec['priority']}</h4>
-            <h3>{rec['title']}</h3>
-            <p style="margin-bottom: 1rem;">{rec['description']}</p>
-            <div style="display: flex; justify-content: space-between; font-size: 0.9rem;">
-                <span><strong>{rec['impact']}</strong></span>
-                <span><strong>⏱️ Timeline: {rec['timeline']}</strong></span>
-            </div>
+            <h4>Recommendation #{i}</h4>
+            <p>{rec}</p>
         </div>
         """, unsafe_allow_html=True)
-    
-    # Implementation roadmap
-    st.markdown("#### 🗺️ Implementation Roadmap")
-    
-    roadmap_data = {
-        "Phase": ["Phase 1 (0-3 months)", "Phase 2 (3-6 months)", "Phase 3 (6-12 months)"],
-        "Focus Areas": [
-            "Process Automation, Quick Wins",
-            "Vendor Consolidation, Risk Management", 
-            "Strategic Contracts, Digital Platform"
-        ],
-        "Expected ROI": ["15-20%", "20-30%", "30-40%"],
-        "Key Deliverables": [
-            "Automated workflows, Spend visibility",
-            "Strategic partnerships, Risk framework",
-            "AI-powered platform, Performance management"
-        ]
-    }
-    
-    roadmap_df = pd.DataFrame(roadmap_data)
-    st.dataframe(roadmap_df, use_container_width=True, hide_index=True)
 
 # Footer
 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 | SAP S/4HANA Integration Demo</p>
-    <p><em>Synthetic data demonstration • {len(st.session_state.po_df):,} orders • {len(st.session_state.po_df['vendor'].unique())} vendors • OpenAI {api_key_status}</em></p>
-    <p><small>💡 Add your OpenAI API key as 'OPENAI_API_KEY' in Hugging Face Space settings for enhanced AI features</small></p>
+    <p>🤖 <strong>Agentic AI Procurement Analytics</strong> | Built with Streamlit & Python</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)