Upload streamlit_app.py

src/streamlit_app.py

@@ -1,7 +1,6 @@
 #!/usr/bin/env python3
 """
-Hugging Face Spaces compatible launcher for the Multi-Agent System Dashboard
-This file handles environment setup and permissions for deployment.
+Simplified Hugging Face Spaces compatible Multi-Agent System Dashboard
 """
 
 import os
@@ -10,105 +9,400 @@ import tempfile
 import sqlite3
 from pathlib import Path
 import warnings
+from datetime import datetime, timedelta
+import random
 
-# Suppress warnings for cleaner output
+# Suppress warnings
 warnings.filterwarnings('ignore')
 
 # Set environment variables for Hugging Face Spaces
 os.environ['STREAMLIT_SERVER_HEADLESS'] = 'true'
 os.environ['STREAMLIT_SERVER_PORT'] = '7860'
 os.environ['STREAMLIT_BROWSER_GATHER_USAGE_STATS'] = 'false'
-os.environ['STREAMLIT_SERVER_ENABLE_CORS'] = 'false'
-os.environ['STREAMLIT_SERVER_ENABLE_XSRF_PROTECTION'] = 'false'
 
-# Create a writable directory for Streamlit config
-try:
-    # Try to create .streamlit directory in temp
-    streamlit_dir = Path(tempfile.gettempdir()) / '.streamlit'
-    streamlit_dir.mkdir(exist_ok=True)
-    os.environ['STREAMLIT_CONFIG_DIR'] = str(streamlit_dir)
-    
-    # Create config file
-    config_content = """
-[server]
-headless = true
-port = 7860
-enableCORS = false
-enableXsrfProtection = false
+# Import streamlit first and set page config
+import streamlit as st
 
-[browser]
-gatherUsageStats = false
+st.set_page_config(
+    page_title="🤖 Multi-Agent System Dashboard",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
 
-[theme]
-primaryColor = "#FF6B6B"
-backgroundColor = "#FFFFFF"
-secondaryBackgroundColor = "#F0F2F6"
-textColor = "#262730"
-"""
-    
-    config_file = streamlit_dir / 'config.toml'
-    with open(config_file, 'w') as f:
-        f.write(config_content)
-        
-except Exception as e:
-    print(f"Warning: Could not create streamlit config: {e}")
+# Import other required modules
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import json
+import numpy as np
+from typing import Dict, List, Any
 
-# Now import the main application
-try:
-    # Import the main dashboard application
-    from app import HuggingFaceDashboard
+class SimpleDashboard:
+    def __init__(self):
+        # Use temp directory for database
+        temp_dir = tempfile.gettempdir()
+        self.db_path = os.path.join(temp_dir, "evaluation_logs.db")
+        try:
+            self.setup_demo_data()
+        except Exception as e:
+            st.error(f"Setup error: {str(e)}")
+            self.create_fallback_data()
     
-    # Initialize and run the dashboard
-    dashboard = HuggingFaceDashboard()
-    dashboard.run()
+    def create_fallback_data(self):
+        """Create fallback data if database fails"""
+        st.warning("Using fallback demo data")
+        
+        # Create sample data directly
+        agents = ["Diet Agent", "Support Agent", "Queries Agent"]
+        data = []
+        
+        for i in range(50):
+            data.append({
+                'id': i,
+                'session_id': f"session_{random.randint(1000, 9999)}",
+                'agent_name': random.choice(agents),
+                'query': f"Sample query {i}",
+                'response': f"Sample response {i} with detailed information...",
+                'overall_score': random.uniform(7.0, 9.5),
+                'relevance_score': random.uniform(7.0, 9.5),
+                'accuracy_score': random.uniform(7.0, 9.5),
+                'completeness_score': random.uniform(7.0, 9.5),
+                'coherence_score': random.uniform(7.0, 9.5),
+                'guardrails_passed': True,
+                'safety_score': random.uniform(8.0, 10.0),
+                'execution_time_ms': random.uniform(500, 2000),
+                'timestamp': datetime.now() - timedelta(days=random.randint(0, 30))
+            })
+        
+        self.fallback_df = pd.DataFrame(data)
+        self.use_fallback = True
     
-except ImportError as e:
-    # Fallback to a simple error page
-    import streamlit as st
+    def setup_demo_data(self):
+        """Setup demo database"""
+        self.use_fallback = False
+        
+        if not os.path.exists(self.db_path):
+            self.create_demo_database()
     
-    st.set_page_config(
-        page_title="🤖 Multi-Agent System Dashboard",
-        page_icon="🤖",
-        layout="wide"
-    )
+    def create_demo_database(self):
+        """Create demo database"""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        
+        # Create table
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS evaluation_logs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL,
+            agent_name TEXT NOT NULL,
+            query TEXT NOT NULL,
+            response TEXT,
+            overall_score REAL,
+            relevance_score REAL,
+            accuracy_score REAL,
+            completeness_score REAL,
+            coherence_score REAL,
+            guardrails_passed BOOLEAN,
+            safety_score REAL,
+            execution_time_ms REAL,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+        ''')
+        
+        # Insert demo data
+        agents = ["Diet Agent", "Support Agent", "Queries Agent"]
+        
+        sample_queries = {
+            "Diet Agent": [
+                "What's a healthy meal plan for weight loss?",
+                "Can you suggest low-carb breakfast options?",
+                "What are the benefits of intermittent fasting?",
+                "How much protein should I eat daily?",
+                "What foods are good for heart health?"
+            ],
+            "Support Agent": [
+                "I'm having trouble sleeping, can you help?",
+                "How do I manage work stress?",
+                "I feel overwhelmed with my tasks",
+                "Can you help me organize my schedule?",
+                "How to improve my productivity?"
+            ],
+            "Queries Agent": [
+                "What are the latest developments in AI?",
+                "How does blockchain technology work?",
+                "What is quantum computing?",
+                "Explain machine learning algorithms",
+                "What are the benefits of cloud computing?"
+            ]
+        }
+        
+        for i in range(100):
+            session_id = f"session_{random.randint(1000, 9999)}"
+            agent = random.choice(agents)
+            query = random.choice(sample_queries[agent])
+            
+            # Generate detailed response
+            response = f"Based on your query about {query[:30]}..., here's a comprehensive response with detailed information and actionable recommendations."
+            
+            # Generate realistic scores
+            base_score = random.uniform(7.0, 9.5)
+            
+            timestamp = datetime.now() - timedelta(days=random.randint(0, 30))
+            
+            cursor.execute('''
+            INSERT INTO evaluation_logs (
+                session_id, agent_name, query, response, overall_score,
+                relevance_score, accuracy_score, completeness_score, coherence_score,
+                guardrails_passed, safety_score, execution_time_ms, timestamp
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                session_id, agent, query, response, base_score,
+                base_score + random.uniform(-0.3, 0.3),
+                base_score + random.uniform(-0.4, 0.2),
+                base_score + random.uniform(-0.5, 0.3),
+                base_score + random.uniform(-0.2, 0.4),
+                random.choice([True, True, True, False]),  # 75% pass rate
+                random.uniform(8.0, 10.0),
+                random.uniform(500, 2000),
+                timestamp.isoformat()
+            ))
+        
+        conn.commit()
+        conn.close()
     
-    st.error(f"Import Error: {str(e)}")
-    st.info("Please ensure all dependencies are installed correctly.")
+    def load_data(self):
+        """Load data"""
+        if self.use_fallback:
+            return self.fallback_df
+        
+        try:
+            conn = sqlite3.connect(self.db_path)
+            df = pd.read_sql_query("SELECT * FROM evaluation_logs ORDER BY timestamp DESC", conn)
+            conn.close()
+            
+            if not df.empty:
+                df['timestamp'] = pd.to_datetime(df['timestamp'])
+            
+            return df
+        except Exception as e:
+            st.error(f"Data loading error: {str(e)}")
+            return pd.DataFrame()
     
-    # Show basic info
-    st.header("🤖 Multi-Agent System Dashboard")
-    st.markdown("""
-    This dashboard provides comprehensive monitoring and evaluation capabilities for multi-agent systems.
+    def show_overview(self, df):
+        """Show overview tab"""
+        st.header("📈 Executive Summary")
+        
+        if df.empty:
+            st.warning("No data available")
+            return
+        
+        # Key metrics
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.metric("Total Evaluations", len(df))
+        
+        with col2:
+            avg_score = df['overall_score'].mean()
+            st.metric("Average Score", f"{avg_score:.2f}/10")
+        
+        with col3:
+            safety_rate = (df['guardrails_passed'].sum() / len(df)) * 100
+            st.metric("Safety Rate", f"{safety_rate:.1f}%")
+        
+        with col4:
+            avg_time = df['execution_time_ms'].mean() / 1000
+            st.metric("Avg Response Time", f"{avg_time:.2f}s")
+        
+        # Charts
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("📊 Performance by Agent")
+            agent_scores = df.groupby('agent_name')['overall_score'].mean().reset_index()
+            fig = px.bar(
+                agent_scores, 
+                x='agent_name', 
+                y='overall_score',
+                title="Average Score by Agent",
+                color='overall_score',
+                color_continuous_scale='viridis'
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            st.subheader("📈 Score Distribution")
+            fig = px.histogram(
+                df, 
+                x='overall_score', 
+                nbins=20,
+                title="Score Distribution",
+                color_discrete_sequence=['#1f77b4']
+            )
+            st.plotly_chart(fig, use_container_width=True)
     
-    **Features:**
-    - 🎯 Real-time performance monitoring
-    - 📊 Comprehensive evaluation metrics
-    - 🔍 Detailed analytics and insights
-    - 📈 Interactive visualizations
-    - 🛡️ Safety and guardrails monitoring
+    def show_agent_performance(self, df):
+        """Show agent performance tab"""
+        st.header("🤖 Agent Performance Analysis")
+        
+        if df.empty:
+            st.warning("No data available")
+            return
+        
+        # Agent selector
+        agents = df['agent_name'].unique()
+        selected_agent = st.selectbox("Select Agent", ["All Agents"] + list(agents))
+        
+        # Filter data
+        if selected_agent != "All Agents":
+            filtered_df = df[df['agent_name'] == selected_agent]
+        else:
+            filtered_df = df
+        
+        # Performance metrics
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("🎯 Score Breakdown")
+            score_cols = ['relevance_score', 'accuracy_score', 'completeness_score', 'coherence_score']
+            available_scores = [col for col in score_cols if col in filtered_df.columns]
+            
+            if available_scores:
+                avg_scores = filtered_df[available_scores].mean()
+                fig = px.bar(
+                    x=avg_scores.index,
+                    y=avg_scores.values,
+                    title=f"Average Scores - {selected_agent}",
+                    labels={'x': 'Metric', 'y': 'Score'}
+                )
+                st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            st.subheader("⏱️ Response Time Analysis")
+            fig = px.box(
+                filtered_df,
+                x='agent_name',
+                y='execution_time_ms',
+                title="Response Time Distribution"
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # Recent evaluations table
+        st.subheader("📋 Recent Evaluations")
+        display_cols = ['agent_name', 'query', 'overall_score', 'execution_time_ms', 'timestamp']
+        available_cols = [col for col in display_cols if col in filtered_df.columns]
+        
+        if available_cols:
+            recent_data = filtered_df[available_cols].head(20)
+            st.dataframe(recent_data, use_container_width=True)
     
-    **Error:** The application encountered an import error. Please contact support.
-    """)
+    def show_response_analysis(self, df):
+        """Show response analysis tab"""
+        st.header("📝 Response Analysis & Tracing")
+        
+        if df.empty:
+            st.warning("No data available")
+            return
+        
+        # Response metrics
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            if 'response' in df.columns:
+                avg_length = df['response'].str.len().mean()
+                st.metric("Avg Response Length", f"{avg_length:.0f} chars")
+            else:
+                st.metric("Avg Response Length", "N/A")
+        
+        with col2:
+            if 'response' in df.columns:
+                avg_words = df['response'].str.split().str.len().mean()
+                st.metric("Avg Word Count", f"{avg_words:.0f} words")
+            else:
+                st.metric("Avg Word Count", "N/A")
+        
+        with col3:
+            response_rate = (df['response'].notna().sum() / len(df)) * 100
+            st.metric("Response Rate", f"{response_rate:.1f}%")
+        
+        # Search functionality
+        st.subheader("🔍 Search Responses")
+        search_term = st.text_input("Search in responses:", placeholder="Enter keywords...")
+        
+        if search_term and 'response' in df.columns:
+            mask = df['response'].str.contains(search_term, case=False, na=False)
+            search_results = df[mask]
+        else:
+            search_results = df.head(10)
+        
+        # Display results
+        if not search_results.empty:
+            st.write(f"**Showing {len(search_results)} results**")
+            
+            for idx, row in search_results.iterrows():
+                with st.expander(f"🤖 {row['agent_name']} - Score: {row['overall_score']:.1f}"):
+                    col1, col2 = st.columns([2, 1])
+                    
+                    with col1:
+                        st.write("**Query:**")
+                        st.write(row['query'])
+                        
+                        if 'response' in row and pd.notna(row['response']):
+                            st.write("**Response:**")
+                            st.write(row['response'])
+                    
+                    with col2:
+                        st.write("**Metrics:**")
+                        st.write(f"Overall Score: {row['overall_score']:.1f}/10")
+                        if 'execution_time_ms' in row:
+                            st.write(f"Response Time: {row['execution_time_ms']:.0f}ms")
+                        if 'timestamp' in row:
+                            st.write(f"Timestamp: {row['timestamp']}")
     
+    def run(self):
+        """Run the dashboard"""
+        st.title("🤖 Multi-Agent System Dashboard")
+        st.markdown("---")
+        
+        st.info("🎉 **Welcome!** This dashboard showcases evaluation metrics for Diet, Support, and Queries agents.")
+        
+        # Load data
+        df = self.load_data()
+        
+        # Create tabs
+        tab1, tab2, tab3 = st.tabs([
+            "📈 Overview", 
+            "🤖 Agent Performance", 
+            "📝 Response Analysis"
+        ])
+        
+        with tab1:
+            self.show_overview(df)
+        
+        with tab2:
+            self.show_agent_performance(df)
+        
+        with tab3:
+            self.show_response_analysis(df)
+        
+        # Footer
+        st.markdown("---")
+        st.markdown("🚀 **Multi-Agent System Dashboard** | Built with Streamlit & Plotly")
+
+# Run the dashboard
+try:
+    dashboard = SimpleDashboard()
+    dashboard.run()
 except Exception as e:
-    # Handle any other errors gracefully
-    import streamlit as st
-    
-    st.set_page_config(
-        page_title="🤖 Multi-Agent System Dashboard - Error",
-        page_icon="⚠️",
-        layout="wide"
-    )
-    
     st.error(f"Application Error: {str(e)}")
-    st.info("The application encountered an unexpected error. Please refresh the page.")
+    st.info("Please refresh the page.")
     
-    # Show debug info in expander
     with st.expander("Debug Information"):
         st.code(f"""
-Error Type: {type(e).__name__}
-Error Message: {str(e)}
-Python Version: {sys.version}
-Working Directory: {os.getcwd()}
-Temp Directory: {tempfile.gettempdir()}
+Error: {str(e)}
+Type: {type(e).__name__}
+Python: {sys.version}
+Working Dir: {os.getcwd()}
+Temp Dir: {tempfile.gettempdir()}
         """)