Add Perfect Sample Data for HF Spaces Demo

- Created comprehensive multi-agent customer service scenario
- Sample trace with 5 specialized agents and error handling
- Knowledge graph with 15 entities and 18 relations
- Demonstrates optimization opportunities and failure recovery
- Auto-loads only on HF Spaces when database is empty
- Users see immediate value instead of empty dashboard

backend/app.py

@@ -82,23 +82,6 @@ async def startup_event():
         if os.getenv("SPACE_ID"):
             logger.info("🔒 HF Spaces: Using in-memory database for user privacy")
             logger.info("📝 Note: Data will be cleared when container restarts")
-            
-            # Load perfect demo data for HF Spaces
-            try:
-                from backend.database.demo_data_loader import load_demo_trace_for_hf_spaces
-                from backend.database import SessionLocal
-                
-                # Create database session for demo loading
-                with SessionLocal() as demo_session:
-                    demo_loaded = load_demo_trace_for_hf_spaces(demo_session)
-                    if demo_loaded:
-                        logger.info("🎯 Perfect demonstration trace loaded for immediate user experience")
-                    else:
-                        logger.info("⚠️ Demo trace loading skipped - users will start with empty database")
-                        
-            except Exception as demo_error:
-                logger.warning(f"Demo data loading failed (non-critical): {demo_error}")
-                
         else:
             logger.info("💾 Local development: Using persistent database")
             

backend/database/demo_data_loader.py

@@ -1,135 +0,0 @@
-"""
-Demo Data Loader for HF Spaces
-Automatically loads a perfect demonstration trace with rich analysis results
-"""
-
-import os
-import json
-import logging
-from pathlib import Path
-from typing import Dict, Any
-from datetime import datetime
-
-logger = logging.getLogger(__name__)
-
-def load_demo_trace_for_hf_spaces(db_session):
-    """
-    Load demonstration trace data for HF Spaces to provide immediate user experience
-    Only runs in HF Spaces environment with in-memory database
-    """
-    
-    # Only load demo data in HF Spaces environment
-    if not os.getenv("SPACE_ID"):
-        logger.info("Not in HF Spaces environment, skipping demo data loading")
-        return False
-        
-    try:
-        # Get demo trace file path
-        demo_file = Path(__file__).parent.parent.parent / "datasets" / "demo" / "perfect_demo_trace.json"
-        
-        if not demo_file.exists():
-            logger.warning(f"Demo trace file not found at {demo_file}")
-            return False
-            
-        # Load demo trace data
-        with open(demo_file, 'r', encoding='utf-8') as f:
-            demo_data = json.load(f)
-            
-        logger.info("📊 Loading perfect demonstration trace for HF Spaces...")
-        
-        # Import the trace using the existing save_trace utility
-        from backend.database.utils import save_trace
-        
-        # Convert demo data to trace format
-        trace_content = json.dumps(demo_data, indent=2)
-        
-        # Create the trace record
-        trace = save_trace(
-            session=db_session,
-            content=trace_content,
-            filename="perfect_demo_trace.json",
-            title="🚀 Perfect Demo: E-commerce Recommendation System Optimization",
-            description="Complete multi-agent analysis of a failing recommendation system with performance recovery, failure analysis, and optimization strategies. Demonstrates model drift detection, infrastructure scaling, and systematic problem-solving.",
-            trace_type="demo",
-            trace_source="hf_spaces_demo",
-            tags=["demo", "multi-agent", "optimization", "failure-analysis", "e-commerce", "ml-system"]
-        )
-        
-        logger.info(f"✅ Demo trace loaded successfully: {trace.trace_id}")
-        logger.info(f"📈 Title: {trace.title}")
-        logger.info(f"🏷️  Tags: {', '.join(trace.tags) if trace.tags else 'none'}")
-        
-        # Process the trace to generate knowledge graph
-        logger.info("🧠 Generating knowledge graph from demo trace...")
-        
-        try:
-            # Import and use the knowledge graph generation
-            from agentgraph.methods.production.multi_agent_knowledge_extractor import create_knowledge_graph
-            
-            # Extract knowledge graph from the trace
-            kg_result = create_knowledge_graph(trace_content)
-            
-            if kg_result and "final_kg" in kg_result:
-                # Save the knowledge graph
-                from backend.database.utils import save_knowledge_graph
-                
-                kg_record = save_knowledge_graph(
-                    session=db_session,
-                    trace_id=trace.trace_id,
-                    knowledge_graph_data=kg_result["final_kg"],
-                    metadata={
-                        "demo_type": "perfect_example",
-                        "generated_at": datetime.now().isoformat(),
-                        "entities_count": len(kg_result["final_kg"].get("entities", [])),
-                        "relations_count": len(kg_result["final_kg"].get("relations", [])),
-                        "analysis_depth": "comprehensive",
-                        "optimization_identified": True,
-                        "failure_patterns_detected": 3
-                    }
-                )
-                
-                logger.info(f"🎯 Knowledge graph generated successfully: {kg_record.kg_id}")
-                logger.info(f"📊 Entities: {len(kg_result['final_kg'].get('entities', []))}")
-                logger.info(f"🔗 Relations: {len(kg_result['final_kg'].get('relations', []))}")
-                
-            else:
-                logger.warning("Knowledge graph generation returned empty result")
-                
-        except Exception as kg_error:
-            logger.error(f"Failed to generate knowledge graph from demo trace: {kg_error}")
-            # Don't fail the whole demo loading process
-            
-        # Add some summary stats for the UI
-        logger.info("🎉 Perfect demo environment ready!")
-        logger.info("👤 Users will see: Rich trace analysis, failure detection, optimization strategies")
-        logger.info("🔍 Features demonstrated: Multi-agent collaboration, system optimization, performance recovery")
-        
-        return True
-        
-    except FileNotFoundError:
-        logger.error(f"Demo trace file not found: {demo_file}")
-        return False
-    except json.JSONDecodeError as e:
-        logger.error(f"Invalid JSON in demo trace file: {e}")
-        return False
-    except Exception as e:
-        logger.error(f"Failed to load demo trace: {e}")
-        return False
-
-
-def get_demo_stats():
-    """Get statistics about the loaded demo data for display"""
-    return {
-        "demo_loaded": True,
-        "trace_title": "Perfect Demo: E-commerce Recommendation System Optimization", 
-        "agent_count": 4,
-        "optimization_steps": 8,
-        "failures_analyzed": 3,
-        "performance_improvements": {
-            "model_accuracy": "+18%",
-            "inference_latency": "-39%", 
-            "system_cpu": "-35%",
-            "cache_hit_rate": "+48%"
-        },
-        "business_impact": "$1.8-2.1M monthly revenue recovery"
-    }

backend/database/init_db.py

@@ -43,6 +43,233 @@ def confirm_reset():
     response = input("Are you sure you want to continue? (yes/no): ")
     return response.lower() in ["yes", "y"]
 
+def add_sample_data(cursor, conn):
+    """Add sample trace and knowledge graph data for demonstration purposes."""
+    import json
+    import uuid
+    import hashlib
+    
+    # Sample trace content - Multi-agent customer service scenario
+    sample_trace_content = '''[
+    {
+        "role": "user",
+        "content": "I need help with my order #12345. It was supposed to arrive yesterday but I still haven't received it. This is very frustrating as I need it for an important meeting tomorrow.",
+        "timestamp": "2024-08-31T10:00:00Z",
+        "metadata": {"priority": "high", "emotion": "frustrated"}
+    },
+    {
+        "role": "assistant", 
+        "name": "RouterAgent",
+        "content": "I understand your frustration about the delayed order. Let me route this to our order tracking specialist who can provide detailed information about your shipment.",
+        "timestamp": "2024-08-31T10:00:15Z",
+        "actions": [{"type": "route", "target": "OrderTrackingAgent", "priority": "high"}]
+    },
+    {
+        "role": "assistant",
+        "name": "OrderTrackingAgent", 
+        "content": "I'll look up order #12345 immediately. Checking our tracking system... I found the issue - there was a delay at the distribution center due to weather conditions. Your package is currently in transit and should arrive by 2 PM today.",
+        "timestamp": "2024-08-31T10:01:00Z",
+        "actions": [
+            {"type": "database_query", "query": "SELECT * FROM orders WHERE order_id = '12345'"},
+            {"type": "api_call", "endpoint": "shipping_tracker", "response": "in_transit"}
+        ],
+        "findings": {
+            "issue": "Weather delay at distribution center", 
+            "current_status": "In transit",
+            "estimated_delivery": "2024-08-31T14:00:00Z"
+        }
+    },
+    {
+        "role": "assistant",
+        "name": "CompensationAgent",
+        "content": "Given this delay caused inconvenience, I'm authorizing a $10 credit to your account and providing free expedited shipping on your next order. I'm also escalating this to ensure better communication about delays in the future.",
+        "timestamp": "2024-08-31T10:02:00Z", 
+        "actions": [
+            {"type": "credit_account", "amount": 10, "reason": "delivery_delay"},
+            {"type": "add_benefit", "type": "free_expedited_shipping"},
+            {"type": "escalate", "department": "operations", "issue": "delayed_delivery_communication"}
+        ],
+        "error": "Failed to process account credit - payment system temporarily unavailable"
+    },
+    {
+        "role": "assistant",
+        "name": "SupervisorAgent",
+        "content": "I see there was an error processing the account credit. I'm manually flagging your account for the $10 credit and expedited shipping benefit. Our technical team will resolve the payment system issue. You should see the credit within 24 hours.",
+        "timestamp": "2024-08-31T10:03:00Z",
+        "actions": [
+            {"type": "manual_flag", "account_credit": 10},
+            {"type": "technical_escalation", "system": "payment_processor"},
+            {"type": "follow_up_schedule", "timeframe": "24_hours"}
+        ],
+        "optimization_opportunity": "Implement payment system redundancy to prevent credit processing failures"
+    },
+    {
+        "role": "user",
+        "content": "Thank you for the quick response and compensation. I appreciate you taking care of this issue promptly.",
+        "timestamp": "2024-08-31T10:04:00Z",
+        "sentiment": "satisfied"
+    },
+    {
+        "role": "assistant",
+        "name": "QualityAgent", 
+        "content": "Session completed successfully. Customer satisfaction restored. Identified system improvement: need better proactive communication about shipping delays and payment system reliability backup.",
+        "timestamp": "2024-08-31T10:05:00Z",
+        "session_analysis": {
+            "resolution_time": "5 minutes",
+            "customer_satisfaction": "high",
+            "agents_involved": 4,
+            "system_errors": 1,
+            "optimization_recommendations": [
+                "Implement proactive delay notifications",
+                "Add payment system redundancy", 
+                "Improve agent handoff protocols"
+            ]
+        }
+    }
+]'''
+
+    # Generate trace metadata
+    trace_id = str(uuid.uuid4())
+    content_hash = hashlib.sha256(sample_trace_content.encode()).hexdigest()
+    
+    # Insert sample trace
+    cursor.execute('''
+        INSERT INTO traces (
+            trace_id, filename, title, description, content, content_hash,
+            uploader, trace_type, trace_source, character_count, turn_count, 
+            status, tags, trace_metadata
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ''', (
+        trace_id,
+        "sample_customer_service.json", 
+        "Multi-Agent Customer Service Resolution",
+        "Demonstration of multi-agent system handling customer complaint with error handling and optimization opportunities",
+        sample_trace_content,
+        content_hash,
+        "AgentGraph Demo",
+        "multi_agent",
+        "sample",
+        len(sample_trace_content),
+        6,  # Number of turns
+        "processed",
+        json.dumps(["sample", "customer_service", "multi_agent", "error_handling", "optimization"]),
+        json.dumps({
+            "scenario": "customer_service",
+            "agents": ["RouterAgent", "OrderTrackingAgent", "CompensationAgent", "SupervisorAgent", "QualityAgent"],
+            "domain": "e_commerce",
+            "complexity": "high"
+        })
+    ))
+    
+    # Create sample knowledge graph
+    kg_id = 1  # First knowledge graph
+    
+    # Insert knowledge graph metadata
+    cursor.execute('''
+        INSERT INTO knowledge_graphs (
+            filename, creator, entity_count, relation_count, namespace, 
+            system_name, system_summary, status, trace_id, window_index, 
+            window_total, processing_run_id
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ''', (
+        "sample_customer_service_kg.json",
+        "AgentGraph Demo", 
+        15,  # Will match actual entities inserted
+        18,  # Will match actual relations inserted
+        "customer_service_demo",
+        "Multi-Agent Customer Service System",
+        "An intelligent customer service system featuring multiple specialized agents working together to resolve customer issues, handle errors, and identify optimization opportunities. The system demonstrates sophisticated agent coordination, error recovery mechanisms, and continuous improvement processes.",
+        "completed",
+        trace_id,
+        0,
+        1,
+        "sample_demo_run"
+    ))
+    
+    # Sample entities with rich properties
+    entities_data = [
+        # Agents
+        ("agent_1", "agent", "RouterAgent", {"role": "traffic_routing", "specialization": "request_classification", "priority_handling": True}),
+        ("agent_2", "agent", "OrderTrackingAgent", {"role": "order_management", "specialization": "shipping_tracking", "data_sources": ["internal_db", "shipping_apis"]}),
+        ("agent_3", "agent", "CompensationAgent", {"role": "customer_retention", "specialization": "compensation_authorization", "max_credit_limit": 50}),
+        ("agent_4", "agent", "SupervisorAgent", {"role": "escalation_handling", "specialization": "system_error_recovery", "override_authority": True}),
+        ("agent_5", "agent", "QualityAgent", {"role": "quality_assurance", "specialization": "session_analysis", "improvement_tracking": True}),
+        
+        # Systems and Tools
+        ("system_1", "system", "OrderDatabase", {"type": "database", "function": "order_storage", "performance": "high"}),
+        ("system_2", "system", "ShippingTracker", {"type": "external_api", "function": "package_tracking", "reliability": "99.5%"}),
+        ("system_3", "system", "PaymentProcessor", {"type": "financial_system", "function": "account_credits", "status": "temporarily_unavailable"}),
+        
+        # Issues and Problems
+        ("issue_1", "issue", "DeliveryDelay", {"severity": "medium", "cause": "weather_conditions", "impact": "customer_satisfaction"}),
+        ("issue_2", "issue", "PaymentSystemFailure", {"severity": "high", "cause": "system_unavailability", "impact": "compensation_processing"}),
+        
+        # Actions and Processes
+        ("action_1", "action", "RouteRequest", {"type": "traffic_management", "success_rate": "98%"}),
+        ("action_2", "action", "TrackPackage", {"type": "information_retrieval", "data_sources": 2}),
+        ("action_3", "action", "AuthorizeCredit", {"type": "financial_transaction", "approval_required": True}),
+        ("action_4", "action", "EscalateIssue", {"type": "process_escalation", "department": "operations"}),
+        
+        # Improvements and Optimizations
+        ("improvement_1", "improvement", "ProactiveNotifications", {"priority": "high", "implementation_effort": "medium", "expected_impact": "reduce_complaints_by_30%"})
+    ]
+    
+    # Insert entities
+    for entity_id, entity_type, name, properties in entities_data:
+        cursor.execute('''
+            INSERT INTO entities (
+                graph_id, entity_id, type, name, properties, knowledge_graph_namespace
+            ) VALUES (?, ?, ?, ?, ?, ?)
+        ''', (kg_id, entity_id, entity_type, name, json.dumps(properties), "customer_service_demo"))
+    
+    # Sample relations showing complex interactions
+    relations_data = [
+        # Agent interactions
+        ("rel_1", "agent_1", "routes_to", "agent_2", {"context": "order_inquiry", "priority": "high", "success": True}),
+        ("rel_2", "agent_2", "collaborates_with", "agent_3", {"context": "customer_compensation", "coordination": "automated"}),
+        ("rel_3", "agent_3", "escalates_to", "agent_4", {"context": "system_error", "escalation_reason": "payment_failure"}),
+        ("rel_4", "agent_4", "coordinates_with", "agent_5", {"context": "quality_improvement", "outcome": "optimization_identified"}),
+        
+        # System interactions
+        ("rel_5", "agent_2", "queries", "system_1", {"query_type": "order_lookup", "response_time": "0.5s", "success": True}),
+        ("rel_6", "agent_2", "calls", "system_2", {"api_endpoint": "track_package", "response_time": "1.2s", "success": True}),
+        ("rel_7", "agent_3", "attempts_transaction", "system_3", {"transaction_type": "credit", "amount": 10, "success": False}),
+        
+        # Problem identification and resolution
+        ("rel_8", "agent_2", "identifies", "issue_1", {"detection_method": "system_query", "severity_assessed": "medium"}),
+        ("rel_9", "agent_3", "encounters", "issue_2", {"error_handling": "automatic_escalation", "recovery_action": "manual_override"}),
+        ("rel_10", "agent_4", "resolves", "issue_2", {"resolution_method": "manual_flag", "permanent_fix": False}),
+        
+        # Action execution
+        ("rel_11", "agent_1", "executes", "action_1", {"execution_time": "15s", "outcome": "successful_routing"}),
+        ("rel_12", "agent_2", "performs", "action_2", {"data_retrieved": True, "accuracy": "100%"}),
+        ("rel_13", "agent_3", "initiates", "action_3", {"authorization_level": "standard", "blocked_by": "system_error"}),
+        ("rel_14", "agent_4", "triggers", "action_4", {"escalation_department": "operations", "follow_up_required": True}),
+        
+        # Improvement opportunities
+        ("rel_15", "agent_5", "identifies", "improvement_1", {"analysis_method": "session_review", "confidence": "high"}),
+        ("rel_16", "issue_1", "leads_to", "improvement_1", {"causal_relationship": "direct", "prevention_potential": "high"}),
+        ("rel_17", "issue_2", "exposes", "system_3", {"vulnerability_type": "single_point_of_failure", "risk_level": "high"}),
+        ("rel_18", "improvement_1", "would_prevent", "issue_1", {"prevention_mechanism": "early_warning", "effectiveness": "85%"})
+    ]
+    
+    # Insert relations
+    for relation_id, from_entity, relation_type, to_entity, properties in relations_data:
+        cursor.execute('''
+            INSERT INTO relations (
+                graph_id, relation_id, from_entity_id, relation_type, to_entity_id, 
+                properties, knowledge_graph_namespace
+            ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        ''', (kg_id, relation_id, from_entity, relation_type, to_entity, json.dumps(properties), "customer_service_demo"))
+    
+    # Commit the sample data
+    conn.commit()
+    
+    logger.info("✅ Sample data added successfully!")
+    logger.info(f"   • 1 sample trace: Multi-Agent Customer Service Resolution")
+    logger.info(f"   • 1 knowledge graph with {len(entities_data)} entities and {len(relations_data)} relations")
+    logger.info(f"   • Demonstrates: Multi-agent coordination, error handling, optimization opportunities")
+
 def init_database(reset=False, force=False):
     """
     Initialize the database with the required tables.
@@ -330,6 +557,11 @@ def init_database(reset=False, force=False):
     
     logger.info(f"Database contains: {kg_count} knowledge graphs, {entity_count} entities, {relation_count} relations, {trace_count} traces")
     
+    # Add sample data for HF Spaces if database is empty
+    if os.getenv("SPACE_ID") and kg_count == 0 and trace_count == 0:
+        logger.info("🎯 HF Spaces detected with empty database - adding sample data...")
+        add_sample_data(cursor, conn)
+    
     # Close connection
     conn.close()
 

datasets/demo/perfect_demo_trace.json

@@ -1,288 +0,0 @@
-{
-  "trace_metadata": {
-    "trace_id": "demo_trace_001",
-    "task": "Analyze and optimize a failing e-commerce recommendation system",
-    "timestamp": "2024-08-31T12:00:00Z",
-    "duration": "18.5 minutes",
-    "total_agents": 4,
-    "total_tool_calls": 12,
-    "status": "completed_with_optimizations"
-  },
-  "agent_interactions": [
-    {
-      "step": 1,
-      "timestamp": "2024-08-31T12:00:00Z",
-      "agent": "TaskPlanner",
-      "role": "system",
-      "content": "Received task: Analyze failing e-commerce recommendation system with 23% CTR drop. Planning multi-agent approach with Data Analyst, ML Engineer, and System Optimizer.",
-      "reasoning": "Complex system analysis requires specialized agents for data investigation, model evaluation, and system optimization.",
-      "next_agents": ["DataAnalyst", "MLEngineer"]
-    },
-    {
-      "step": 2,
-      "timestamp": "2024-08-31T12:01:30Z",
-      "agent": "DataAnalyst",
-      "role": "assistant",
-      "content": "Analyzing recommendation system performance data. Checking user interaction patterns, conversion rates, and system metrics.",
-      "tool_calls": [
-        {
-          "tool": "database_query",
-          "input": "SELECT user_id, item_id, click_through_rate, conversion_rate FROM recommendations WHERE date >= '2024-08-01'",
-          "output": "Retrieved 45,892 recommendation records. Average CTR: 23.1% (down from 46.3%). Conversion rate: 3.2% (down from 7.8%)",
-          "success": true
-        }
-      ],
-      "findings": [
-        "CTR dropped significantly starting August 15th",
-        "Most affected category: Electronics (67% CTR drop)",
-        "Peak failure times: 2-4 PM and 8-10 PM (high traffic periods)"
-      ],
-      "reasoning": "Data shows clear performance degradation pattern. Need to investigate model and infrastructure causes."
-    },
-    {
-      "step": 3,
-      "timestamp": "2024-08-31T12:04:15Z",
-      "agent": "MLEngineer",
-      "role": "assistant", 
-      "content": "Evaluating recommendation model performance and feature engineering pipeline.",
-      "tool_calls": [
-        {
-          "tool": "model_evaluation",
-          "input": "Evaluate current recommendation model accuracy and latency",
-          "output": "Model accuracy: 0.73 (down from 0.89). Average inference time: 145ms (up from 67ms)",
-          "success": true
-        },
-        {
-          "tool": "feature_analysis",
-          "input": "Analyze feature drift and data quality issues",
-          "output": "ERROR: Feature pipeline timeout. 23% of features showing null values. Embedding service responding slowly.",
-          "success": false,
-          "error": "Feature pipeline instability detected"
-        }
-      ],
-      "findings": [
-        "Model accuracy degraded by 18%",
-        "Inference latency increased 2.2x",
-        "Feature pipeline showing instability",
-        "Embedding service bottleneck identified"
-      ],
-      "reasoning": "Performance issues stem from both model degradation and infrastructure problems. Need system optimization.",
-      "escalation": "SystemOptimizer",
-      "priority": "high"
-    },
-    {
-      "step": 4,
-      "timestamp": "2024-08-31T12:07:45Z",
-      "agent": "SystemOptimizer",
-      "role": "assistant",
-      "content": "Investigating system architecture and infrastructure bottlenecks affecting recommendation performance.",
-      "tool_calls": [
-        {
-          "tool": "system_monitoring",
-          "input": "Check CPU, memory, and network utilization for recommendation services",
-          "output": "CPU: 87% avg (recommendation service), Memory: 92% (embedding cache), Network: 340ms avg latency to ML models",
-          "success": true
-        },
-        {
-          "tool": "database_performance",
-          "input": "Analyze database query performance and connection pools",
-          "output": "Average query time: 890ms (up 4x). Connection pool: 98% utilization. 12 slow queries identified.",
-          "success": true
-        },
-        {
-          "tool": "caching_analysis",
-          "input": "Evaluate recommendation cache hit rates and invalidation patterns", 
-          "output": "Cache hit rate: 34% (down from 78%). Cache invalidation frequency: 340% increase due to model updates",
-          "success": true
-        }
-      ],
-      "findings": [
-        "Recommendation service under severe load (87% CPU)",
-        "Embedding cache nearly full (92% memory usage)",
-        "Database queries 4x slower than baseline", 
-        "Cache hit rate dropped from 78% to 34%",
-        "Frequent cache invalidations due to model update strategy"
-      ],
-      "reasoning": "System bottlenecks are cascading - high memory usage affects caching, slow queries increase CPU load, poor cache performance increases database pressure."
-    },
-    {
-      "step": 5,
-      "timestamp": "2024-08-31T12:12:20Z",
-      "agent": "TaskPlanner",
-      "role": "system",
-      "content": "Synthesizing findings from all agents. Root causes identified: model drift, infrastructure overload, and cache inefficiency.",
-      "synthesis": {
-        "root_causes": [
-          "Model performance degraded due to data drift and feature pipeline issues",
-          "Infrastructure cannot handle current load with increased latency",
-          "Cache strategy inefficient due to frequent model updates"
-        ],
-        "impact_analysis": {
-          "business_impact": "23% CTR drop = ~$2.3M monthly revenue loss",
-          "user_experience": "Poor recommendations leading to decreased engagement",
-          "system_stability": "High resource utilization risking system failures"
-        }
-      }
-    },
-    {
-      "step": 6,
-      "timestamp": "2024-08-31T12:14:00Z",
-      "agent": "MLEngineer",
-      "role": "assistant",
-      "content": "Proposing model optimization strategy based on identified issues.",
-      "optimization_plan": {
-        "immediate_fixes": [
-          "Retrain model with recent data to address drift",
-          "Optimize feature pipeline to reduce null values",
-          "Implement model compression to reduce inference time"
-        ],
-        "tool_calls": [
-          {
-            "tool": "model_retraining",
-            "input": "Retrain recommendation model with last 30 days of clean data",
-            "output": "New model accuracy: 0.86 (+13%). Inference time: 89ms (-39%)",
-            "success": true
-          }
-        ]
-      },
-      "expected_improvements": {
-        "accuracy": "+13% (from 0.73 to 0.86)",
-        "latency": "-39% (from 145ms to 89ms)", 
-        "CTR_projection": "+15-20% improvement expected"
-      }
-    },
-    {
-      "step": 7,
-      "timestamp": "2024-08-31T12:16:30Z",
-      "agent": "SystemOptimizer", 
-      "role": "assistant",
-      "content": "Implementing infrastructure optimizations to support improved model performance.",
-      "optimization_actions": [
-        {
-          "action": "Scale embedding cache cluster",
-          "tool_calls": [
-            {
-              "tool": "infrastructure_scaling",
-              "input": "Add 2 cache nodes and optimize memory allocation",
-              "output": "Cache cluster scaled. Memory utilization: 67% (-25%). Hit rate projected: 82%",
-              "success": true
-            }
-          ]
-        },
-        {
-          "action": "Optimize database queries",
-          "tool_calls": [
-            {
-              "tool": "query_optimization", 
-              "input": "Add indexes and optimize slow query patterns",
-              "output": "12 queries optimized. Average query time: 210ms (-76%)",
-              "success": true
-            }
-          ]
-        },
-        {
-          "action": "Implement smart cache invalidation",
-          "details": "Reduced invalidation frequency by 60% using incremental updates"
-        }
-      ],
-      "performance_gains": {
-        "cpu_utilization": "-35% (from 87% to 57%)",
-        "query_performance": "-76% latency improvement",
-        "cache_hit_rate": "+48% (from 34% to 82%)"
-      }
-    },
-    {
-      "step": 8,
-      "timestamp": "2024-08-31T12:18:30Z",
-      "agent": "TaskPlanner",
-      "role": "system",
-      "content": "Final optimization results and monitoring recommendations.",
-      "final_results": {
-        "performance_improvements": {
-          "model_accuracy": "0.86 (+18% from degraded state)",
-          "inference_latency": "89ms (-39% improvement)",
-          "system_cpu": "57% (-35% improvement)", 
-          "cache_hit_rate": "82% (+48% improvement)",
-          "projected_ctr": "38-42% (+15-19% improvement)"
-        },
-        "business_impact": {
-          "estimated_revenue_recovery": "$1.8-2.1M monthly",
-          "user_experience_score": "+25% improvement expected",
-          "system_reliability": "High load handling capacity restored"
-        },
-        "monitoring_recommendations": [
-          "Set up alerts for model accuracy below 0.80",
-          "Monitor cache hit rate - alert if below 75%",
-          "Track feature pipeline health continuously",
-          "Implement gradual model rollback capability"
-        ],
-        "failure_prevention": [
-          "Automated model performance monitoring",
-          "Infrastructure auto-scaling triggers",
-          "Feature pipeline redundancy",
-          "A/B testing framework for safe model updates"
-        ]
-      }
-    }
-  ],
-  "failure_analysis": {
-    "identified_failures": [
-      {
-        "type": "model_drift",
-        "severity": "high",
-        "impact": "18% accuracy loss",
-        "root_cause": "Training data staleness and feature pipeline degradation",
-        "prevention": "Automated retraining triggers and feature monitoring"
-      },
-      {
-        "type": "infrastructure_bottleneck", 
-        "severity": "critical",
-        "impact": "2.2x latency increase",
-        "root_cause": "Insufficient cache capacity and database optimization",
-        "prevention": "Auto-scaling policies and performance monitoring"
-      },
-      {
-        "type": "tool_failure",
-        "severity": "medium", 
-        "impact": "Feature analysis timeout in step 3",
-        "root_cause": "Feature pipeline instability under load",
-        "prevention": "Pipeline redundancy and timeout handling"
-      }
-    ],
-    "optimization_opportunities": [
-      {
-        "area": "model_deployment",
-        "opportunity": "Implement blue-green deployment for safer model updates",
-        "potential_impact": "Zero-downtime updates, reduced risk of performance degradation"
-      },
-      {
-        "area": "caching_strategy",
-        "opportunity": "Machine learning-based cache pre-warming",
-        "potential_impact": "90%+ cache hit rate, 50% further latency reduction"
-      },
-      {
-        "area": "monitoring",
-        "opportunity": "Predictive performance alerting using ML",
-        "potential_impact": "Prevent issues before they impact users"
-      }
-    ]
-  },
-  "knowledge_extraction": {
-    "key_entities": [
-      "RecommendationSystem", "MLModel", "DataPipeline", "CacheCluster", 
-      "DatabaseQuery", "UserEngagement", "SystemPerformance", "ModelAccuracy"
-    ],
-    "critical_relationships": [
-      "ModelDrift -> PerformanceDegradation",
-      "InfrastructureBottleneck -> LatencyIncrease", 
-      "CacheInvalidation -> DatabaseLoad",
-      "ModelOptimization -> AccuracyImprovement",
-      "SystemScaling -> PerformanceRecovery"
-    ],
-    "success_patterns": [
-      "MultiAgentCollaboration -> ComprehensiveAnalysis",
-      "DataDrivenOptimization -> MeasurableImprovements",
-      "InfrastructureScaling -> SystemStability"
-    ]
-  }
-}

frontend/src/components/features/workspace/DashboardView.tsx

@@ -4,7 +4,6 @@ import { DashboardVisualization } from "../dashboard/DashboardVisualization";
 import { EntityRelationAnalysisModal } from "../dashboard/modals/EntityRelationAnalysisModal";
 import { TinyTrendChart } from "@/components/shared/TinyTrendChart";
 import { EntityRelationTreeChart } from "@/components/shared/EntityRelationTreeChart";
-import { DemoBanner } from "@/components/shared/DemoBanner";
 import {
   generateTrendData,
   calculateFailureCount,
@@ -77,9 +76,6 @@ export function DashboardView() {
 
       {/* Content with relative positioning */}
       <div className="relative z-10 flex flex-col gap-6 h-full">
-        {/* Demo Banner for HF Spaces */}
-        <DemoBanner />
-        
         {/* Error State */}
         {error && (
           <Card className="border-destructive/50 bg-destructive/10">

frontend/src/components/shared/DemoBanner.tsx

@@ -1,113 +0,0 @@
-import React from "react";
-import { Card, CardContent } from "@/components/ui/card";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import { 
-  Sparkles, 
-  TrendingUp, 
-  Zap, 
-  Target, 
-  ArrowRight,
-  Users,
-  BarChart3
-} from "lucide-react";
-import { useAgentGraph } from "@/context/AgentGraphContext";
-import { IS_HF_SPACES } from "@/lib/config";
-
-export function DemoBanner() {
-  const { actions } = useAgentGraph();
-
-  // Only show on HF Spaces
-  if (!IS_HF_SPACES) {
-    return null;
-  }
-
-  const handleExploreDemo = () => {
-    // Navigate to traces view to show the loaded demo trace
-    actions.setActiveView("traces");
-  };
-
-  return (
-    <Card className="border-2 border-blue-200 bg-gradient-to-r from-blue-50 to-indigo-50 mb-6">
-      <CardContent className="p-6">
-        <div className="flex items-start justify-between">
-          <div className="flex-1">
-            {/* Header */}
-            <div className="flex items-center gap-2 mb-3">
-              <Sparkles className="h-5 w-5 text-blue-600" />
-              <h3 className="text-lg font-semibold text-blue-900">
-                🚀 Perfect Demo Environment Ready
-              </h3>
-              <Badge variant="secondary" className="bg-blue-100 text-blue-700">
-                Pre-loaded Demo
-              </Badge>
-            </div>
-
-            {/* Description */}
-            <p className="text-gray-700 mb-4 leading-relaxed">
-              Explore a complete <strong>multi-agent system analysis</strong> of a failing e-commerce 
-              recommendation system. See how AI agents collaborate to identify problems, 
-              implement optimizations, and recover system performance.
-            </p>
-
-            {/* Key Features Grid */}
-            <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mb-4">
-              <div className="flex items-center gap-2 text-sm text-gray-600">
-                <Users className="h-4 w-4 text-blue-500" />
-                <span>4 AI Agents</span>
-              </div>
-              <div className="flex items-center gap-2 text-sm text-gray-600">
-                <Target className="h-4 w-4 text-green-500" />
-                <span>3 Failures Analyzed</span>
-              </div>
-              <div className="flex items-center gap-2 text-sm text-gray-600">
-                <TrendingUp className="h-4 w-4 text-orange-500" />
-                <span>Performance +39%</span>
-              </div>
-              <div className="flex items-center gap-2 text-sm text-gray-600">
-                <BarChart3 className="h-4 w-4 text-purple-500" />
-                <span>$2.1M Recovery</span>
-              </div>
-            </div>
-
-            {/* Highlights */}
-            <div className="flex flex-wrap gap-2 mb-4">
-              <Badge variant="outline" className="border-green-200 text-green-700 bg-green-50">
-                <Zap className="h-3 w-3 mr-1" />
-                Model Optimization
-              </Badge>
-              <Badge variant="outline" className="border-orange-200 text-orange-700 bg-orange-50">
-                <TrendingUp className="h-3 w-3 mr-1" />
-                System Scaling
-              </Badge>
-              <Badge variant="outline" className="border-purple-200 text-purple-700 bg-purple-50">
-                <Target className="h-3 w-3 mr-1" />
-                Failure Recovery
-              </Badge>
-            </div>
-          </div>
-
-          {/* Action Button */}
-          <div className="ml-4 flex-shrink-0">
-            <Button 
-              onClick={handleExploreDemo}
-              className="bg-blue-600 hover:bg-blue-700 text-white shadow-md"
-            >
-              Explore Demo
-              <ArrowRight className="h-4 w-4 ml-2" />
-            </Button>
-          </div>
-        </div>
-
-        {/* Bottom note */}
-        <div className="mt-4 pt-4 border-t border-blue-200">
-          <p className="text-xs text-blue-600 flex items-center gap-1">
-            <Sparkles className="h-3 w-3" />
-            This demonstration shows AgentGraph's complete analysis capabilities. 
-            Upload your own traces to analyze real AI agent interactions!
-          </p>
-        </div>
-      </CardContent>
-    </Card>
-  );
-}