Update app.py

app.py

@@ -1,276 +1,126 @@
 """
-Hugging Face Spaces Entry Point for CSRC Car Manual RAG System
-This is the entry point for Hugging Face Spaces deployment
+Minimal version of app.py for Hugging Face Spaces
+Use this for testing if the full version doesn't work
 """
 import os
-import sys
-from pathlib import Path
-
-# Add the current directory to Python path for Spaces environment
-sys.path.insert(0, str(Path(__file__).parent))
-
+import gradio as gr
 from openai import OpenAI
-from src.config import Config
-from src.vector_store import VectorStoreManager
-from src.rag_query import RAGQueryEngine
-from src.question_generator import QuestionGenerator
-from src.knowledge_graph import KnowledgeGraphGenerator
-from src.gradio_interface import GradioInterfaceBuilder
-
-# Import personalized learning if available
-try:
-    from modules.personalized_learning import UserProfilingSystem, LearningPathGenerator, AdaptiveLearningEngine
-    PERSONALIZED_LEARNING_AVAILABLE = True
-except ImportError:
-    PERSONALIZED_LEARNING_AVAILABLE = False
-    print("⚠️ Personalized learning modules not available")
 
-# Import proactive learning if available
-try:
-    from modules.proactive_learning import ProactiveLearningEngine
-    PROACTIVE_LEARNING_AVAILABLE = True
-except ImportError:
-    PROACTIVE_LEARNING_AVAILABLE = False
-    print("⚠️ Proactive learning modules not available")
+# Simple configuration
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+VECTOR_STORE_ID = os.getenv("VECTOR_STORE_ID", "vs_69022a9edd74819199bf9a34a83e877b")
+MODEL = "gpt-4o-mini"
 
-# Import scenario contextualization if available
-try:
-    from modules.scenario_contextualization.database.scenario_database import ScenarioDatabase
-    from modules.scenario_contextualization.integration.feature_extractor import ADASFeatureExtractor
-    from modules.scenario_contextualization.retrieval.scenario_retriever import ScenarioRetriever
-    from modules.scenario_contextualization.formatting.constructive_formatter import ConstructiveFormatter
-    from modules.scenario_contextualization.integration.enhanced_rag_engine import EnhancedRAGEngine
-    SCENARIO_CONTEXTUALIZATION_AVAILABLE = True
-except ImportError as e:
-    SCENARIO_CONTEXTUALIZATION_AVAILABLE = False
-    print(f"⚠️ Scenario contextualization modules not available: {e}")
 
-
-def initialize_system(config: Config) -> dict:
-    """Initialize the RAG system components"""
-    # Initialize OpenAI client
-    if not config.openai_api_key:
-        raise ValueError(
-            "OPENAI_API_KEY not found! Please set it in Hugging Face Spaces Secrets. "
-            "Go to Settings > Secrets and add OPENAI_API_KEY"
-        )
-    
-    client = OpenAI(api_key=config.openai_api_key)
+def query_rag(question: str) -> str:
+    """Simple RAG query function"""
+    if not OPENAI_API_KEY:
+        return "❌ Error: OPENAI_API_KEY not set in Spaces Secrets"
     
-    # Initialize vector store manager
-    vector_store_manager = VectorStoreManager(client)
+    if not VECTOR_STORE_ID:
+        return "❌ Error: VECTOR_STORE_ID not set"
     
-    # Get or create vector store
-    vector_store_id = config.get_vector_store_id()
-    
-    if not vector_store_id:
-        print("📦 Creating new vector store...")
-        pdf_files = config.get_pdf_files()
+    try:
+        client = OpenAI(api_key=OPENAI_API_KEY)
+        
+        # Create assistant with file search
+        assistant = client.beta.assistants.create(
+            name="Car Manual Assistant",
+            instructions="You are a helpful assistant that answers questions about car manuals.",
+            model=MODEL,
+            tools=[{"type": "file_search"}],
+            tool_resources={"file_search": {"vector_store_ids": [VECTOR_STORE_ID]}}
+        )
         
-        if not pdf_files:
-            raise ValueError(f"No PDF files found in {config.car_manual_dir}")
+        # Create thread and run
+        thread = client.beta.threads.create()
         
-        vector_store_details = vector_store_manager.create_vector_store(config.vector_store_name)
-        if not vector_store_details:
-            raise RuntimeError("Failed to create vector store")
+        message = client.beta.threads.messages.create(
+            thread_id=thread.id,
+            role="user",
+            content=question
+        )
         
-        vector_store_id = vector_store_details["id"]
-        config.save_vector_store_id(vector_store_id, config.vector_store_name)
+        run = client.beta.threads.runs.create_and_poll(
+            thread_id=thread.id,
+            assistant_id=assistant.id
+        )
         
-        # Upload files
-        upload_stats = vector_store_manager.upload_pdf_files(pdf_files, vector_store_id)
-        if upload_stats["successful_uploads"] == 0:
-            raise RuntimeError("Failed to upload any files")
-    else:
-        print(f"✅ Using existing vector store: {vector_store_id}")
-    
-    # Initialize RAG query engine
-    rag_engine = RAGQueryEngine(client, vector_store_id, config.model)
-    
-    # Initialize question generator
-    question_generator = QuestionGenerator(client, rag_engine)
-    
-    # Initialize knowledge graph generator
-    knowledge_graph = KnowledgeGraphGenerator(client, vector_store_id, str(config.output_dir))
-    
-    # Initialize personalized learning (if available)
-    user_profiling = None
-    learning_path_generator = None
-    adaptive_engine = None
-    
-    if PERSONALIZED_LEARNING_AVAILABLE:
-        try:
-            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 Exception as e:
-            print(f"⚠️ Error initializing Personalized Learning System: {e}")
-    
-    # Initialize proactive learning (if available)
-    proactive_engine = None
-    if PROACTIVE_LEARNING_AVAILABLE and user_profiling:
-        try:
-            proactive_engine = ProactiveLearningEngine(
-                client, rag_engine, user_profiling, adaptive_engine, config.available_topics
-            )
-            print("✅ Proactive Learning Assistance initialized!")
-        except Exception as e:
-            print(f"⚠️ Error initializing Proactive Learning Assistance: {e}")
-    
-    # Initialize scenario contextualization (if available)
-    enhanced_rag_engine = None
-    if SCENARIO_CONTEXTUALIZATION_AVAILABLE:
-        try:
-            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 Exception as e:
-            print(f"⚠️ Error initializing Scenario Contextualization: {e}")
-            import traceback
-            traceback.print_exc()
-    
-    return {
-        "client": client,
-        "vector_store_manager": vector_store_manager,
-        "rag_engine": rag_engine,
-        "question_generator": question_generator,
-        "knowledge_graph": knowledge_graph,
-        "user_profiling": user_profiling,
-        "learning_path_generator": learning_path_generator,
-        "adaptive_engine": adaptive_engine,
-        "proactive_engine": proactive_engine,
-        "enhanced_rag_engine": enhanced_rag_engine,
-        "config": config
-    }
+        if run.status == 'completed':
+            messages = client.beta.threads.messages.list(thread_id=thread.id)
+            response = messages.data[0].content[0].text.value
+            
+            # Cleanup
+            client.beta.assistants.delete(assistant.id)
+            
+            return response
+        else:
+            return f"❌ Query failed with status: {run.status}"
+            
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
 
 
-def create_app():
-    """Create and return the Gradio app for Hugging Face Spaces"""
-    print("=" * 60)
-    print("🚗 CSRC Car Manual RAG System - Hugging Face Spaces")
-    print("=" * 60)
+# Create Gradio interface
+def create_interface():
+    """Create minimal Gradio interface"""
     
-    # Load configuration
-    config = Config()
-    
-    # Initialize system
-    try:
-        components = initialize_system(config)
-    except Exception as e:
-        print(f"❌ Error initializing system: {e}")
-        import gradio as gr
-        
-        # Create error interface
-        error_msg = f"""
-        # ❌ Initialization Error
-        
-        **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
-        """
-        
-        def error_display():
-            return error_msg
-        
-        error_interface = gr.Interface(
-            fn=error_display,
-            inputs=None,
-            outputs=gr.Markdown(),
-            title="CSRC Car Manual RAG System",
-            description="An error occurred during initialization. Please check the logs."
+    with gr.Blocks(title="CSRC Car Manual RAG") as demo:
+        gr.Markdown("""
+        # 🚗 CSRC Car Manual RAG System
+        ## Minimal Version for Testing
+        
+        This is a simplified version for testing Hugging Face Spaces deployment.
+        """)
+        
+        with gr.Row():
+            with gr.Column():
+                question_input = gr.Textbox(
+                    label="Your Question",
+                    placeholder="Ask anything about the car manual...",
+                    lines=3
+                )
+                submit_btn = gr.Button("Submit", variant="primary")
+                
+            with gr.Column():
+                answer_output = gr.Textbox(
+                    label="Answer",
+                    lines=10
+                )
+        
+        gr.Examples(
+            examples=[
+                ["What are the main features of the adaptive cruise control?"],
+                ["How do I use the parking assist system?"],
+                ["What should I check during regular maintenance?"]
+            ],
+            inputs=question_input
         )
-        return error_interface
-    
-    # Build Gradio interface
-    print("\n🌐 Building Gradio interface...")
-    try:
-        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 Exception as e:
-        print(f"❌ Error building Gradio interface: {e}")
-        import traceback
-        traceback.print_exc()
         
-        # Return error interface
-        import gradio as gr
-        error_msg = f"""
-        # ❌ Interface Building Error
-        
-        **Error:** {str(e)}
-        
-        **Possible solutions:**
-        1. Check Gradio version compatibility
-        2. Check the logs for detailed error information
-        3. Verify all dependencies are installed correctly
-        
-        **Traceback:**
-        ```
-        {traceback.format_exc()}
-        ```
-        """
-        
-        def error_display():
-            return error_msg
-        
-        error_interface = gr.Interface(
-            fn=error_display,
-            inputs=None,
-            outputs=gr.Markdown(),
-            title="CSRC Car Manual RAG System",
-            description="An error occurred while building the interface. Please check the logs."
+        submit_btn.click(
+            fn=query_rag,
+            inputs=question_input,
+            outputs=answer_output
         )
-        return error_interface
+        
+        gr.Markdown("""
+        ---
+        ### Status
+        - ✅ Using vector store: `{}`
+        - 🔑 API Key: {}
+        """.format(
+            VECTOR_STORE_ID,
+            "✅ Set" if OPENAI_API_KEY else "❌ Not Set"
+        ))
+    
+    return demo
 
 
-# Create the app for Hugging Face Spaces
-# Spaces will automatically detect Gradio and run this
-# Use module-level variable to prevent multiple initializations
-if 'demo' not in globals():
-    try:
-        print("🔄 Initializing app...")
-        demo = create_app()
-        print("✅ App initialized successfully!")
-    except Exception as e:
-        print(f"❌ Error creating app: {e}")
-        import traceback
-        traceback.print_exc()
-        # Create a minimal error interface
-        import gradio as gr
-        demo = gr.Interface(
-            fn=lambda: f"Error: {str(e)}\n\nPlease check the logs for details.",
-            inputs=None,
-            outputs=gr.Textbox(),
-            title="CSRC Car Manual RAG System - Error",
-            description="An error occurred during initialization. Please check the logs."
-        )
-else:
-    print("ℹ️  App already initialized, reusing existing instance")
+# Create and launch
+print("🔄 Creating minimal app...")
+demo = create_interface()
+print("✅ App created!")
 
+if __name__ == "__main__":
+    print("🚀 Launching app...")
+    demo.launch()