🎉 Complete Fix for HF Spaces Sample Data Loading

✅ Fixed All Critical Issues:
1. OPENAI_API_KEY None TypeError (4 files):
- multi_agent_knowledge_extractor.py
- knowledge_graph_merger.py
- knowledge_graph_tester.py
- knowledge_graph_processor.py
→ Added null checks: if OPENAI_API_KEY: os.environ[...] = OPENAI_API_KEY

2. SQLAlchemy ObjectNotExecutableError:
- Added text() import and wrapped all SQL strings
→ All execute() calls now use text("SQL") format

3. SQLAlchemy ArgumentError - Parameter Format:
- Converted positional parameters to named parameters
- Changed ?, ?, ? → :param1, :param2, :param3
- Changed tuple params → dict params
→ All queries now use {"param1": value1, "param2": value2} format

🎯 Local Test Results:
✅ Application starts successfully
✅ Sample data loads completely:
• 1 trace inserted
• 1 knowledge graph inserted
• 5 entities inserted
• 4 relations inserted
✅ All database operations successful
✅ Transaction committed successfully
✅ Final counts match expected values

Expected HF Spaces Result:
Dashboard should now show: Traces & Graphs: 1 • 1, Entities & Relations: 5 • 4

agentgraph/extraction/graph_processing/knowledge_graph_processor.py

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

agentgraph/extraction/graph_utilities/knowledge_graph_merger.py

@@ -50,7 +50,8 @@ from agentgraph.shared.models.reference_based import KnowledgeGraph
 
 # Load OpenAI API key from configuration
 from utils.config import OPENAI_API_KEY
-os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+if 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,7 +80,8 @@ import base64
 
 # openlit.init()
 
-os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+if 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,7 +52,8 @@ import openlit
 
 openlit.init()
 
-os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+if 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/database/__init__.py

@@ -4,7 +4,7 @@ This package provides database access and utilities for agent monitoring.
 """
 
 import os
-from sqlalchemy import create_engine
+from sqlalchemy import create_engine, text
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker, scoped_session
 
@@ -68,7 +68,7 @@ def test_database_connection():
         Base.metadata.create_all(bind=engine)
         
         # Test a simple query
-        result = session.execute("SELECT 1").fetchone()
+        result = session.execute(text("SELECT 1")).fetchone()
         print(f"✅ Database connection test successful: {result}")
         
         session.close()
@@ -105,11 +105,11 @@ def add_sample_data_for_hf():
             try:
                 print("🔍 Checking existing data...")
                 # Check if data already exists
-                result = conn.execute("SELECT COUNT(*) FROM traces").fetchone()
+                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("SELECT COUNT(*) FROM knowledge_graphs").fetchone()  
+                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")
                 
@@ -147,31 +147,56 @@ def add_sample_data_for_hf():
                 print("💾 Inserting sample trace...")
                 # Insert trace
                 conn.execute(
-                    """INSERT INTO traces (trace_id, filename, title, description, content, content_hash, 
+                    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, "sample_demo.json", "Multi-Agent Customer Service Demo", 
-                     "Demo showing agent coordination and error handling", sample_trace_content, content_hash,
-                     now, now, "AgentGraph Demo", "multi_agent", "sample", len(sample_trace_content), 6, 
-                     "processed", '["demo", "customer_service", "multi_agent"]', 
-                     '{"scenario": "customer_service", "agents": ["RouterAgent", "OrderAgent", "CompensationAgent", "SupervisorAgent"]}')
+                       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(
-                    """INSERT INTO knowledge_graphs (filename, entity_count, relation_count,
+                    text("""INSERT INTO knowledge_graphs (filename, entity_count, relation_count,
                        status, trace_id, window_index, window_total, processing_run_id)
-                       VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
-                    ("demo_kg.json", 5, 4, "completed", trace_id, 0, 1, "demo_run")
+                       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("SELECT id FROM knowledge_graphs WHERE trace_id = ?", (trace_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")
@@ -193,12 +218,19 @@ def add_sample_data_for_hf():
                 for i, (entity_id, entity_type, name, properties) in enumerate(entities, 1):
                     print(f"   • Inserting entity {i}/5: {name} ({entity_type})")
                     conn.execute(
-                        """INSERT INTO entities (graph_id, entity_id, type, name, properties)
-                           VALUES (?, ?, ?, ?, ?)""",
-                        (kg_id, entity_id, entity_type, name, properties)
+                        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("SELECT id FROM entities WHERE graph_id = ? AND entity_id = ?", (kg_id, entity_id))
+                    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}")
@@ -221,9 +253,16 @@ def add_sample_data_for_hf():
                     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(
-                        """INSERT INTO relations (graph_id, relation_id, type, source_id, target_id, properties) 
-                           VALUES (?, ?, ?, ?, ?, ?)""",
-                        (kg_id, relation_id, relation_type, source_db_id, target_db_id, properties)
+                        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")
                 
@@ -234,10 +273,10 @@ def add_sample_data_for_hf():
                 
                 print("🔍 Verifying final data counts...")
                 # Verify data
-                final_traces = conn.execute("SELECT COUNT(*) FROM traces").fetchone()[0]
-                final_kgs = conn.execute("SELECT COUNT(*) FROM knowledge_graphs").fetchone()[0]
-                final_entities = conn.execute("SELECT COUNT(*) FROM entities").fetchone()[0]
-                final_relations = conn.execute("SELECT COUNT(*) FROM relations").fetchone()[0]
+                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:")