Update app.py

app.py

@@ -1,12 +1,12 @@
 """
-Hugging Face Spaces Entry Point for CSRC Car Manual RAG System
-Optimized version with timeout protection and lazy loading
+Performance-Optimized Hugging Face Spaces Entry Point
+Solves slow response and loading issues
 """
 import os
 import sys
 from pathlib import Path
-import signal
-from contextlib import contextmanager
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
 
 # Add the current directory to Python path for Spaces environment
 sys.path.insert(0, str(Path(__file__).parent))
@@ -47,31 +47,28 @@ except ImportError as e:
     SCENARIO_CONTEXTUALIZATION_AVAILABLE = False
     print(f"⚠️ Scenario contextualization modules not available: {e}")
 
+# Performance configuration
+ENABLE_CACHING = True  # Enable query caching
+MAX_WORKERS = 4  # Thread pool size
+QUERY_TIMEOUT = 30  # Query timeout in seconds
 
-class TimeoutError(Exception):
-    pass
+# Global thread pool for async processing
+executor = ThreadPoolExecutor(max_workers=MAX_WORKERS)
 
-
-@contextmanager
-def timeout(seconds):
-    """Context manager for timeout operations"""
-    def timeout_handler(signum, frame):
-        raise TimeoutError(f"Operation timed out after {seconds} seconds")
-    
-    # Set the signal handler
-    old_handler = signal.signal(signal.SIGALRM, timeout_handler)
-    signal.alarm(seconds)
-    
-    try:
-        yield
-    finally:
-        # Restore the old handler
-        signal.alarm(0)
-        signal.signal(signal.SIGALRM, old_handler)
+# Simple in-memory cache for queries
+query_cache = {}
 
 
 def initialize_system(config: Config) -> dict:
-    """Initialize the RAG system components"""
+    """
+    Initialize the RAG system components with performance optimization
+    
+    Args:
+        config: Configuration object
+        
+    Returns:
+        Dictionary containing all initialized components
+    """
     print("🔧 Initializing core components...")
     
     # Initialize OpenAI client
@@ -122,62 +119,48 @@ def initialize_system(config: Config) -> dict:
     print("🔧 Initializing knowledge graph...")
     knowledge_graph = KnowledgeGraphGenerator(client, vector_store_id, str(config.output_dir))
     
-    # Initialize personalized learning (if available) - with timeout
+    # Initialize optional modules (with reduced logging)
     user_profiling = None
     learning_path_generator = None
     adaptive_engine = None
     
     if PERSONALIZED_LEARNING_AVAILABLE:
         try:
-            print("🔧 Initializing personalized learning...")
-            with timeout(10):
-                user_profiling = UserProfilingSystem()
-                learning_path_generator = LearningPathGenerator(user_profiling, config.available_topics)
-                adaptive_engine = AdaptiveLearningEngine(user_profiling, learning_path_generator)
+            user_profiling = UserProfilingSystem()
+            learning_path_generator = LearningPathGenerator(user_profiling, config.available_topics)
+            adaptive_engine = AdaptiveLearningEngine(user_profiling, learning_path_generator)
             print("✅ Personalized Learning System initialized!")
-        except TimeoutError:
-            print("⚠️ Personalized Learning System initialization timed out - skipping")
         except Exception as e:
             print(f"⚠️ Error initializing Personalized Learning System: {e}")
     
-    # Initialize proactive learning (if available) - with timeout
     proactive_engine = None
     if PROACTIVE_LEARNING_AVAILABLE and user_profiling:
         try:
-            print("🔧 Initializing proactive learning...")
-            with timeout(10):
-                proactive_engine = ProactiveLearningEngine(
-                    client, rag_engine, user_profiling, adaptive_engine, config.available_topics
-                )
+            proactive_engine = ProactiveLearningEngine(
+                client, rag_engine, user_profiling, adaptive_engine, config.available_topics
+            )
             print("✅ Proactive Learning Assistance initialized!")
-        except TimeoutError:
-            print("⚠️ Proactive Learning Assistance initialization timed out - skipping")
         except Exception as e:
             print(f"⚠️ Error initializing Proactive Learning Assistance: {e}")
     
-    # Initialize scenario contextualization (if available) - with timeout
     enhanced_rag_engine = None
     if SCENARIO_CONTEXTUALIZATION_AVAILABLE:
         try:
-            print("🔧 Initializing scenario contextualization...")
-            with timeout(15):
-                scenario_database = ScenarioDatabase()
-                feature_extractor = ADASFeatureExtractor(use_llm=False, client=client)
-                scenario_retriever = ScenarioRetriever(
-                    scenario_database=scenario_database,
-                    scenario_vector_store_id=None,
-                    client=client
-                )
-                formatter = ConstructiveFormatter()
-                enhanced_rag_engine = EnhancedRAGEngine(
-                    base_rag_engine=rag_engine,
-                    scenario_retriever=scenario_retriever,
-                    feature_extractor=feature_extractor,
-                    formatter=formatter
-                )
+            scenario_database = ScenarioDatabase()
+            feature_extractor = ADASFeatureExtractor(use_llm=False, client=client)
+            scenario_retriever = ScenarioRetriever(
+                scenario_database=scenario_database,
+                scenario_vector_store_id=None,
+                client=client
+            )
+            formatter = ConstructiveFormatter()
+            enhanced_rag_engine = EnhancedRAGEngine(
+                base_rag_engine=rag_engine,
+                scenario_retriever=scenario_retriever,
+                feature_extractor=feature_extractor,
+                formatter=formatter
+            )
             print("✅ Scenario Contextualization initialized!")
-        except TimeoutError:
-            print("⚠️ Scenario Contextualization initialization timed out - skipping")
         except Exception as e:
             print(f"⚠️ Error initializing Scenario Contextualization: {e}")
     
@@ -197,41 +180,87 @@ def initialize_system(config: Config) -> dict:
     }
 
 
+def create_optimized_query_wrapper(rag_engine):
+    """
+    Create an optimized query wrapper with caching, timeout, and async processing
+    
+    Args:
+        rag_engine: The RAG query engine to wrap
+        
+    Returns:
+        Optimized query function
+    """
+    def query_with_optimization(question: str, use_cache: bool = True) -> str:
+        """
+        Optimized query function with caching and timeout protection
+        
+        Args:
+            question: User's question
+            use_cache: Whether to use cache (default: True)
+            
+        Returns:
+            Answer string
+        """
+        if not question or not question.strip():
+            return "Please enter a question."
+        
+        # Normalize question for cache key
+        cache_key = question.strip().lower()
+        
+        # Check cache
+        if use_cache and ENABLE_CACHING and cache_key in query_cache:
+            print(f"📋 Using cached result for: {question[:50]}...")
+            return query_cache[cache_key]
+        
+        try:
+            print(f"🔍 Processing query: {question[:50]}...")
+            
+            # Execute query using thread pool (non-blocking)
+            future = executor.submit(rag_engine.query, question)
+            
+            # Wait for result with timeout
+            result = future.result(timeout=QUERY_TIMEOUT)
+            
+            # Cache the result
+            if ENABLE_CACHING:
+                query_cache[cache_key] = result
+                # Limit cache size
+                if len(query_cache) > 100:
+                    # Remove oldest entry
+                    query_cache.pop(next(iter(query_cache)))
+            
+            print(f"✅ Query completed successfully")
+            return result
+            
+        except TimeoutError:
+            error_msg = "⏱️ Query timeout. Please try a simpler question or try again later."
+            print(error_msg)
+            return error_msg
+        except Exception as e:
+            error_msg = f"❌ Error processing query: {str(e)}"
+            print(error_msg)
+            return error_msg
+    
+    return query_with_optimization
+
+
 def create_app():
-    """Create and return the Gradio app for Hugging Face Spaces"""
+    """
+    Create and return the optimized Gradio app for Hugging Face Spaces
+    
+    Returns:
+        Gradio Blocks app
+    """
     print("=" * 60)
-    print("🚗 CSRC Car Manual RAG System - Hugging Face Spaces")
+    print("🚗 CSRC Car Manual RAG System - Performance Optimized")
     print("=" * 60)
     
     # Load configuration
     config = Config()
     
-    # Initialize system with timeout
+    # Initialize system
     try:
-        print("⏱️  Starting initialization (max 90 seconds)...")
-        with timeout(90):
-            components = initialize_system(config)
-    except TimeoutError:
-        print("❌ System initialization timed out!")
-        import gradio as gr
-        error_msg = """
-        # ❌ Initialization Timeout
-        
-        The system took too long to initialize. This usually happens when:
-        1. Vector store creation is slow
-        2. Too many modules are being loaded at startup
-        
-        **Suggested solutions:**
-        1. Reduce the number of modules loaded at startup
-        2. Use a smaller vector store
-        3. Implement lazy loading for optional features
-        """
-        return gr.Interface(
-            fn=lambda: error_msg,
-            inputs=None,
-            outputs=gr.Markdown(),
-            title="CSRC Car Manual RAG System",
-        )
+        components = initialize_system(config)
     except Exception as e:
         print(f"❌ Error initializing system: {e}")
         import traceback
@@ -243,15 +272,7 @@ def create_app():
         
         **Error:** {str(e)}
         
-        **Possible solutions:**
-        1. Check if OPENAI_API_KEY is set in Spaces Secrets (Settings > Secrets)
-        2. Ensure PDF files are in the `car_manual/` directory
-        3. Check the logs for more details
-        
-        **Traceback:**
-        ```
-        {traceback.format_exc()}
-        ```
+        Please check the logs for more details.
         """
         
         return gr.Interface(
@@ -261,46 +282,39 @@ def create_app():
             title="CSRC Car Manual RAG System",
         )
     
-    # Build Gradio interface with timeout
+    # Create optimized query wrapper
+    optimized_query = create_optimized_query_wrapper(components["rag_engine"])
+    
+    # Replace original RAG engine query method with optimized version
+    original_query = components["rag_engine"].query
+    components["rag_engine"].query = optimized_query
+    
+    # Build Gradio interface
     print("\n🌐 Building Gradio interface...")
     try:
-        print("⏱️  Creating interface (max 30 seconds)...")
-        with timeout(30):
-            interface_builder = GradioInterfaceBuilder(
-                rag_engine=components["rag_engine"],
-                question_generator=components["question_generator"],
-                knowledge_graph=components["knowledge_graph"],
-                config=components["config"],
-                user_profiling=components["user_profiling"],
-                adaptive_engine=components["adaptive_engine"],
-                proactive_engine=components["proactive_engine"]
-            )
-            
-            print("📦 Creating interface components...")
-            demo = interface_builder.create_interface()
-        print("✅ Gradio interface created successfully!")
-        return demo
-    except TimeoutError:
-        print("❌ Gradio interface creation timed out!")
-        import gradio as gr
-        error_msg = """
-        # ❌ Interface Creation Timeout
+        interface_builder = GradioInterfaceBuilder(
+            rag_engine=components["rag_engine"],
+            question_generator=components["question_generator"],
+            knowledge_graph=components["knowledge_graph"],
+            config=components["config"],
+            user_profiling=components["user_profiling"],
+            adaptive_engine=components["adaptive_engine"],
+            proactive_engine=components["proactive_engine"]
+        )
         
-        The Gradio interface took too long to create. This usually happens when:
-        1. Too many components are being created
-        2. Complex initialization in component callbacks
+        print("📦 Creating interface components...")
+        demo = interface_builder.create_interface()
         
-        **Suggested solutions:**
-        1. Simplify the interface
-        2. Use lazy loading for complex components
-        3. Move initialization logic out of interface creation
-        """
-        return gr.Interface(
-            fn=lambda: error_msg,
-            inputs=None,
-            outputs=gr.Markdown(),
-            title="CSRC Car Manual RAG System",
+        # Enable queue for better performance
+        print("⚡ Enabling queue for better performance...")
+        demo.queue(
+            max_size=20,  # Maximum queue size
+            default_concurrency_limit=5  # Concurrency limit
         )
+        
+        print("✅ Gradio interface created successfully!")
+        return demo
+        
     except Exception as e:
         print(f"❌ Error building Gradio interface: {e}")
         import traceback
@@ -311,11 +325,6 @@ def create_app():
         # ❌ Interface Building Error
         
         **Error:** {str(e)}
-        
-        **Traceback:**
-        ```
-        {traceback.format_exc()}
-        ```
         """
         
         return gr.Interface(
@@ -326,11 +335,16 @@ def create_app():
         )
 
 
-# Prevent multiple initializations
+# Prevent multiple initializations using singleton pattern
 _app_instance = None
 
 def get_app():
-    """Get or create the app instance (singleton pattern)"""
+    """
+    Get or create the app instance (singleton pattern)
+    
+    Returns:
+        Gradio app instance
+    """
     global _app_instance
     if _app_instance is None:
         print("🔄 Creating new app instance...")
@@ -341,10 +355,15 @@ def get_app():
     return _app_instance
 
 
-# For Hugging Face Spaces
+# For Hugging Face Spaces auto-detection
 if __name__ == "__main__":
     demo = get_app()
-    demo.launch()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,  # Show detailed errors
+        favicon_path=None,  # Skip favicon loading for faster startup
+    )
 else:
     # Module-level variable for Spaces auto-detection
     demo = get_app()