fixed all bugs

app.py

@@ -271,6 +271,14 @@ class ContentOrganizerMCPServer:
             return {"success": False, "error": str(e)}
 
 mcp_server = ContentOrganizerMCPServer()
+try:
+    print("⏳ Initializing LlamaIndex Service...")
+    # Use the fixed run_async method to safely initialize
+    mcp_server.run_async(mcp_server.llamaindex_service.initialize())
+    print("✅ LlamaIndex Initialized Successfully!")
+except Exception as e:
+    print(f"⚠️ Warning during LlamaIndex init: {e}")
+
 
 def get_document_list():
     try:
@@ -345,6 +353,9 @@ def upload_and_process_file(file):
         file_type = Path(file_path).suffix.lower().strip('.')
         logger.info(f"Processing file: {file_path}, type: {file_type}")
         result = mcp_server.run_async(mcp_server.ingest_document_async(file_path, file_type))
+        if result["success"]:
+            logger.info("Syncing LlamaIndex with new document...")
+            mcp_server.run_async(mcp_server.llamaindex_service.sync_on_demand())
         
         doc_list_updated = get_document_list()
         doc_choices_updated = get_document_choices()
@@ -634,278 +645,278 @@ voice_conversation_state = {
     "transcript": []
 }
 
-voice_conversation_state = {
-    "session_id": None,
-    "active": False,
-    "transcript": []
-}
+# voice_conversation_state = {
+#     "session_id": None,
+#     "active": False,
+#     "transcript": []
+# }
 
-def start_voice_conversation():
-    """
-    Start a new voice conversation session
+# def start_voice_conversation():
+#     """
+#     Start a new voice conversation session
     
-    Returns:
-        Tuple of (status_message, start_button_state, stop_button_state, chatbot_history)
-    """
-    try:
-        # Check if service is available
-        if not mcp_server.elevenlabs_service.is_available():
-            return (
-                "⚠️ Voice assistant not configured.\n\n"
-                "**Setup Instructions:**\n"
-                "1. Get API key from: https://elevenlabs.io/app/settings/api-keys\n"
-                "2. Create an agent at: https://elevenlabs.io/app/conversational-ai\n"
-                "3. Add to .env file:\n"
-                "   - ELEVENLABS_API_KEY=your_api_key\n"
-                "   - ELEVENLABS_AGENT_ID=your_agent_id\n"
-                "4. Restart the application",
-                gr.update(interactive=True),   # start button enabled
-                gr.update(interactive=False),  # stop button disabled
-                []
-            )
+#     Returns:
+#         Tuple of (status_message, start_button_state, stop_button_state, chatbot_history)
+#     """
+#     try:
+#         # Check if service is available
+#         if not mcp_server.elevenlabs_service.is_available():
+#             return (
+#                 "⚠️ Voice assistant not configured.\n\n"
+#                 "**Setup Instructions:**\n"
+#                 "1. Get API key from: https://elevenlabs.io/app/settings/api-keys\n"
+#                 "2. Create an agent at: https://elevenlabs.io/app/conversational-ai\n"
+#                 "3. Add to .env file:\n"
+#                 "   - ELEVENLABS_API_KEY=your_api_key\n"
+#                 "   - ELEVENLABS_AGENT_ID=your_agent_id\n"
+#                 "4. Restart the application",
+#                 gr.update(interactive=True),   # start button enabled
+#                 gr.update(interactive=False),  # stop button disabled
+#                 []
+#             )
         
-        # Create new session
-        session_id = str(uuid.uuid4())
-        result = mcp_server.run_async(
-            mcp_server.elevenlabs_service.start_conversation(session_id)
-        )
+#         # Create new session
+#         session_id = str(uuid.uuid4())
+#         result = mcp_server.run_async(
+#             mcp_server.elevenlabs_service.start_conversation(session_id)
+#         )
         
-        if result.get("success"):
-            voice_conversation_state["session_id"] = session_id
-            voice_conversation_state["active"] = True
-            voice_conversation_state["transcript"] = []
+#         if result.get("success"):
+#             voice_conversation_state["session_id"] = session_id
+#             voice_conversation_state["active"] = True
+#             voice_conversation_state["transcript"] = []
             
-            # Initialize chatbot with welcome message
-            initial_message = {
-                "role": "assistant",
-                "content": "👋 Hello! I'm your AI librarian. Ask me anything about your documents!"
-            }
+#             # Initialize chatbot with welcome message
+#             initial_message = {
+#                 "role": "assistant",
+#                 "content": "👋 Hello! I'm your AI librarian. Ask me anything about your documents!"
+#             }
             
-            return (
-                "✅ Voice assistant is ready!\n\n"
-                "You can now ask questions about your uploaded documents.",
-                gr.update(interactive=False),  # start button disabled
-                gr.update(interactive=True),   # stop button enabled
-                [initial_message]
-            )
-        else:
-            error_msg = result.get("error", "Unknown error")
-            return (
-                f"❌ Failed to start: {error_msg}\n\n"
-                "**Troubleshooting:**\n"
-                "• Check your API key is valid\n"
-                "• Verify agent ID is correct\n"
-                "• Check internet connection",
-                gr.update(interactive=True),
-                gr.update(interactive=False),
-                []
-            )
-    except Exception as e:
-        logger.error(f"Error starting voice conversation: {str(e)}", exc_info=True)
-        return (
-            f"❌ Error: {str(e)}",
-            gr.update(interactive=True),
-            gr.update(interactive=False),
-            []
-        )
-
-def stop_voice_conversation():
-    """
-    Stop active voice conversation
+#             return (
+#                 "✅ Voice assistant is ready!\n\n"
+#                 "You can now ask questions about your uploaded documents.",
+#                 gr.update(interactive=False),  # start button disabled
+#                 gr.update(interactive=True),   # stop button enabled
+#                 [initial_message]
+#             )
+#         else:
+#             error_msg = result.get("error", "Unknown error")
+#             return (
+#                 f"❌ Failed to start: {error_msg}\n\n"
+#                 "**Troubleshooting:**\n"
+#                 "• Check your API key is valid\n"
+#                 "• Verify agent ID is correct\n"
+#                 "• Check internet connection",
+#                 gr.update(interactive=True),
+#                 gr.update(interactive=False),
+#                 []
+#             )
+#     except Exception as e:
+#         logger.error(f"Error starting voice conversation: {str(e)}", exc_info=True)
+#         return (
+#             f"❌ Error: {str(e)}",
+#             gr.update(interactive=True),
+#             gr.update(interactive=False),
+#             []
+#         )
+
+# def stop_voice_conversation():
+#     """
+#     Stop active voice conversation
     
-    Returns:
-        Tuple of (status_message, start_button_state, stop_button_state, chatbot_history)
-    """
-    try:
-        if not voice_conversation_state["active"]:
-            return (
-                "ℹ️ No active conversation",
-                gr.update(interactive=True),
-                gr.update(interactive=False),
-                voice_conversation_state["transcript"]
-            )
+#     Returns:
+#         Tuple of (status_message, start_button_state, stop_button_state, chatbot_history)
+#     """
+#     try:
+#         if not voice_conversation_state["active"]:
+#             return (
+#                 "ℹ️ No active conversation",
+#                 gr.update(interactive=True),
+#                 gr.update(interactive=False),
+#                 voice_conversation_state["transcript"]
+#             )
         
-        session_id = voice_conversation_state["session_id"]
-        if session_id:
-            mcp_server.run_async(
-                mcp_server.elevenlabs_service.end_conversation(session_id)
-            )
+#         session_id = voice_conversation_state["session_id"]
+#         if session_id:
+#             mcp_server.run_async(
+#                 mcp_server.elevenlabs_service.end_conversation(session_id)
+#             )
         
-        # Get conversation stats
-        message_count = len(voice_conversation_state["transcript"])
+#         # Get conversation stats
+#         message_count = len(voice_conversation_state["transcript"])
         
-        voice_conversation_state["active"] = False
-        voice_conversation_state["session_id"] = None
+#         voice_conversation_state["active"] = False
+#         voice_conversation_state["session_id"] = None
         
-        return (
-            f"✅ Conversation ended\n\n"
-            f"📊 Stats: {message_count} messages exchanged",
-            gr.update(interactive=True),
-            gr.update(interactive=False),
-            voice_conversation_state["transcript"]
-        )
-    except Exception as e:
-        logger.error(f"Error stopping conversation: {str(e)}")
-        return (
-            f"❌ Error: {str(e)}",
-            gr.update(interactive=True),
-            gr.update(interactive=False),
-            voice_conversation_state["transcript"]
-        )
-
-def send_voice_message_v6(message, chat_history):
-    """
-    Send message in voice conversation - Gradio 6+ format
+#         return (
+#             f"✅ Conversation ended\n\n"
+#             f"📊 Stats: {message_count} messages exchanged",
+#             gr.update(interactive=True),
+#             gr.update(interactive=False),
+#             voice_conversation_state["transcript"]
+#         )
+#     except Exception as e:
+#         logger.error(f"Error stopping conversation: {str(e)}")
+#         return (
+#             f"❌ Error: {str(e)}",
+#             gr.update(interactive=True),
+#             gr.update(interactive=False),
+#             voice_conversation_state["transcript"]
+#         )
+
+# def send_voice_message_v6(message, chat_history):
+#     """
+#     Send message in voice conversation - Gradio 6+ format
     
-    Args:
-        message: User's text message
-        chat_history: Current chat history (list of message dicts)
+#     Args:
+#         message: User's text message
+#         chat_history: Current chat history (list of message dicts)
     
-    Returns:
-        Tuple of (updated_chat_history, cleared_input_box)
-    """
-    try:
-        # Validate state
-        if not voice_conversation_state["active"]:
-            chat_history.append({
-                "role": "assistant",
-                "content": "⚠️ Please start a conversation first by clicking 'Start Conversation'"
-            })
-            return chat_history, ""
+#     Returns:
+#         Tuple of (updated_chat_history, cleared_input_box)
+#     """
+#     try:
+#         # Validate state
+#         if not voice_conversation_state["active"]:
+#             chat_history.append({
+#                 "role": "assistant",
+#                 "content": "⚠️ Please start a conversation first by clicking 'Start Conversation'"
+#             })
+#             return chat_history, ""
         
-        # Validate input
-        if not message or not message.strip():
-            return chat_history, message
+#         # Validate input
+#         if not message or not message.strip():
+#             return chat_history, message
         
-        session_id = voice_conversation_state["session_id"]
+#         session_id = voice_conversation_state["session_id"]
         
-        # Add user message to display
-        chat_history.append({
-            "role": "user",
-            "content": message
-        })
+#         # Add user message to display
+#         chat_history.append({
+#             "role": "user",
+#             "content": message
+#         })
         
-        # Show typing indicator
-        chat_history.append({
-            "role": "assistant",
-            "content": "🤔 Thinking..."
-        })
+#         # Show typing indicator
+#         chat_history.append({
+#             "role": "assistant",
+#             "content": "🤔 Thinking..."
+#         })
         
-        # Get AI response
-        result = mcp_server.run_async(
-            mcp_server.voice_tool.voice_qa(message, session_id)
-        )
+#         # Get AI response
+#         result = mcp_server.run_async(
+#             mcp_server.voice_tool.voice_qa(message, session_id)
+#         )
         
-        # Remove typing indicator
-        chat_history = chat_history[:-1]
+#         # Remove typing indicator
+#         chat_history = chat_history[:-1]
         
-        # Add response
-        if result.get("success"):
-            answer = result.get("answer", "No response")
+#         # Add response
+#         if result.get("success"):
+#             answer = result.get("answer", "No response")
             
-            # Add helpful context if RAG was used
-            if "document" in answer.lower() or "file" in answer.lower():
-                footer = "\n\n💡 *Answer based on your documents*"
-            else:
-                footer = ""
+#             # Add helpful context if RAG was used
+#             if "document" in answer.lower() or "file" in answer.lower():
+#                 footer = "\n\n💡 *Answer based on your documents*"
+#             else:
+#                 footer = ""
             
-            chat_history.append({
-                "role": "assistant",
-                "content": answer + footer
-            })
-        else:
-            error_msg = result.get("error", "Unknown error")
-            chat_history.append({
-                "role": "assistant",
-                "content": f"❌ Error: {error_msg}\n\n"
-                          "**Suggestions:**\n"
-                          "• Try rephrasing your question\n"
-                          "• Make sure you have uploaded relevant documents\n"
-                          "• Check if the question is about your document library"
-            })
+#             chat_history.append({
+#                 "role": "assistant",
+#                 "content": answer + footer
+#             })
+#         else:
+#             error_msg = result.get("error", "Unknown error")
+#             chat_history.append({
+#                 "role": "assistant",
+#                 "content": f"❌ Error: {error_msg}\n\n"
+#                           "**Suggestions:**\n"
+#                           "• Try rephrasing your question\n"
+#                           "• Make sure you have uploaded relevant documents\n"
+#                           "• Check if the question is about your document library"
+#             })
         
-        # Update conversation state
-        voice_conversation_state["transcript"] = chat_history
+#         # Update conversation state
+#         voice_conversation_state["transcript"] = chat_history
         
-        return chat_history, ""
+#         return chat_history, ""
         
-    except Exception as e:
-        logger.error(f"Error in voice message: {str(e)}", exc_info=True)
+#     except Exception as e:
+#         logger.error(f"Error in voice message: {str(e)}", exc_info=True)
         
-        # Remove typing indicator if present
-        if chat_history and chat_history[-1]["role"] == "assistant" and "Thinking" in chat_history[-1]["content"]:
-            chat_history = chat_history[:-1]
+#         # Remove typing indicator if present
+#         if chat_history and chat_history[-1]["role"] == "assistant" and "Thinking" in chat_history[-1]["content"]:
+#             chat_history = chat_history[:-1]
         
-        chat_history.append({
-            "role": "assistant",
-            "content": f"❌ An error occurred: {str(e)}\n\nPlease try again."
-        })
-        return chat_history, ""
-
-def test_voice_connection():
-    """
-    Test voice assistant connection
+#         chat_history.append({
+#             "role": "assistant",
+#             "content": f"❌ An error occurred: {str(e)}\n\nPlease try again."
+#         })
+#         return chat_history, ""
+
+# def test_voice_connection():
+#     """
+#     Test voice assistant connection
     
-    Returns:
-        Status message with test results
-    """
-    try:
-        result = mcp_server.run_async(
-            mcp_server.voice_tool.test_connection()
-        )
+#     Returns:
+#         Status message with test results
+#     """
+#     try:
+#         result = mcp_server.run_async(
+#             mcp_server.voice_tool.test_connection()
+#         )
         
-        if result.get("success"):
-            return (
-                "✅ **Connection Test Passed**\n\n"
-                f"• API Status: Connected\n"
-                f"• Voices Available: {result.get('voices_available', 0)}\n"
-                f"• RAG Tool: {'✓ Working' if result.get('rag_tool_working') else '✗ Failed'}\n"
-                f"• Client Tools: {'✓ Registered' if result.get('client_tools_registered') else '✗ Not Registered'}\n\n"
-                "🎉 Voice assistant is ready to use!"
-            )
-        else:
-            return (
-                "❌ **Connection Test Failed**\n\n"
-                f"Error: {result.get('message', 'Unknown error')}\n\n"
-                "**Troubleshooting:**\n"
-                "1. Verify ELEVENLABS_API_KEY in .env\n"
-                "2. Check ELEVENLABS_AGENT_ID is set\n"
-                "3. Ensure API key is valid\n"
-                "4. Check internet connection"
-            )
-    except Exception as e:
-        logger.error(f"Connection test error: {str(e)}")
-        return (
-            f"❌ **Test Error**\n\n{str(e)}\n\n"
-            "Please check your configuration and try again."
-        )
-
-def get_conversation_stats():
-    """
-    Get statistics about current conversation
+#         if result.get("success"):
+#             return (
+#                 "✅ **Connection Test Passed**\n\n"
+#                 f"• API Status: Connected\n"
+#                 f"• Voices Available: {result.get('voices_available', 0)}\n"
+#                 f"• RAG Tool: {'✓ Working' if result.get('rag_tool_working') else '✗ Failed'}\n"
+#                 f"• Client Tools: {'✓ Registered' if result.get('client_tools_registered') else '✗ Not Registered'}\n\n"
+#                 "🎉 Voice assistant is ready to use!"
+#             )
+#         else:
+#             return (
+#                 "❌ **Connection Test Failed**\n\n"
+#                 f"Error: {result.get('message', 'Unknown error')}\n\n"
+#                 "**Troubleshooting:**\n"
+#                 "1. Verify ELEVENLABS_API_KEY in .env\n"
+#                 "2. Check ELEVENLABS_AGENT_ID is set\n"
+#                 "3. Ensure API key is valid\n"
+#                 "4. Check internet connection"
+#             )
+#     except Exception as e:
+#         logger.error(f"Connection test error: {str(e)}")
+#         return (
+#             f"❌ **Test Error**\n\n{str(e)}\n\n"
+#             "Please check your configuration and try again."
+#         )
+
+# def get_conversation_stats():
+#     """
+#     Get statistics about current conversation
     
-    Returns:
-        Formatted stats string
-    """
-    try:
-        if not voice_conversation_state["active"]:
-            return "ℹ️ No active conversation"
+#     Returns:
+#         Formatted stats string
+#     """
+#     try:
+#         if not voice_conversation_state["active"]:
+#             return "ℹ️ No active conversation"
         
-        transcript = voice_conversation_state["transcript"]
-        user_msgs = sum(1 for msg in transcript if msg["role"] == "user")
-        ai_msgs = sum(1 for msg in transcript if msg["role"] == "assistant")
+#         transcript = voice_conversation_state["transcript"]
+#         user_msgs = sum(1 for msg in transcript if msg["role"] == "user")
+#         ai_msgs = sum(1 for msg in transcript if msg["role"] == "assistant")
         
-        return (
-            "📊 **Conversation Statistics**\n\n"
-            f"��� Session ID: {voice_conversation_state['session_id'][:8]}...\n"
-            f"• Your messages: {user_msgs}\n"
-            f"• AI responses: {ai_msgs}\n"
-            f"• Total exchanges: {user_msgs}\n"
-            f"• Status: {'🟢 Active' if voice_conversation_state['active'] else '🔴 Inactive'}"
-        )
-    except Exception as e:
-        logger.error(f"Error getting stats: {str(e)}")
-        return f"❌ Error: {str(e)}"
+#         return (
+#             "📊 **Conversation Statistics**\n\n"
+#             f"• Session ID: {voice_conversation_state['session_id'][:8]}...\n"
+#             f"• Your messages: {user_msgs}\n"
+#             f"• AI responses: {ai_msgs}\n"
+#             f"• Total exchanges: {user_msgs}\n"
+#             f"• Status: {'🟢 Active' if voice_conversation_state['active'] else '🔴 Inactive'}"
+#         )
+#     except Exception as e:
+#         logger.error(f"Error getting stats: {str(e)}")
+#         return f"❌ Error: {str(e)}"
 
 def generate_podcast_ui(doc_ids, style, duration, voice1, voice2):
     """UI wrapper for podcast generation"""
@@ -1340,120 +1351,120 @@ def create_gradio_interface():
                     outputs=[content_output_display]
                 )
 
-            with gr.Tab("🎙️ Voice Assistant"):
-                # Simple header
-                gr.Markdown("### Ask questions about your documents using AI")
+            # with gr.Tab("🎙️ Voice Assistant"):
+            #     # Simple header
+            #     gr.Markdown("### Ask questions about your documents using AI")
                 
-                with gr.Row():
-                    # Compact left sidebar (25% width)
-                    with gr.Column(scale=1):
-                        # Status box
-                        voice_status_display = gr.Textbox(
-                            label="Status",
-                            value="Click 'Start' to begin",
-                            interactive=False,
-                            lines=3,
-                            max_lines=3
-                        )
+            #     with gr.Row():
+            #         # Compact left sidebar (25% width)
+            #         with gr.Column(scale=1):
+            #             # Status box
+            #             voice_status_display = gr.Textbox(
+            #                 label="Status",
+            #                 value="Click 'Start' to begin",
+            #                 interactive=False,
+            #                 lines=3,
+            #                 max_lines=3
+            #             )
                         
-                        # Control buttons stacked vertically
-                        start_voice_btn = gr.Button(
-                            "🎤 Start",
-                            variant="primary",
-                            size="lg"
-                        )
+            #             # Control buttons stacked vertically
+            #             start_voice_btn = gr.Button(
+            #                 "🎤 Start",
+            #                 variant="primary",
+            #                 size="lg"
+            #             )
                         
-                        stop_voice_btn = gr.Button(
-                            "⏹️ Stop",
-                            variant="stop",
-                            size="lg",
-                            interactive=False
-                        )
+            #             stop_voice_btn = gr.Button(
+            #                 "⏹️ Stop",
+            #                 variant="stop",
+            #                 size="lg",
+            #                 interactive=False
+            #             )
                         
-                        test_connection_btn = gr.Button(
-                            "🔧 Test",
-                            variant="secondary",
-                            size="sm"
-                        )
+            #             test_connection_btn = gr.Button(
+            #                 "🔧 Test",
+            #                 variant="secondary",
+            #                 size="sm"
+            #             )
                         
-                        gr.Markdown("---")
+            #             gr.Markdown("---")
                         
-                        # Quick tips
-                        gr.Markdown("""
-                        **Quick Tips:**
-                        • Upload documents first
-                        • Ask specific questions
-                        • Press Enter to send
-                        """, elem_classes=["small-text"])
+            #             # Quick tips
+            #             gr.Markdown("""
+            #             **Quick Tips:**
+            #             • Upload documents first
+            #             • Ask specific questions
+            #             • Press Enter to send
+            #             """, elem_classes=["small-text"])
                     
-                    # Main chat area (75% width)
-                    with gr.Column(scale=3):
-                        # Large chat window
-                        voice_chatbot = gr.Chatbot(
-                            type="messages",
-                            height=550,
-                            show_copy_button=True,
-                            avatar_images=(None, "🤖"),
-                            show_label=False,
-                            container=True,
-                            bubble_full_width=False
-                        )
+            #         # Main chat area (75% width)
+            #         with gr.Column(scale=3):
+            #             # Large chat window
+            #             voice_chatbot = gr.Chatbot(
+            #                 type="messages",
+            #                 height=550,
+            #                 show_copy_button=True,
+            #                 avatar_images=(None, "🤖"),
+            #                 show_label=False,
+            #                 container=True,
+            #                 bubble_full_width=False
+            #             )
                         
-                        # Input row
-                        with gr.Row():
-                            voice_input_text = gr.Textbox(
-                                placeholder="Ask me anything about your documents...",
-                                lines=2,
-                                max_lines=4,
-                                scale=4,
-                                show_label=False,
-                                container=False,
-                                autofocus=True
-                            )
-                            send_voice_btn = gr.Button(
-                                "Send",
-                                scale=1,
-                                variant="primary"
-                            )
+            #             # Input row
+            #             with gr.Row():
+            #                 voice_input_text = gr.Textbox(
+            #                     placeholder="Ask me anything about your documents...",
+            #                     lines=2,
+            #                     max_lines=4,
+            #                     scale=4,
+            #                     show_label=False,
+            #                     container=False,
+            #                     autofocus=True
+            #                 )
+            #                 send_voice_btn = gr.Button(
+            #                     "Send",
+            #                     scale=1,
+            #                     variant="primary"
+            #                 )
                         
-                        # Footer actions
-                        with gr.Row():
-                            clear_chat_btn = gr.Button("Clear", size="sm")
-                            with gr.Column(scale=3):
-                                gr.Markdown("*Tip: Type your question and press Enter*")
+            #             # Footer actions
+            #             with gr.Row():
+            #                 clear_chat_btn = gr.Button("Clear", size="sm")
+            #                 with gr.Column(scale=3):
+            #                     gr.Markdown("*Tip: Type your question and press Enter*")
                 
-                # Event handlers
-                start_voice_btn.click(
-                    fn=start_voice_conversation,
-                    outputs=[voice_status_display, start_voice_btn, stop_voice_btn, voice_chatbot]
-                )
+            #     # Event handlers
+            #     start_voice_btn.click(
+            #         fn=start_voice_conversation,
+            #         outputs=[voice_status_display, start_voice_btn, stop_voice_btn, voice_chatbot]
+            #     )
                 
-                stop_voice_btn.click(
-                    fn=stop_voice_conversation,
-                    outputs=[voice_status_display, start_voice_btn, stop_voice_btn, voice_chatbot]
-                )
+            #     stop_voice_btn.click(
+            #         fn=stop_voice_conversation,
+            #         outputs=[voice_status_display, start_voice_btn, stop_voice_btn, voice_chatbot]
+            #     )
                 
-                send_voice_btn.click(
-                    fn=send_voice_message_v6,
-                    inputs=[voice_input_text, voice_chatbot],
-                    outputs=[voice_chatbot, voice_input_text]
-                )
+            #     send_voice_btn.click(
+            #         fn=send_voice_message_v6,
+            #         inputs=[voice_input_text, voice_chatbot],
+            #         outputs=[voice_chatbot, voice_input_text]
+            #     )
                 
-                voice_input_text.submit(
-                    fn=send_voice_message_v6,
-                    inputs=[voice_input_text, voice_chatbot],
-                    outputs=[voice_chatbot, voice_input_text]
-                )
+            #     voice_input_text.submit(
+            #         fn=send_voice_message_v6,
+            #         inputs=[voice_input_text, voice_chatbot],
+            #         outputs=[voice_chatbot, voice_input_text]
+            #     )
                 
-                clear_chat_btn.click(
-                    fn=lambda: [],
-                    outputs=[voice_chatbot]
-                )
+            #     clear_chat_btn.click(
+            #         fn=lambda: [],
+            #         outputs=[voice_chatbot]
+            #     )
                 
-                test_connection_btn.click(
-                    fn=test_voice_connection,
-                    outputs=[voice_status_display]
-                )
+            #     test_connection_btn.click(
+            #         fn=test_voice_connection,
+            #         outputs=[voice_status_display]
+            #     )
 
             with gr.Tab("🎧 Podcast Studio"):
                 gr.Markdown("""
@@ -1636,7 +1647,7 @@ def create_gradio_interface():
                                 show_copy_button=True
                             )
 
-        all_dropdowns_to_update = [delete_doc_dropdown_visible, doc_dropdown_content, doc_dropdown_tag_visible,podcast_doc_selector]
+        all_dropdowns_to_update = [delete_doc_dropdown_visible, doc_dropdown_content,podcast_doc_selector]
         
         refresh_outputs = [document_list_display] + [dd for dd in all_dropdowns_to_update]
         refresh_btn_library.click(fn=refresh_library, outputs=refresh_outputs)

services/elevenlabs_service.py

@@ -67,21 +67,23 @@ class ElevenLabsService:
     def _init_client_tools(self):
         """Initialize client tools for RAG integration"""
         try:
-            # Get or create event loop for ClientTools
+            # FIX: Try initializing without arguments first (Newer SDKs)
             try:
-                loop = asyncio.get_running_loop()
-            except RuntimeError:
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-            
-            # Initialize ClientTools with the loop
-            self.client_tools = ClientTools(loop=loop)
-            
+                self.client_tools = ClientTools()
+            except TypeError:
+                # Fallback for older SDKs that might require a loop
+                try:
+                    loop = asyncio.get_event_loop()
+                except RuntimeError:
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                self.client_tools = ClientTools(loop=loop)
+
             # Register RAG query tool with proper metadata
             self.client_tools.register(
                 "query_documents",
                 handler=self._rag_query_handler,
-                description="Search through the user's uploaded documents to find relevant information. Use this tool whenever the user asks questions about their documents, files, or content in their library.",
+                description="Search through the user's uploaded documents. Use this tool whenever the user asks questions about their documents, files, or content in their library.",
                 parameters={
                     "query": {
                         "type": "string",
@@ -95,6 +97,7 @@ class ElevenLabsService:
             
         except Exception as e:
             logger.error(f"Error initializing client tools: {str(e)}")
+            # Keep client_tools as None so we know it failed
             self.client_tools = None
     
     async def _rag_query_handler(self, params: Dict[str, Any]) -> Dict[str, Any]:

services/llamaindex_service.py

@@ -15,8 +15,6 @@ from llama_index.core import (
 )
 from llama_index.core.tools import QueryEngineTool, ToolMetadata
 from llama_index.core.agent import ReActAgent
-from llama_index.core.selectors import LLMSingleSelector
-from llama_index.core.query_engine import RouterQueryEngine
 from llama_index.llms.openai import OpenAI
 from llama_index.embeddings.huggingface import HuggingFaceEmbedding
 from llama_index.embeddings.openai import OpenAIEmbedding
@@ -36,8 +34,7 @@ class LlamaIndexService:
         self.is_initialized = False
         
         self._initialize_settings()
-        # We don't fully initialize index here because we need async access to doc store
-        # But we try to load existing storage if available
+        # Attempt to load existing index, but don't fail if empty
         self._try_load_from_storage()
 
     def _initialize_settings(self):
@@ -45,11 +42,9 @@ class LlamaIndexService:
         try:
             # LLM Setup
             if self.config.OPENAI_API_KEY:
-                # Use configured OpenAI model (gpt-5.1-chat-latest or similar)
                 Settings.llm = OpenAI(model=self.config.OPENAI_MODEL, api_key=self.config.OPENAI_API_KEY)
                 logger.info(f"LlamaIndex using OpenAI model: {self.config.OPENAI_MODEL}")
             elif self.config.NEBIUS_API_KEY:
-                # Use Nebius as OpenAI-compatible provider
                 Settings.llm = OpenAI(
                     model=self.config.NEBIUS_MODEL, 
                     api_key=self.config.NEBIUS_API_KEY, 
@@ -57,7 +52,7 @@ class LlamaIndexService:
                 )
                 logger.info(f"LlamaIndex using Nebius model: {self.config.NEBIUS_MODEL}")
             else:
-                logger.warning("No API key found for LlamaIndex LLM (OpenAI or Nebius). Agentic features may fail.")
+                logger.warning("No API key found for LlamaIndex LLM. Agentic features may fail.")
 
             # Embedding Setup
             if self.config.EMBEDDING_MODEL.startswith("text-embedding-"):
@@ -66,9 +61,7 @@ class LlamaIndexService:
                         model=self.config.EMBEDDING_MODEL,
                         api_key=self.config.OPENAI_API_KEY
                     )
-                    logger.info(f"LlamaIndex using OpenAI embeddings: {self.config.EMBEDDING_MODEL}")
                 else:
-                    logger.warning("OpenAI embedding model requested but no API key found. Falling back to HuggingFace.")
                     Settings.embed_model = HuggingFaceEmbedding(
                         model_name="sentence-transformers/all-MiniLM-L6-v2"
                     )
@@ -76,7 +69,6 @@ class LlamaIndexService:
                 Settings.embed_model = HuggingFaceEmbedding(
                     model_name=self.config.EMBEDDING_MODEL
                 )
-                logger.info(f"LlamaIndex using HuggingFace embeddings: {self.config.EMBEDDING_MODEL}")
             
         except Exception as e:
             logger.error(f"Error initializing LlamaIndex settings: {str(e)}")
@@ -84,14 +76,14 @@ class LlamaIndexService:
     def _try_load_from_storage(self):
         """Try to load index from storage synchronously"""
         try:
-            if self.storage_dir.exists():
+            if self.storage_dir.exists() and any(self.storage_dir.iterdir()):
                 logger.info("Loading LlamaIndex from storage...")
                 storage_context = StorageContext.from_defaults(persist_dir=str(self.storage_dir))
                 self.index = load_index_from_storage(storage_context)
                 self._initialize_agent()
                 self.is_initialized = True
             else:
-                logger.info("No existing LlamaIndex storage found. Waiting for async initialization.")
+                logger.info("No existing LlamaIndex storage found. Waiting for initialization.")
         except Exception as e:
             logger.error(f"Error loading LlamaIndex from storage: {str(e)}")
 
@@ -99,15 +91,11 @@ class LlamaIndexService:
         """Async initialization to sync documents and build index"""
         try:
             logger.info("Starting LlamaIndex async initialization...")
-            
-            # If we already have an index, we might still want to sync if it's empty or stale
-            # For now, if no index exists, we definitely need to build it
             if self.index is None:
                 await self.sync_from_document_store()
             
             self.is_initialized = True
             logger.info("LlamaIndex async initialization complete.")
-            
         except Exception as e:
             logger.error(f"Error during LlamaIndex async initialization: {str(e)}")
 
@@ -116,18 +104,19 @@ class LlamaIndexService:
         try:
             logger.info("Syncing documents from DocumentStore to LlamaIndex...")
             
-            # Fetch documents from async document store
-            # Limit to 1000 for now to avoid memory issues
             docs = await self.document_store.list_documents(limit=1000)
             
             if not docs:
-                logger.warning("No documents found in DocumentStore to sync.")
-                # Create empty index if no docs
-                self.index = VectorStoreIndex.from_documents([])
-            else:
-                # Convert to LlamaIndex documents
-                llama_docs = []
-                for doc in docs:
+                logger.warning("No documents found in DocumentStore. Creating empty index.")
+                # FIX: Handle empty state gracefully
+                self.index = None
+                self.agent = None
+                return
+
+            # Convert to LlamaIndex documents
+            llama_docs = []
+            for doc in docs:
+                if doc.content and len(doc.content.strip()) > 0:
                     llama_doc = Document(
                         text=doc.content,
                         metadata={
@@ -137,9 +126,13 @@ class LlamaIndexService:
                         }
                     )
                     llama_docs.append(llama_doc)
-                
-                logger.info(f"Building LlamaIndex with {len(llama_docs)} documents...")
-                self.index = VectorStoreIndex.from_documents(llama_docs)
+            
+            if not llama_docs:
+                logger.warning("Documents found but content was empty.")
+                return
+
+            logger.info(f"Building LlamaIndex with {len(llama_docs)} documents...")
+            self.index = VectorStoreIndex.from_documents(llama_docs)
             
             # Persist storage
             if not self.storage_dir.exists():
@@ -174,6 +167,7 @@ class LlamaIndexService:
                 )
             )
             
+            # ReAct Agent requires an LLM
             self.agent = ReActAgent.from_tools(
                 [query_engine_tool],
                 llm=Settings.llm,
@@ -186,14 +180,24 @@ class LlamaIndexService:
 
     async def query(self, query_text: str) -> str:
         """Process a query using the agent"""
+        
+        # 1. AUTO-RECOVERY: If agent is missing, try to initialize it now
+        if not self.agent:
+            logger.info("Agent not found during query. Attempting to initialize...")
+            await self.initialize()
+            
+        # 2. Check if it's still missing after attempt
         if not self.agent:
-            if not self.is_initialized:
-                return "Agent is initializing, please try again in a moment."
-            return "Agent failed to initialize. Please check logs."
+            # Check why it failed
+            if not self.index:
+                return "I can't answer that yet because there are no documents in the library. Please upload a document first."
+            
+            return "System Error: The AI agent failed to start. Please check if your OPENAI_API_KEY is correct in the .env file."
             
         try:
+            # 3. Run the query
             response = await self.agent.achat(query_text)
             return str(response)
         except Exception as e:
             logger.error(f"Error querying LlamaIndex agent: {str(e)}")
-            return f"Error processing query: {str(e)}"
+            return f"I encountered an error searching the documents: {str(e)}"