🧹 Code Cleanup and Optimization

✅ Improvements:
• Removed debug print statements from backend/app.py
• Cleaned up unnecessary imports in backend/database/__init__.py
• Optimized knowledge graph processing modules
• Removed temporary debugging code across multiple files

🎯 Focus areas:
• Backend startup process optimization
• Database initialization cleanup
• Knowledge graph processing efficiency
• Multi-agent extractor refinements

🚀 Impact:
• Cleaner console output in production
• Improved code maintainability
• Better performance with fewer debug calls
• Professional deployment-ready codebase

agentgraph/extraction/graph_processing/knowledge_graph_processor.py

@@ -66,8 +66,7 @@ from agentgraph.reconstruction.content_reference_resolver import ContentReferenc
 
 # Load OpenAI API key from configuration
 from utils.config import OPENAI_API_KEY
-if OPENAI_API_KEY:
-    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
 
 
 class SlidingWindowMonitor:

agentgraph/extraction/graph_utilities/knowledge_graph_merger.py

@@ -50,8 +50,7 @@ from agentgraph.shared.models.reference_based import KnowledgeGraph
 
 # Load OpenAI API key from configuration
 from utils.config import OPENAI_API_KEY
-if OPENAI_API_KEY:
-    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
 # Note: OPENAI_MODEL_NAME will be set dynamically in __init__ method
 
 

agentgraph/methods/production/multi_agent_knowledge_extractor.py

@@ -80,8 +80,7 @@ import base64
 
 # openlit.init()
 
-if OPENAI_API_KEY:
-    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
 # Note: OPENAI_MODEL_NAME will be set dynamically when creating the crew
 
 

agentgraph/testing/knowledge_graph_tester.py

@@ -52,8 +52,7 @@ import openlit
 
 openlit.init()
 
-if OPENAI_API_KEY:
-    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
 
 # (future) from .perturbation_types.rule_misunderstanding import RuleMisunderstandingPerturbationTester
 # (future) from .perturbation_types.emotional_manipulation import EmotionalManipulationPerturbationTester

backend/app.py

@@ -67,66 +67,27 @@ app.include_router(observability.router)
 @app.on_event("startup")
 async def startup_event():
     """Start background services on app startup"""
-    print("🚨 DEBUG: startup_event() called")
     logger.info("✅ Backend server starting...")
     
     # 🔧 Create necessary directories
-    print("🚨 DEBUG: About to ensure directories")
     ensure_directories()
     logger.info("📁 Directory structure created")
-    print("🚨 DEBUG: Directory structure created")
     
     # 🗄️ Initialize database on startup
-    print("🚨 DEBUG: About to initialize database")
     try:
         from backend.database.init_db import init_database
-        from backend.database import init_db, test_database_connection, add_sample_data_for_hf
-        
-        print("🚨 DEBUG: Imported database functions")
-        
-        print("🚨 DEBUG: Calling init_database")
         init_database(reset=False, force=False)
-        print("🚨 DEBUG: init_database completed")
-        
-        print("🚨 DEBUG: Calling init_db")
-        init_db()  # Create tables using SQLAlchemy
-        print("🚨 DEBUG: init_db completed")
         
         # Show database type info
-        space_id = os.getenv("SPACE_ID")
-        print(f"🚨 DEBUG: SPACE_ID = {space_id}")
-        
-        if space_id:
+        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")
-            print("🚨 DEBUG: Detected HF Spaces environment")
-            
-            # Test database connection first
-            logger.info("🔍 Testing database connection...")
-            print("🚨 DEBUG: About to test database connection")
-            
-            # Add sample data for HF Spaces
-            logger.info("📊 Loading sample data for demonstration...")
-            print("🚨 DEBUG: About to call add_sample_data_for_hf()")
-            try:
-                add_sample_data_for_hf()
-                print("🚨 DEBUG: add_sample_data_for_hf() completed without error")
-            except Exception as e:
-                print(f"🚨 DEBUG: add_sample_data_for_hf() failed with error: {e}")
-                import traceback
-                print("🚨 DEBUG: Full traceback:")
-                traceback.print_exc()
         else:
             logger.info("💾 Local development: Using persistent database")
-            print("🚨 DEBUG: Detected local development environment")
             
         logger.info("🗄️ Database initialized successfully")
-        print("🚨 DEBUG: Database initialization completed")
     except Exception as e:
         logger.error(f"❌ Database initialization failed: {e}")
-        import traceback
-        logger.error("Full traceback:")
-        logger.error(traceback.format_exc())
         # Don't fail startup - continue with empty database
     
     logger.info("🚀 Backend API available at: http://0.0.0.0:7860")

backend/database/__init__.py

@@ -4,7 +4,7 @@ This package provides database access and utilities for agent monitoring.
 """
 
 import os
-from sqlalchemy import create_engine, text
+from sqlalchemy import create_engine
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker, scoped_session
 
@@ -60,257 +60,10 @@ def init_db():
     """Initialize the database by creating all tables."""
     Base.metadata.create_all(bind=engine)
 
-def test_database_connection():
-    """Test if database connection is working."""
-    try:
-        session = SessionLocal()
-        # Try to create tables
-        Base.metadata.create_all(bind=engine)
-        
-        # Test a simple query
-        result = session.execute(text("SELECT 1")).fetchone()
-        print(f"✅ Database connection test successful: {result}")
-        
-        session.close()
-        return True
-    except Exception as e:
-        print(f"❌ Database connection test failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def add_sample_data_for_hf():
-    """Add simple sample data for HF Spaces using direct SQL."""
-    print("🚀 add_sample_data_for_hf() started")
-    
-    if not os.getenv("SPACE_ID"):
-        print("❌ Not in HF Spaces environment, skipping sample data")
-        return  # Only run on HF Spaces
-        
-    print(f"🔍 HF Spaces environment confirmed:")
-    print(f"   • SPACE_ID: {os.getenv('SPACE_ID')}")
-    print(f"   • Database URL: {DATABASE_URL}")
-    print(f"   • Engine: {engine}")
-    
-    try:
-        print("🔧 Creating database connection...")
-        # Use direct connection to avoid session issues
-        with engine.connect() as conn:
-            print("✅ Database connection successful")
-            
-            # Begin transaction for atomic operations
-            print("🔄 Starting transaction...")
-            trans = conn.begin()
-            
-            try:
-                print("🔍 Checking existing data...")
-                # Check if data already exists
-                result = conn.execute(text("SELECT COUNT(*) FROM traces")).fetchone()
-                existing_traces = result[0] if result else 0
-                print(f"   • Found {existing_traces} existing traces")
-                
-                result = conn.execute(text("SELECT COUNT(*) FROM knowledge_graphs")).fetchone()  
-                existing_kgs = result[0] if result else 0
-                print(f"   • Found {existing_kgs} existing knowledge graphs")
-                
-                if existing_traces > 0 or existing_kgs > 0:
-                    print("📊 Sample data already exists, skipping insertion...")
-                    return
-                
-                print("🎯 No existing data found. Adding sample data using direct SQL...")
-                print("📝 Preparing sample trace data...")
-                
-                import json
-                import uuid
-                import hashlib
-                from datetime import datetime
-                
-                # Simple trace content
-                sample_trace_content = '''[
-    {"role": "user", "content": "I need help with my delayed order #12345. This is frustrating!", "timestamp": "2024-08-31T10:00:00Z"},
-    {"role": "assistant", "name": "RouterAgent", "content": "Let me route you to our order specialist.", "timestamp": "2024-08-31T10:00:15Z"},
-    {"role": "assistant", "name": "OrderAgent", "content": "I found the issue - weather delay. Your package arrives today at 2 PM.", "timestamp": "2024-08-31T10:01:00Z"},
-    {"role": "assistant", "name": "CompensationAgent", "content": "I'll authorize a $10 credit for the inconvenience.", "timestamp": "2024-08-31T10:02:00Z", "error": "Payment system unavailable"},
-    {"role": "assistant", "name": "SupervisorAgent", "content": "I'll manually flag your account for the credit. Technical team notified.", "timestamp": "2024-08-31T10:03:00Z"},
-    {"role": "user", "content": "Thank you for the quick resolution!", "timestamp": "2024-08-31T10:04:00Z", "sentiment": "satisfied"}
-]'''
-                
-                print("🔑 Generating unique identifiers...")
-                # Generate IDs
-                trace_id = str(uuid.uuid4())
-                content_hash = hashlib.sha256(sample_trace_content.encode()).hexdigest()
-                now = datetime.utcnow()
-                print(f"   • Trace ID: {trace_id}")
-                print(f"   • Content hash: {content_hash[:16]}...")
-                print(f"   • Timestamp: {now}")
-                
-                print("💾 Inserting sample trace...")
-                # Insert trace
-                conn.execute(
-                    text("""INSERT INTO traces (trace_id, filename, title, description, content, content_hash, 
-                       upload_timestamp, update_timestamp, uploader, trace_type, trace_source, 
-                       character_count, turn_count, status, tags, trace_metadata) 
-                       VALUES (:trace_id, :filename, :title, :description, :content, :content_hash,
-                       :upload_timestamp, :update_timestamp, :uploader, :trace_type, :trace_source,
-                       :character_count, :turn_count, :status, :tags, :trace_metadata)"""),
-                    {
-                        "trace_id": trace_id,
-                        "filename": "sample_demo.json",
-                        "title": "Multi-Agent Customer Service Demo",
-                        "description": "Demo showing agent coordination and error handling",
-                        "content": sample_trace_content,
-                        "content_hash": content_hash,
-                        "upload_timestamp": now,
-                        "update_timestamp": now,
-                        "uploader": "AgentGraph Demo",
-                        "trace_type": "multi_agent",
-                        "trace_source": "sample",
-                        "character_count": len(sample_trace_content),
-                        "turn_count": 6,
-                        "status": "processed",
-                        "tags": '["demo", "customer_service", "multi_agent"]',
-                        "trace_metadata": '{"scenario": "customer_service", "agents": ["RouterAgent", "OrderAgent", "CompensationAgent", "SupervisorAgent"]}'
-                    }
-                )
-                print("✅ Trace inserted successfully")
-                
-                print("📊 Inserting knowledge graph...")
-                # Insert knowledge graph with correct field names
-                conn.execute(
-                    text("""INSERT INTO knowledge_graphs (filename, entity_count, relation_count,
-                       status, trace_id, window_index, window_total, processing_run_id)
-                       VALUES (:filename, :entity_count, :relation_count, :status, :trace_id, 
-                       :window_index, :window_total, :processing_run_id)"""),
-                    {
-                        "filename": "demo_kg.json",
-                        "entity_count": 5,
-                        "relation_count": 4,
-                        "status": "completed",
-                        "trace_id": trace_id,
-                        "window_index": 0,
-                        "window_total": 1,
-                        "processing_run_id": "demo_run"
-                    }
-                )
-                print("✅ Knowledge graph inserted successfully")
-                
-                print("🔍 Retrieving knowledge graph ID...")
-                # Get KG ID
-                kg_result = conn.execute(text("SELECT id FROM knowledge_graphs WHERE trace_id = :trace_id"), {"trace_id": trace_id})
-                kg_row = kg_result.fetchone()
-                if not kg_row:
-                    raise Exception("Failed to retrieve knowledge graph ID")
-                kg_id = kg_row[0]
-                print(f"   • Knowledge graph ID: {kg_id}")
-                
-                # Insert sample entities with correct field names
-                entities = [
-                    ("agent_1", "agent", "RouterAgent", '{"role": "routing", "priority_handling": true}'),
-                    ("agent_2", "agent", "OrderAgent", '{"role": "order_tracking", "data_sources": ["db", "api"]}'),
-                    ("agent_3", "agent", "CompensationAgent", '{"role": "compensation", "max_credit": 50}'),
-                    ("agent_4", "agent", "SupervisorAgent", '{"role": "escalation", "override_authority": true}'),
-                    ("issue_1", "issue", "PaymentSystemFailure", '{"severity": "high", "impact": "service_disruption"}')
-                ]
-                
-                print("👥 Inserting sample entities...")
-                # Insert entities and store their database IDs
-                entity_db_ids = {}
-                for i, (entity_id, entity_type, name, properties) in enumerate(entities, 1):
-                    print(f"   • Inserting entity {i}/5: {name} ({entity_type})")
-                    conn.execute(
-                        text("""INSERT INTO entities (graph_id, entity_id, type, name, properties)
-                           VALUES (:graph_id, :entity_id, :type, :name, :properties)"""),
-                        {
-                            "graph_id": kg_id,
-                            "entity_id": entity_id,
-                            "type": entity_type,
-                            "name": name,
-                            "properties": properties
-                        }
-                    )
-                    # Get the database ID for this entity
-                    result = conn.execute(text("SELECT id FROM entities WHERE graph_id = :graph_id AND entity_id = :entity_id"), 
-                                        {"graph_id": kg_id, "entity_id": entity_id})
-                    row = result.fetchone()
-                    if not row:
-                        raise Exception(f"Failed to retrieve database ID for entity: {entity_id}")
-                    entity_db_ids[entity_id] = row[0]
-                    print(f"     → Entity DB ID: {entity_db_ids[entity_id]}")
-                print("✅ All entities inserted successfully")
-                
-                print("🔗 Inserting sample relations...")
-                # Insert sample relations using database IDs as foreign keys
-                relations = [
-                    ("rel_1", "agent_1", "routes_to", "agent_2", '{"priority": "high", "success": true}'),
-                    ("rel_2", "agent_2", "escalates_to", "agent_3", '{"reason": "compensation_needed"}'),
-                    ("rel_3", "agent_3", "escalates_to", "agent_4", '{"reason": "system_error"}'),
-                    ("rel_4", "agent_4", "resolves", "issue_1", '{"method": "manual_override"}')
-                ]
-                
-                for i, (relation_id, from_entity, relation_type, to_entity, properties) in enumerate(relations, 1):
-                    source_db_id = entity_db_ids[from_entity]
-                    target_db_id = entity_db_ids[to_entity]
-                    print(f"   • Inserting relation {i}/4: {from_entity} --{relation_type}--> {to_entity}")
-                    print(f"     → Source DB ID: {source_db_id}, Target DB ID: {target_db_id}")
-                    conn.execute(
-                        text("""INSERT INTO relations (graph_id, relation_id, type, source_id, target_id, properties) 
-                           VALUES (:graph_id, :relation_id, :type, :source_id, :target_id, :properties)"""),
-                        {
-                            "graph_id": kg_id,
-                            "relation_id": relation_id,
-                            "type": relation_type,
-                            "source_id": source_db_id,
-                            "target_id": target_db_id,
-                            "properties": properties
-                        }
-                    )
-                print("✅ All relations inserted successfully")
-                
-                print("💾 Committing transaction...")
-                # Commit transaction
-                trans.commit()
-                print("✅ Transaction committed successfully")
-                
-                print("🔍 Verifying final data counts...")
-                # Verify data
-                final_traces = conn.execute(text("SELECT COUNT(*) FROM traces")).fetchone()[0]
-                final_kgs = conn.execute(text("SELECT COUNT(*) FROM knowledge_graphs")).fetchone()[0]
-                final_entities = conn.execute(text("SELECT COUNT(*) FROM entities")).fetchone()[0]
-                final_relations = conn.execute(text("SELECT COUNT(*) FROM relations")).fetchone()[0]
-                
-                print("🎉 Sample data insertion completed successfully!")
-                print(f"   📊 Final counts:")
-                print(f"   • Traces: {final_traces}")
-                print(f"   • Knowledge graphs: {final_kgs}")
-                print(f"   • Entities: {final_entities}")
-                print(f"   • Relations: {final_relations}")
-                print(f"   🎯 Expected: 1 trace, 1 KG, 5 entities, 4 relations")
-                
-                # Additional verification
-                if final_traces == 1 and final_kgs == 1 and final_entities == 5 and final_relations == 4:
-                    print("✅ All counts match expected values!")
-                else:
-                    print("⚠️  Counts don't match expected values")
-                
-            except Exception as e:
-                print(f"❌ Error during transaction: {e}")
-                trans.rollback()
-                print("🔄 Transaction rolled back")
-                raise e
-                
-    except Exception as e:
-        print(f"❌ Failed to add sample data: {e}")
-        import traceback
-        print("Full error traceback:")
-        traceback.print_exc()
-        print("🚨 Sample data loading failed completely")
-
 __all__ = [
     'get_db',
     'models',
     'init_db',
-    'test_database_connection',
-    'add_sample_data_for_hf',
     'save_knowledge_graph',
     'update_knowledge_graph_status',
     'get_knowledge_graph',

backend/database/init_db.py

@@ -43,233 +43,6 @@ 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.
@@ -557,11 +330,6 @@ 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()