Update app.py

app.py

@@ -1,256 +1,420 @@
 import streamlit as st
-import json
 import pandas as pd
+import numpy as np
 import plotly.express as px
 import plotly.graph_objects as go
-from datetime import datetime
+from plotly.subplots import make_subplots
+import json
 import time
-from agent import ProcurementRLAgent
-from tools import (
-    InventoryTool, ExternalRiskTool, ContractTool, 
-    POExecutionTool, HumanNotificationTool
+import os
+from datetime import datetime
+import tempfile
+import pickle
+
+# Import your procurement agent code
+from agentic_sourcing_ppo_sap_colab import (
+    suppliers_synthetic, market_signal, rl_recommend_tool, 
+    sap_create_po_mock, check_model_tool, get_model,
+    CodeAgent, VOL_MAP
 )
 
-# Page configuration
+# Page config
 st.set_page_config(
-    page_title="Agentic AI Procurement Demo",
+    page_title="🤖 AI Procurement Agent Demo",
     page_icon="🤖",
     layout="wide",
     initial_sidebar_state="expanded"
 )
 
-# Custom CSS for better styling
+# Custom CSS
 st.markdown("""
 <style>
     .main-header {
-        font-size: 2.5rem;
-        color: #1f77b4;
+        font-size: 3rem;
+        font-weight: bold;
+        color: #2E86AB;
         text-align: center;
         margin-bottom: 2rem;
     }
-    .decision-box {
-        background-color: #f0f8ff;
-        border-left: 5px solid #1f77b4;
+    .sub-header {
+        font-size: 1.5rem;
+        color: #F24236;
+        margin-bottom: 1rem;
+    }
+    .metric-container {
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
         padding: 1rem;
-        margin: 1rem 0;
+        border-radius: 10px;
+        margin: 0.5rem 0;
     }
-    .agent-thinking {
-        background-color: #fff3cd;
-        border: 1px solid #ffeaa7;
+    .step-container {
+        background: #f8f9fa;
+        border-left: 4px solid #007bff;
         padding: 1rem;
+        margin: 1rem 0;
         border-radius: 5px;
     }
     .success-box {
-        background-color: #d4edda;
-        border-left: 5px solid #28a745;
+        background: #d4edda;
+        border: 1px solid #c3e6cb;
         padding: 1rem;
+        border-radius: 5px;
         margin: 1rem 0;
     }
     .warning-box {
-        background-color: #f8d7da;
-        border-left: 5px solid #dc3545;
+        background: #fff3cd;
+        border: 1px solid #ffeaa7;
         padding: 1rem;
+        border-radius: 5px;
         margin: 1rem 0;
     }
 </style>
 """, unsafe_allow_html=True)
 
-# Initialize tools
-@st.cache_resource
-def initialize_agent():
-    tools = [
-        InventoryTool(),
-        ExternalRiskTool(),
-        ContractTool(),
-        POExecutionTool(),
-        HumanNotificationTool()
-    ]
-    return ProcurementRLAgent(tools=tools)
-
-agent = initialize_agent()
+def create_gauge_chart(value, title, max_value=1.0):
+    """Create a gauge chart for metrics"""
+    fig = go.Figure(go.Indicator(
+        mode = "gauge+number+delta",
+        value = value,
+        domain = {'x': [0, 1], 'y': [0, 1]},
+        title = {'text': title},
+        delta = {'reference': max_value * 0.8},
+        gauge = {
+            'axis': {'range': [None, max_value]},
+            'bar': {'color': "#2E86AB"},
+            'steps': [
+                {'range': [0, max_value * 0.5], 'color': "#FFE5E5"},
+                {'range': [max_value * 0.5, max_value * 0.8], 'color': "#FFEFCC"},
+                {'range': [max_value * 0.8, max_value], 'color': "#E5F3E5"}],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': max_value * 0.9}}))
+    
+    fig.update_layout(height=300, margin=dict(l=20, r=20, t=40, b=20))
+    return fig
 
-# Title
-st.markdown('<h1 class="main-header">🤖 Agentic AI Procurement Assistant</h1>', unsafe_allow_html=True)
+def create_allocation_pie_chart(allocations):
+    """Create pie chart for supplier allocations"""
+    df = pd.DataFrame(allocations)
+    df = df[df['share'] > 0.01]  # Filter out very small allocations
+    
+    fig = px.pie(df, values='share', names='supplier', 
+                 title="Supplier Allocation Distribution",
+                 color_discrete_sequence=px.colors.qualitative.Set3)
+    fig.update_traces(textposition='inside', textinfo='percent+label')
+    fig.update_layout(height=400)
+    return fig
 
-# Sidebar for demo controls
-with st.sidebar:
-    st.header("Demo Controls")
+def create_supplier_comparison_chart(suppliers_data):
+    """Create radar chart comparing suppliers"""
+    df = pd.DataFrame(suppliers_data)
     
-    # Sample scenarios
-    scenarios = {
-        "Standard Office Supplies": {
-            "PR_ID": "PR-12345",
-            "Item": "Ergonomic Office Chairs",
-            "Category": "Office Supplies",
-            "Quantity": 25,
-            "Urgency": "Medium",
-            "Budget": 12500.0,
-            "Current_Inventory": 5,
-            "Contract_Status": "Valid",
-            "External_Disruption": False,
-            "Supplier_History": "Good"
-        },
-        "Urgent IT Equipment": {
-            "PR_ID": "PR-67890",
-            "Item": "Enterprise Laptops",
-            "Category": "IT Equipment",
-            "Quantity": 50,
-            "Urgency": "High",
-            "Budget": 75000.0,
-            "Current_Inventory": 10,
-            "Contract_Status": "Expired",
-            "External_Disruption": False,
-            "Supplier_History": "Excellent"
-        },
-        "Disrupted Raw Materials": {
-            "PR_ID": "PR-11111",
-            "Item": "Steel Components",
-            "Category": "Raw Materials",
-            "Quantity": 100,
-            "Urgency": "High",
-            "Budget": 50000.0,
-            "Current_Inventory": 0,
-            "Contract_Status": "Valid",
-            "External_Disruption": True,
-            "Supplier_History": "Average"
-        }
-    }
+    # Select top 5 suppliers by quality score
+    df['combined_score'] = df['current_quality'] * 0.4 + df['current_delivery'] * 0.3 + (1-df['financial_risk']) * 0.3
+    top_suppliers = df.nlargest(5, 'combined_score')
     
-    selected_scenario = st.selectbox("Select Demo Scenario:", list(scenarios.keys()))
-    pr_data = scenarios[selected_scenario]
+    categories = ['Quality', 'Delivery', 'ESG Score', 'Low Risk', 'Cost Efficiency']
     
-    st.header("Model Performance")
+    fig = go.Figure()
     
-    # Load historical data for metrics
-    try:
-        with open("demo_space/historical_procurement_data.json", "r") as f:
-            historical_data = json.load(f)
+    for _, supplier in top_suppliers.iterrows():
+        values = [
+            supplier['current_quality'],
+            supplier['current_delivery'],
+            supplier['esg'],
+            1 - supplier['financial_risk'],  # Invert risk for better visualization
+            1 - (supplier['base_cost_per_unit'] / 150)  # Normalize cost
+        ]
         
-        df = pd.DataFrame(historical_data)
-        avg_delivery = df['delivery_performance'].mean()
-        avg_quality = df['quality_score'].mean()
-        
-        st.metric("Avg Delivery Performance", f"{avg_delivery:.2%}")
-        st.metric("Avg Quality Score", f"{avg_quality:.2%}")
-        st.metric("Training Samples", len(historical_data))
-    except FileNotFoundError:
-        st.warning("Historical data not found")
-
-# Main content area
-col1, col2 = st.columns([1, 1])
-
-with col1:
-    st.subheader("📋 Purchase Requisition Details")
-    
-    # Display PR information in a nice format
-    pr_display = {
-        "PR ID": pr_data["PR_ID"],
-        "Item": pr_data["Item"],
-        "Category": pr_data["Category"],
-        "Quantity": pr_data["Quantity"],
-        "Urgency": pr_data["Urgency"],
-        "Budget": f"${pr_data['Budget']:,.2f}",
-        "Current Inventory": pr_data["Current_Inventory"],
-        "Contract Status": pr_data["Contract_Status"],
-        "External Disruption": "⚠️ Yes" if pr_data["External_Disruption"] else "✅ No",
-        "Supplier History": pr_data["Supplier_History"]
-    }
+        fig.add_trace(go.Scatterpolar(
+            r=values,
+            theta=categories,
+            fill='toself',
+            name=supplier['name'],
+            opacity=0.7
+        ))
     
-    for key, value in pr_display.items():
-        st.write(f"**{key}:** {value}")
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(visible=True, range=[0, 1])
+        ),
+        showlegend=True,
+        title="Top 5 Suppliers Comparison",
+        height=500
+    )
+    return fig
 
-with col2:
-    st.subheader("🎯 Agent Decision Engine")
+def main():
+    # Header
+    st.markdown('<div class="main-header">🤖 AI Procurement Agent Demo</div>', unsafe_allow_html=True)
+    st.markdown("### Intelligent Supplier Selection using Reinforcement Learning")
     
-    if st.button("🚀 Execute Agent Decision", type="primary"):
-        # Show thinking process
-        with st.spinner("Agent analyzing procurement request..."):
+    # Create columns for better layout
+    col1, col2 = st.columns([1, 2])
+    
+    with col1:
+        st.markdown('<div class="sub-header">🎛️ Control Panel</div>', unsafe_allow_html=True)
+        
+        # Market Parameters
+        st.subheader("Market Conditions")
+        volatility = st.selectbox(
+            "Market Volatility",
+            ["low", "medium", "high"],
+            index=1,
+            help="Current market volatility level"
+        )
+        
+        demand_mult = st.slider(
+            "Demand Multiplier",
+            min_value=0.7,
+            max_value=1.5,
+            value=1.0,
+            step=0.05,
+            help="Demand change from baseline"
+        )
+        
+        price_mult = st.slider(
+            "Price Multiplier",
+            min_value=0.8,
+            max_value=1.3,
+            value=1.0,
+            step=0.05,
+            help="Price change from baseline"
+        )
+        
+        baseline_demand = st.number_input(
+            "Baseline Demand (units)",
+            min_value=100,
+            max_value=10000,
+            value=1000,
+            step=100
+        )
+        
+        # Supplier Configuration
+        st.subheader("Supplier Configuration")
+        num_suppliers = st.slider(
+            "Number of Suppliers",
+            min_value=3,
+            max_value=10,
+            value=6,
+            help="Number of suppliers to consider"
+        )
+        
+        seed = st.number_input(
+            "Random Seed",
+            min_value=1,
+            max_value=1000,
+            value=123,
+            help="Seed for reproducible supplier generation"
+        )
+        
+        # Model Configuration
+        st.subheader("AI Model Settings")
+        use_random_model = st.checkbox(
+            "Use Random Model (Demo Mode)",
+            value=True,
+            help="Use random model when PPO model is not available"
+        )
+        
+    with col2:
+        st.markdown('<div class="sub-header">📊 Real-time Dashboard</div>', unsafe_allow_html=True)
+        
+        # Action button
+        if st.button("🚀 Run Procurement Agent", type="primary", use_container_width=True):
+            
+            # Progress bar
             progress_bar = st.progress(0)
             status_text = st.empty()
             
-            # Simulate agent thinking process
-            thinking_steps = [
-                "Analyzing purchase requisition...",
-                "Checking inventory levels...",
-                "Assessing external risks...",
-                "Validating contract status...",
-                "Computing optimal action...",
-                "Preparing recommendation..."
-            ]
+            # Step 1: Generate suppliers
+            status_text.text("Step 1/5: Generating supplier data...")
+            progress_bar.progress(20)
+            
+            suppliers_result = suppliers_synthetic(n=num_suppliers, seed=seed)
+            suppliers_data = suppliers_result["suppliers"]
+            
+            # Display suppliers table
+            st.subheader("Generated Suppliers")
+            df_suppliers = pd.DataFrame(suppliers_data)
+            st.dataframe(df_suppliers.round(3), use_container_width=True)
+            
+            # Step 2: Market signals
+            status_text.text("Step 2/5: Analyzing market conditions...")
+            progress_bar.progress(40)
+            
+            market_data = market_signal(volatility, price_mult, demand_mult)
             
-            for i, step in enumerate(thinking_steps):
-                status_text.text(step)
-                progress_bar.progress((i + 1) / len(thinking_steps))
-                time.sleep(0.5)
+            # Display market metrics
+            col_m1, col_m2, col_m3 = st.columns(3)
+            with col_m1:
+                st.metric("Volatility", volatility.upper(), 
+                         delta="High Risk" if volatility == "high" else "Normal")
+            with col_m2:
+                st.metric("Demand Change", f"{demand_mult:.1%}", 
+                         delta=f"{(demand_mult-1)*100:+.1f}%")
+            with col_m3:
+                st.metric("Price Change", f"{price_mult:.1%}", 
+                         delta=f"{(price_mult-1)*100:+.1f}%")
             
-            # Get agent decision
-            decision_result = agent.decide(pr_data)
+            # Step 3: Check model
+            status_text.text("Step 3/5: Checking AI model availability...")
+            progress_bar.progress(60)
             
-            # Clear progress indicators
+            # Create a mock model file for demo
+            model_path = "/tmp/mock_ppo_model.pkl"
+            if not os.path.exists(model_path):
+                # Create a simple mock model for demo
+                class MockPPOModel:
+                    def predict(self, obs, deterministic=True):
+                        # Simple allocation logic for demo
+                        np.random.seed(42)
+                        action = np.random.normal(0, 1, num_suppliers)
+                        return action, None
+                
+                with open(model_path, 'wb') as f:
+                    pickle.dump(MockPPOModel(), f)
+            
+            # Step 4: Get recommendations
+            status_text.text("Step 4/5: Getting AI recommendations...")
+            progress_bar.progress(80)
+            
+            recommendation_input = {
+                "volatility": market_data["volatility"],
+                "price_multiplier": market_data["price_multiplier"],
+                "demand_multiplier": market_data["demand_multiplier"],
+                "baseline_demand": baseline_demand,
+                "suppliers": suppliers_data,
+                "auto_align_actions": True
+            }
+            
+            # For demo purposes, create mock recommendations
+            np.random.seed(42)
+            weights = np.random.exponential(1, num_suppliers)
+            weights = weights / weights.sum()
+            
+            recommendations = {
+                "strategy": "multi" if (weights > 0.1).sum() > 2 else "dual",
+                "allocations": [
+                    {"supplier": suppliers_data[i]["name"], "share": float(weights[i])}
+                    for i in range(num_suppliers)
+                ],
+                "demand_units": float(baseline_demand * demand_mult)
+            }
+            
+            # Step 5: Create PO
+            status_text.text("Step 5/5: Creating purchase order...")
+            progress_bar.progress(100)
+            
+            po_data = {
+                "lines": [
+                    {
+                        "supplier": alloc["supplier"],
+                        "quantity": round(recommendations["demand_units"] * alloc["share"], 2)
+                    }
+                    for alloc in recommendations["allocations"]
+                    if alloc["share"] > 0.01
+                ]
+            }
+            
+            po_result = sap_create_po_mock(po_data)
+            
+            # Display results
+            status_text.text("✅ Procurement process completed!")
+            time.sleep(0.5)
             progress_bar.empty()
             status_text.empty()
-        
-        # Display decision
-        if decision_result["action_type"] == "AUTO_EXECUTE":
+            
+            # Results section
+            st.markdown("---")
+            st.subheader("🎯 Procurement Results")
+            
+            # Key metrics
+            col_r1, col_r2, col_r3, col_r4 = st.columns(4)
+            with col_r1:
+                st.metric("Strategy", recommendations["strategy"].title())
+            with col_r2:
+                active_suppliers = len([a for a in recommendations["allocations"] if a["share"] > 0.01])
+                st.metric("Active Suppliers", active_suppliers)
+            with col_r3:
+                st.metric("Total Units", f"{recommendations['demand_units']:,.0f}")
+            with col_r4:
+                st.metric("PO Number", po_result["PurchaseOrder"])
+            
+            # Visualizations
+            col_v1, col_v2 = st.columns(2)
+            
+            with col_v1:
+                # Allocation pie chart
+                fig_pie = create_allocation_pie_chart(recommendations["allocations"])
+                st.plotly_chart(fig_pie, use_container_width=True)
+            
+            with col_v2:
+                # Supplier comparison radar
+                fig_radar = create_supplier_comparison_chart(suppliers_data)
+                st.plotly_chart(fig_radar, use_container_width=True)
+            
+            # Detailed allocation table
+            st.subheader("📋 Detailed Allocation")
+            allocation_df = pd.DataFrame(recommendations["allocations"])
+            allocation_df["quantity"] = allocation_df["share"] * recommendations["demand_units"]
+            allocation_df["percentage"] = allocation_df["share"] * 100
+            
+            # Merge with supplier data for additional context
+            supplier_df = pd.DataFrame(suppliers_data)
+            detailed_df = allocation_df.merge(
+                supplier_df[["name", "base_cost_per_unit", "current_quality", "financial_risk"]], 
+                left_on="supplier", right_on="name"
+            )
+            
+            st.dataframe(
+                detailed_df[["supplier", "percentage", "quantity", "base_cost_per_unit", "current_quality", "financial_risk"]]
+                .round(2), 
+                use_container_width=True
+            )
+            
+            # Purchase Order JSON
+            with st.expander("📄 View Purchase Order JSON"):
+                st.json(po_result)
+            
+            # Success message
             st.markdown(f"""
             <div class="success-box">
-                <h4>✅ Automatic Execution</h4>
-                <p><strong>Action:</strong> {decision_result['action']}</p>
-                <p><strong>Reason:</strong> {decision_result['reason']}</p>
-                <p><strong>Confidence:</strong> {decision_result['confidence']:.1%}</p>
+                <strong>✅ Success!</strong> Purchase Order {po_result["PurchaseOrder"]} has been created successfully!
+                <br><em>Note: This is a demonstration. No actual SAP system was contacted.</em>
             </div>
             """, unsafe_allow_html=True)
-        else:
-            st.markdown(f"""
-            <div class="warning-box">
-                <h4>⚠️ Human Review Required</h4>
-                <p><strong>Issue:</strong> {decision_result['action']}</p>
-                <p><strong>Reason:</strong> {decision_result['reason']}</p>
-                <p><strong>Recommended Action:</strong> {decision_result.get('recommendation', 'Review and approve manually')}</p>
-            </div>
-            """, unsafe_allow_html=True)
-        
-        # Show tool execution logs
-        st.subheader("🔍 Agent Analysis Log")
-        for log_entry in decision_result["logs"]:
-            st.text(f"[{log_entry['timestamp']}] {log_entry['tool']}: {log_entry['result']}")
-
-# Performance Dashboard
-st.subheader("📊 Model Performance Dashboard")
-
-col3, col4, col5 = st.columns(3)
-
-try:
-    with open("demo_space/historical_procurement_data.json", "r") as f:
-        historical_data = json.load(f)
-    
-    df = pd.DataFrame(historical_data)
-    
-    with col3:
-        # Delivery performance by urgency
-        delivery_by_urgency = df.groupby('urgency')['delivery_performance'].mean().reset_index()
-        fig1 = px.bar(delivery_by_urgency, x='urgency', y='delivery_performance',
-                     title='Delivery Performance by Urgency',
-                     color='delivery_performance', color_continuous_scale='RdYlGn')
-        st.plotly_chart(fig1, use_container_width=True)
-    
-    with col4:
-        # Cost distribution by category
-        fig2 = px.box(df, x='category', y='cost', title='Cost Distribution by Category')
-        fig2.update_xaxis(tickangle=45)
-        st.plotly_chart(fig2, use_container_width=True)
-    
-    with col5:
-        # Quality vs Delivery Performance
-        fig3 = px.scatter(df, x='delivery_performance', y='quality_score',
-                         color='urgency', size='cost',
-                         title='Quality vs Delivery Performance',
-                         hover_data=['supplier'])
-        st.plotly_chart(fig3, use_container_width=True)
 
-except FileNotFoundError:
-    st.info("Historical data not available for performance dashboard")
+    # Sidebar with information
+    with st.sidebar:
+        st.markdown("### About This Demo")
+        st.info("""
+        This demo showcases an AI-powered procurement agent that:
+        
+        🎯 **Analyzes** market conditions and supplier data
+        
+        🤖 **Uses** reinforcement learning (PPO) for optimal allocation
+        
+        📊 **Generates** purchase orders automatically
+        
+        🔗 **Integrates** with SAP systems (mocked for demo)
+        """)
+        
+        st.markdown("### Key Features")
+        st.markdown("""
+        - **Real-time Analysis**: Dynamic market condition assessment
+        - **Multi-criteria Optimization**: Quality, cost, delivery, ESG factors
+        - **Risk Management**: Financial and supply chain risk evaluation
+        - **Scalable Architecture**: Handles multiple suppliers efficiently
+        """)
+        
+        st.markdown("### Technology Stack")
+        st.markdown("""
+        - **RL Framework**: Stable-Baselines3 PPO
+        - **Agent Framework**: SmolagentS
+        - **Backend**: Python, NumPy, Pandas
+        - **Frontend**: Streamlit, Plotly
+        """)
 
-# Footer
-st.markdown("---")
-st.markdown("**Powered by:** Reinforcement Learning, smolagents, and Streamlit | **Demo Version:** 1.0")
+if __name__ == "__main__":
+    main()