Refactor: Restore MCP architecture - Import from mcp_server.py, remove duplicate code, rename to AI Digital Library Assistant

app.py

@@ -3,7 +3,6 @@ import os
 import asyncio
 import json
 import logging
-import tempfile
 import uuid
 from datetime import datetime
 from pathlib import Path
@@ -13,301 +12,77 @@ import nest_asyncio
 # Apply nest_asyncio to handle nested event loops in Gradio
 nest_asyncio.apply()
 
-# Import our custom modules
-from mcp_tools.ingestion_tool import IngestionTool
-from mcp_tools.search_tool import SearchTool
-from mcp_tools.generative_tool import GenerativeTool
-from services.vector_store_service import VectorStoreService
-from services.document_store_service import DocumentStoreService
-from services.embedding_service import EmbeddingService
-from services.llm_service import LLMService
-from services.ocr_service import OCRService
-from core.models import SearchResult, Document
-import config
+# Import services and tools from mcp_server
+from mcp_server import (
+    # Services
+    vector_store_service,
+    document_store_service,
+    embedding_service_instance,
+    llm_service_instance,
+    ocr_service_instance,
+    llamaindex_service_instance,
+    elevenlabs_service_instance,
+    podcast_generator_instance,
+    # Tools
+    ingestion_tool_instance,
+    search_tool_instance,
+    generative_tool_instance,
+    voice_tool_instance,
+    podcast_tool_instance
+)
 
 # Setup logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
-# Import our custom modules
-from mcp_tools.ingestion_tool import IngestionTool
-from mcp_tools.search_tool import SearchTool
-from mcp_tools.generative_tool import GenerativeTool
-from services.vector_store_service import VectorStoreService
-from services.document_store_service import DocumentStoreService
-from services.embedding_service import EmbeddingService
-from services.llm_service import LLMService
-from services.ocr_service import OCRService
-from core.models import SearchResult, Document
-import config
-from services.llamaindex_service import LlamaIndexService
-from services.elevenlabs_service import ElevenLabsService
-from services.podcast_generator_service import PodcastGeneratorService
-from mcp_tools.voice_tool import VoiceTool
-from mcp_tools.podcast_tool import PodcastTool
 
-# Setup logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class ContentOrganizerMCPServer:
-    def __init__(self):
-        # Initialize services
-        logger.info("Initializing Content Organizer MCP Server...")
-        self.vector_store = VectorStoreService()
-        self.document_store = DocumentStoreService()
-        self.embedding_service = EmbeddingService()
-        self.llm_service = LLMService()
-        self.ocr_service = OCRService()
-        self.llamaindex_service = LlamaIndexService(self.document_store)
-        
-        # Initialize ElevenLabs voice service
-        self.elevenlabs_service = ElevenLabsService(self.llamaindex_service)
-        
-        # Initialize Podcast Generator
-        self.podcast_generator = PodcastGeneratorService(
-            llamaindex_service=self.llamaindex_service,
-            llm_service=self.llm_service
-        )
-        
-        # Initialize tools
-        self.ingestion_tool = IngestionTool(
-            vector_store=self.vector_store,
-            document_store=self.document_store,
-            embedding_service=self.embedding_service,
-            ocr_service=self.ocr_service
-        )
-        self.search_tool = SearchTool(
-            vector_store=self.vector_store,
-            embedding_service=self.embedding_service,
-            document_store=self.document_store
-        )
-        self.generative_tool = GenerativeTool(
-            llm_service=self.llm_service,
-            search_tool=self.search_tool
-        )
-        self.voice_tool = VoiceTool(self.elevenlabs_service)
-        self.podcast_tool = PodcastTool(self.podcast_generator)
-        
+# ============================================================================
+# HELPER FUNCTIONS FOR ASYNC EXECUTION
+# ============================================================================
 
-        # Track processing status
-        self.processing_status = {}
-        
-        # Document cache for quick access
-        self.document_cache = {}
-        logger.info("Content Organizer MCP Server initialized successfully!")
-
-    def run_async(self, coro):
-        """Helper to run async functions in Gradio"""
-        try:
-            loop = asyncio.get_event_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-        if loop.is_running():
-            # If loop is already running, create a task
-            import concurrent.futures
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                future = executor.submit(asyncio.run, coro)
-                return future.result()
-        else:
-            return loop.run_until_complete(coro)
-
-    async def ingest_document_async(self, file_path: str, file_type: str) -> Dict[str, Any]:
-        """MCP Tool: Ingest and process a document"""
-        try:
-            task_id = str(uuid.uuid4())
-            self.processing_status[task_id] = {"status": "processing", "progress": 0}
-            result = await self.ingestion_tool.process_document(file_path, file_type, task_id)
-            if result.get("success"):
-                self.processing_status[task_id] = {"status": "completed", "progress": 100}
-                doc_id = result.get("document_id")
-                if doc_id:
-                    doc = await self.document_store.get_document(doc_id)
-                    if doc:
-                        self.document_cache[doc_id] = doc
-                return result
-            else:
-                self.processing_status[task_id] = {"status": "failed", "error": result.get("error")}
-                return result
-        except Exception as e:
-            logger.error(f"Document ingestion failed: {str(e)}")
-            return {"success": False, "error": str(e), "message": "Failed to process document"}
-
-    async def get_document_content_async(self, document_id: str) -> Optional[str]:
-        """Get document content by ID"""
-        try:
-            # Check cache first
-            if document_id in self.document_cache:
-                return self.document_cache[document_id].content
-            
-            # Get from store
-            doc = await self.document_store.get_document(document_id)
-            if doc:
-                self.document_cache[document_id] = doc
-                return doc.content
-            return None
-        except Exception as e:
-            logger.error(f"Error getting document content: {str(e)}")
-            return None
-
-    async def semantic_search_async(self, query: str, top_k: int = 5, filters: Optional[Dict] = None) -> Dict[str, Any]:
-        """MCP Tool: Perform semantic search"""
-        try:
-            results = await self.search_tool.search(query, top_k, filters)
-            return {"success": True, "query": query, "results": [result.to_dict() for result in results], "total_results": len(results)}
-        except Exception as e:
-            logger.error(f"Semantic search failed: {str(e)}")
-            return {"success": False, "error": str(e), "query": query, "results": []}
-
-    async def summarize_content_async(self, content: str = None, document_id: str = None, style: str = "concise") -> Dict[str, Any]:
-        try:
-            if document_id and document_id != "none":
-                content = await self.get_document_content_async(document_id)
-                if not content:
-                    return {"success": False, "error": f"Document {document_id} not found"}
-            if not content or not content.strip():
-                return {"success": False, "error": "No content provided for summarization"}
-            max_content_length = 4000
-            if len(content) > max_content_length:
-                content = content[:max_content_length] + "..."
-            summary = await self.generative_tool.summarize(content, style)
-            return {"success": True, "summary": summary, "original_length": len(content), "summary_length": len(summary), "style": style, "document_id": document_id}
-        except Exception as e:
-            logger.error(f"Summarization failed: {str(e)}")
-            return {"success": False, "error": str(e)}
-
-    async def generate_tags_async(self, content: str = None, document_id: str = None, max_tags: int = 5) -> Dict[str, Any]:
-        """MCP Tool: Generate tags for content"""
-        try:
-            if document_id and document_id != "none":
-                content = await self.get_document_content_async(document_id)
-                if not content:
-                    return {"success": False, "error": f"Document {document_id} not found"}
-            if not content or not content.strip():
-                return {"success": False, "error": "No content provided for tag generation"}
-            tags = await self.generative_tool.generate_tags(content, max_tags)
-            if document_id and document_id != "none" and tags:
-                await self.document_store.update_document_metadata(document_id, {"tags": tags})
-            return {"success": True, "tags": tags, "content_length": len(content), "document_id": document_id}
-        except Exception as e:
-            logger.error(f"Tag generation failed: {str(e)}")
-            return {"success": False, "error": str(e)}
-    async def generate_podcast_async(
-        self,
-        document_ids: List[str],
-        style: str = "conversational",
-        duration_minutes: int = 10,
-        host1_voice: str = "Rachel",
-        host2_voice: str = "Adam"
-    ) -> Dict[str, Any]:
-        """Generate podcast from documents"""
-        try:
-            result = await self.podcast_tool.generate_podcast(
-                document_ids=document_ids,
-                style=style,
-                duration_minutes=duration_minutes,
-                host1_voice=host1_voice,
-                host2_voice=host2_voice
-            )
-            return result
-        except Exception as e:
-            logger.error(f"Podcast generation failed: {str(e)}")
-            return {"success": False, "error": str(e)}
-
-    async def answer_question_async(self, question: str, context_filter: Optional[Dict] = None) -> Dict[str, Any]:
-        try:
-            search_results = await self.search_tool.search(question, top_k=5, filters=context_filter)
-            if not search_results:
-                return {"success": False, "error": "No relevant context found in your documents. Please make sure you have uploaded relevant documents.", "question": question}
-            answer = await self.generative_tool.answer_question(question, search_results)
-            return {"success": True, "question": question, "answer": answer, "sources": [result.to_dict() for result in search_results], "confidence": "high" if len(search_results) >= 3 else "medium"}
-        except Exception as e:
-            logger.error(f"Question answering failed: {str(e)}")
-            return {"success": False, "error": str(e), "question": question}
-
-    async def generate_outline_async(self, topic: str, num_sections: int = 5, detail_level: str = "medium") -> Dict[str, Any]:
-        try:
-            outline = await self.generative_tool.generate_outline(topic, num_sections, detail_level)
-            return {"success": True, "result": outline}
-        except Exception as e:
-            return {"success": False, "error": str(e)}
-
-    async def explain_concept_async(self, concept: str, audience: str = "general", length: str = "medium") -> Dict[str, Any]:
-        try:
-            explanation = await self.generative_tool.explain_concept(concept, audience, length)
-            return {"success": True, "result": explanation}
-        except Exception as e:
-            return {"success": False, "error": str(e)}
-
-    async def paraphrase_text_async(self, text: str, style: str = "formal") -> Dict[str, Any]:
-        try:
-            paraphrase = await self.generative_tool.paraphrase_text(text, style)
-            return {"success": True, "result": paraphrase}
-        except Exception as e:
-            return {"success": False, "error": str(e)}
-
-    async def categorize_content_async(self, content: str, categories: List[str]) -> Dict[str, Any]:
-        try:
-            category = await self.generative_tool.categorize(content, categories)
-            return {"success": True, "result": category}
-        except Exception as e:
-            return {"success": False, "error": str(e)}
-
-    async def extract_key_insights_async(self, content: str, num_insights: int = 5) -> Dict[str, Any]:
-        try:
-            insights = await self.generative_tool.extract_key_insights(content, num_insights)
-            return {"success": True, "result": "\n".join([f"- {insight}" for insight in insights])}
-        except Exception as e:
-            return {"success": False, "error": str(e)}
-
-    async def generate_questions_async(self, content: str, question_type: str = "comprehension", num_questions: int = 5) -> Dict[str, Any]:
-        try:
-            questions = await self.generative_tool.generate_questions(content, question_type, num_questions)
-            return {"success": True, "result": "\n".join([f"{i+1}. {q}" for i, q in enumerate(questions)])}
-        except Exception as e:
-            return {"success": False, "error": str(e)}
-
-    async def extract_key_information_async(self, content: str) -> Dict[str, Any]:
-        try:
-            info = await self.llm_service.extract_key_information(content)
-            return {"success": True, "result": json.dumps(info, indent=2)}
-        except Exception as e:
-            return {"success": False, "error": str(e)}
-
-    def list_documents_sync(self, limit: int = 100, offset: int = 0) -> Dict[str, Any]:
-        try:
-            documents = self.run_async(self.document_store.list_documents(limit, offset))
-            return {"success": True, "documents": [doc.to_dict() for doc in documents], "total": len(documents)}
-        except Exception as e:
-            return {"success": False, "error": str(e)}
-
-mcp_server = ContentOrganizerMCPServer()
+def run_async(coro):
+    """Helper to run async functions in Gradio"""
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    if loop.is_running():
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            future = executor.submit(asyncio.run, coro)
+            return future.result()
+    else:
+        return loop.run_until_complete(coro)
+
+# ============================================================================
+# DOCUMENT MANAGEMENT FUNCTIONS
+# ============================================================================
 
 def get_document_list():
+    """Get formatted list of documents"""
     try:
-        result = mcp_server.list_documents_sync(limit=100)
-        if result["success"]:
-            if result["documents"]:
-                doc_list_str = "📚 Documents in Library:\n\n"
-                for i, doc_item in enumerate(result["documents"], 1):
-                    doc_list_str += f"{i}. {doc_item['filename']} (ID: {doc_item['id'][:8]}...)\n"
-                    doc_list_str += f"   Type: {doc_item['doc_type']}, Size: {doc_item['file_size']} bytes\n"
-                    if doc_item.get('tags'):
-                        doc_list_str += f"   Tags: {', '.join(doc_item['tags'])}\n"
-                    doc_list_str += f"   Created: {doc_item['created_at'][:10]}\n\n"
-                return doc_list_str
-            else:
-                return "No documents in library yet. Upload some documents to get started!"
+        documents = run_async(document_store_service.list_documents(limit=100))
+        if documents:
+            doc_list_str = "📚 Documents in Library:\n\n"
+            for i, doc in enumerate(documents, 1):
+                doc_list_str += f"{i}. {doc.filename} (ID: {doc.id[:8]}...)\n"
+                doc_list_str += f"   Type: {doc.doc_type}, Size: {doc.file_size} bytes\n"
+                if doc.metadata and doc.metadata.get('tags'):
+                    doc_list_str += f"   Tags: {', '.join(doc.metadata['tags'])}\n"
+                doc_list_str += f"   Created: {doc.created_at[:10]}\n\n"
+            return doc_list_str
         else:
-            return f"Error loading documents: {result['error']}"
+            return "No documents in library yet. Upload some documents to get started!"
     except Exception as e:
+        logger.error(f"Error loading documents: {str(e)}")
         return f"Error: {str(e)}"
 
 def get_document_choices():
+    """Get document choices for dropdowns"""
     try:
-        result = mcp_server.list_documents_sync(limit=100)
-        if result["success"] and result["documents"]:
-            choices = [(f"{doc['filename']} ({doc['id'][:8]}...)", doc['id']) for doc in result["documents"]]
+        documents = run_async(document_store_service.list_documents(limit=100))
+        if documents:
+            choices = [(f"{doc.filename} ({doc.id[:8]}...)", doc.id) for doc in documents]
             logger.info(f"Generated {len(choices)} document choices")
             return choices
         return []
@@ -316,6 +91,7 @@ def get_document_choices():
         return []
 
 def refresh_library():
+    """Refresh library and update all dropdowns"""
     doc_list_refreshed = get_document_list()
     doc_choices_refreshed = get_document_choices()
     logger.info(f"Refreshing library. Found {len(doc_choices_refreshed)} choices.")
@@ -327,6 +103,7 @@ def refresh_library():
     )
 
 def upload_and_process_file(file):
+    """Upload and process a document file"""
     if file is None:
         doc_list_initial = get_document_list()
         doc_choices_initial = get_document_choices()
@@ -338,9 +115,10 @@ def upload_and_process_file(file):
         )
     try:
         file_path = file.name if hasattr(file, 'name') else str(file)
-        file_type = Path(file_path).suffix.lower().strip('.') # Ensure suffix is clean
+        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))
+        
+        result = run_async(ingestion_tool_instance.process_document(file_path, file_type))
         
         doc_list_updated = get_document_list()
         doc_choices_updated = get_document_choices()
@@ -374,114 +152,165 @@ def upload_and_process_file(file):
             gr.update(choices=doc_choices_error)
         )
 
+def delete_document_from_library(document_id):
+    """Delete a document from the library"""
+    if not document_id:
+        doc_list_current = get_document_list()
+        doc_choices_current = get_document_choices()
+        return (
+            "No document selected to delete.",
+            doc_list_current,
+            gr.update(choices=doc_choices_current),
+            gr.update(choices=doc_choices_current),
+            gr.update(choices=doc_choices_current)
+        )
+    try:
+        delete_doc_store_result = run_async(document_store_service.delete_document(document_id))
+        delete_vec_store_result = run_async(vector_store_service.delete_document(document_id))
+
+        msg = ""
+        if delete_doc_store_result:
+            msg += f"🗑️ Document {document_id[:8]}... deleted from document store. "
+        else:
+            msg += f"❌ Failed to delete document {document_id[:8]}... from document store. "
+        
+        if delete_vec_store_result:
+             msg += "Embeddings deleted from vector store."
+        else:
+             msg += "Failed to delete embeddings from vector store (or no embeddings existed)."
+
+        doc_list_updated = get_document_list()
+        doc_choices_updated = get_document_choices()
+        return (
+            msg,
+            doc_list_updated,
+            gr.update(choices=doc_choices_updated),
+            gr.update(choices=doc_choices_updated),
+            gr.update(choices=doc_choices_updated)
+        )
+    except Exception as e:
+        logger.error(f"Error deleting document: {str(e)}")
+        doc_list_error = get_document_list()
+        doc_choices_error = get_document_choices()
+        return (
+            f"❌ Error deleting document: {str(e)}",
+            doc_list_error,
+            gr.update(choices=doc_choices_error),
+            gr.update(choices=doc_choices_error),
+            gr.update(choices=doc_choices_error)
+        )
+
+# ============================================================================
+# SEARCH FUNCTIONS
+# ============================================================================
+
 def perform_search(query, top_k):
+    """Perform semantic search"""
     if not query.strip():
         return "Please enter a search query"
     try:
-        result = mcp_server.run_async(mcp_server.semantic_search_async(query, int(top_k)))
-        if result["success"]:
-            if result["results"]:
-                output_str = f"🔍 Found {result['total_results']} results for: '{query}'\n\n"
-                for i, res_item in enumerate(result["results"], 1):
-                    output_str += f"Result {i}:\n"
-                    output_str += f"📊 Relevance Score: {res_item['score']:.3f}\n"
-                    output_str += f"📄 Content: {res_item['content'][:300]}...\n"
-                    if 'document_filename' in res_item.get('metadata', {}):
-                        output_str += f"📁 Source: {res_item['metadata']['document_filename']}\n"
-                    output_str += f"🔗 Document ID: {res_item.get('document_id', 'Unknown')}\n"
-                    output_str += "-" * 80 + "\n\n"
-                return output_str
-            else:
-                return f"No results found for: '{query}'\n\nMake sure you have uploaded relevant documents first."
+        results = run_async(search_tool_instance.search(query, int(top_k)))
+        if results:
+            output_str = f"🔍 Found {len(results)} results for: '{query}'\n\n"
+            for i, result in enumerate(results, 1):
+                output_str += f"Result {i}:\n"
+                output_str += f"📊 Relevance Score: {result.score:.3f}\n"
+                output_str += f"📄 Content: {result.content[:300]}...\n"
+                if result.metadata and 'document_filename' in result.metadata:
+                    output_str += f"📁 Source: {result.metadata['document_filename']}\n"
+                output_str += f"🔗 Document ID: {result.document_id}\n"
+                output_str += "-" * 80 + "\n\n"
+            return output_str
         else:
-            return f"❌ Search failed: {result['error']}"
+            return f"No results found for: '{query}'\n\nMake sure you have uploaded relevant documents first."
     except Exception as e:
         logger.error(f"Search error: {str(e)}")
         return f"❌ Error: {str(e)}"
 
+# ============================================================================
+# CONTENT STUDIO FUNCTIONS
+# ============================================================================
+
 def update_options_visibility(task):
     """Update visibility of options based on selected task"""
     return (
-        gr.update(visible=task == "Summarize"),          # summary_style
-        gr.update(visible=task == "Generate Outline"),   # outline_sections
-        gr.update(visible=task == "Generate Outline"),   # outline_detail
-        gr.update(visible=task == "Explain Concept"),    # explain_audience
-        gr.update(visible=task == "Explain Concept"),    # explain_length
-        gr.update(visible=task == "Paraphrase"),         # paraphrase_style
-        gr.update(visible=task == "Categorize"),         # categories_input
-        gr.update(visible=task in ["Key Insights", "Generate Questions"]), # num_items
-        gr.update(visible=task == "Generate Questions")  # question_type
+        gr.update(visible=task == "Summarize"),
+        gr.update(visible=task == "Generate Outline"),
+        gr.update(visible=task == "Generate Outline"),
+        gr.update(visible=task == "Explain Concept"),
+        gr.update(visible=task == "Explain Concept"),
+        gr.update(visible=task == "Paraphrase"),
+        gr.update(visible=task == "Categorize"),
+        gr.update(visible=task in ["Key Insights", "Generate Questions"]),
+        gr.update(visible=task == "Generate Questions")
     )
 
+async def get_document_content(document_id: str) -> Optional[str]:
+    """Get document content by ID"""
+    try:
+        doc = await document_store_service.get_document(document_id)
+        if doc:
+            return doc.content
+        return None
+    except Exception as e:
+        logger.error(f"Error getting document content: {str(e)}")
+        return None
+
 def execute_content_task(task, doc_choice, custom_text, 
                         summary_style, outline_sections, outline_detail,
                         explain_audience, explain_length,
                         paraphrase_style, categories_input,
                         num_items, question_type):
+    """Execute content analysis tasks"""
     try:
         # Get content
         content = ""
         if custom_text and custom_text.strip():
             content = custom_text
         elif doc_choice and doc_choice != "none":
-            content = mcp_server.run_async(mcp_server.get_document_content_async(doc_choice))
+            content = run_async(get_document_content(doc_choice))
             if not content:
                 return "❌ Error: Document not found or empty"
         else:
             if task == "Generate Outline":
-                content = custom_text # Topic is passed as text
+                content = custom_text
             else:
                 return "⚠️ Please select a document or enter text"
 
         # Execute task
-        result = {"success": False, "error": "Unknown task"}
-        
         if task == "Summarize":
-            result = mcp_server.run_async(mcp_server.summarize_content_async(content=content, style=summary_style))
-            if result["success"]:
-                return f"📝 Summary ({summary_style}):\n\n{result['summary']}"
+            summary = run_async(generative_tool_instance.summarize(content, summary_style))
+            return f"📝 Summary ({summary_style}):\n\n{summary}"
                 
         elif task == "Generate Outline":
-            # For outline, content is the topic
-            result = mcp_server.run_async(mcp_server.generate_outline_async(content, int(outline_sections), outline_detail))
-            if result["success"]:
-                return f"📝 Outline for '{content}':\n\n{result['result']}"
+            outline = run_async(generative_tool_instance.generate_outline(content, int(outline_sections), outline_detail))
+            return f"📝 Outline for '{content}':\n\n{outline}"
                 
         elif task == "Explain Concept":
-            # For explain, content is the concept
-            result = mcp_server.run_async(mcp_server.explain_concept_async(content, explain_audience, explain_length))
-            if result["success"]:
-                return f"💡 Explanation ({explain_audience}):\n\n{result['result']}"
+            explanation = run_async(generative_tool_instance.explain_concept(content, explain_audience, explain_length))
+            return f"💡 Explanation ({explain_audience}):\n\n{explanation}"
                 
         elif task == "Paraphrase":
-            result = mcp_server.run_async(mcp_server.paraphrase_text_async(content, paraphrase_style))
-            if result["success"]:
-                return f"🔄 Paraphrased Text ({paraphrase_style}):\n\n{result['result']}"
+            paraphrase = run_async(generative_tool_instance.paraphrase_text(content, paraphrase_style))
+            return f"🔄 Paraphrased Text ({paraphrase_style}):\n\n{paraphrase}"
                 
         elif task == "Categorize":
             categories = [c.strip() for c in categories_input.split(',')] if categories_input else []
-            result = mcp_server.run_async(mcp_server.categorize_content_async(content, categories))
-            if result["success"]:
-                return f"🏷️ Category:\n\n{result['result']}"
+            category = run_async(generative_tool_instance.categorize(content, categories))
+            return f"🏷️ Category:\n\n{category}"
                 
         elif task == "Key Insights":
-            result = mcp_server.run_async(mcp_server.extract_key_insights_async(content, int(num_items)))
-            if result["success"]:
-                return f"🔍 Key Insights:\n\n{result['result']}"
+            insights = run_async(generative_tool_instance.extract_key_insights(content, int(num_items)))
+            return f"🔍 Key Insights:\n\n" + "\n".join([f"- {insight}" for insight in insights])
                 
         elif task == "Generate Questions":
-            result = mcp_server.run_async(mcp_server.generate_questions_async(content, question_type, int(num_items)))
-            if result["success"]:
-                return f"❓ Generated Questions ({question_type}):\n\n{result['result']}"
+            questions = run_async(generative_tool_instance.generate_questions(content, question_type, int(num_items)))
+            return f"❓ Generated Questions ({question_type}):\n\n" + "\n".join([f"{i+1}. {q}" for i, q in enumerate(questions)])
                 
         elif task == "Extract Key Info":
-            result = mcp_server.run_async(mcp_server.extract_key_information_async(content))
-            if result["success"]:
-                return f"📊 Key Information:\n\n{result['result']}"
+            info = run_async(llm_service_instance.extract_key_information(content))
+            return f"📊 Key Information:\n\n{json.dumps(info, indent=2)}"
 
-        if not result["success"]:
-            return f"❌ Error: {result.get('error', 'Unknown error')}"
-            
         return "✅ Task completed"
 
     except Exception as e:
@@ -489,105 +318,73 @@ def execute_content_task(task, doc_choice, custom_text,
         return f"❌ Error: {str(e)}"
 
 def generate_tags_for_document(doc_choice, custom_text, max_tags):
+    """Generate tags for document or text"""
     try:
-        logger.info(f"Generate tags called with doc_choice: {doc_choice}, type: {type(doc_choice)}")
+        logger.info(f"Generate tags called with doc_choice: {doc_choice}")
         document_id = doc_choice if doc_choice and doc_choice != "none" and doc_choice != "" else None
 
         if custom_text and custom_text.strip():
             logger.info("Using custom text for tag generation")
-            result = mcp_server.run_async(mcp_server.generate_tags_async(content=custom_text, max_tags=int(max_tags)))
+            tags = run_async(generative_tool_instance.generate_tags(custom_text, int(max_tags)))
+            content_length = len(custom_text)
+            doc_id_display = None
         elif document_id:
             logger.info(f"Generating tags for document: {document_id}")
-            result = mcp_server.run_async(mcp_server.generate_tags_async(document_id=document_id, max_tags=int(max_tags)))
+            content = run_async(get_document_content(document_id))
+            if not content:
+                return "❌ Error: Document not found or empty"
+            tags = run_async(generative_tool_instance.generate_tags(content, int(max_tags)))
+            if tags:
+                run_async(document_store_service.update_document_metadata(document_id, {"tags": tags}))
+            content_length = len(content)
+            doc_id_display = document_id
         else:
             return "Please select a document from the dropdown or enter text to generate tags"
         
-        if result["success"]:
-            tags_str = ", ".join(result["tags"])
+        if tags:
+            tags_str = ", ".join(tags)
             output_str = f"🏷️ Generated Tags:\n\n{tags_str}\n\n"
             output_str += f"📊 Statistics:\n"
-            output_str += f"- Content length: {result['content_length']} characters\n"
-            output_str += f"- Number of tags: {len(result['tags'])}\n"
-            if result.get('document_id'):
-                output_str += f"- Document ID: {result['document_id']}\n"
+            output_str += f"- Content length: {content_length} characters\n"
+            output_str += f"- Number of tags: {len(tags)}\n"
+            if doc_id_display:
+                output_str += f"- Document ID: {doc_id_display}\n"
                 output_str += f"\n✅ Tags have been saved to the document."
             return output_str
         else:
-            return f"❌ Tag generation failed: {result['error']}"
+            return "❌ Tag generation failed"
     except Exception as e:
         logger.error(f"Tag generation error: {str(e)}")
         return f"❌ Error: {str(e)}"
 
 def ask_question(question):
+    """Ask question with RAG"""
     if not question.strip():
         return "Please enter a question"
     try:
-        result = mcp_server.run_async(mcp_server.answer_question_async(question))
-        if result["success"]:
-            output_str = f"❓ Question: {result['question']}\n\n"
-            output_str += f"💡 Answer:\n{result['answer']}\n\n"
-            output_str += f"🎯 Confidence: {result['confidence']}\n\n"
-            output_str += f"📚 Sources Used ({len(result['sources'])}):\n"
-            for i, source_item in enumerate(result['sources'], 1):
-                filename = source_item.get('metadata', {}).get('document_filename', 'Unknown')
-                output_str += f"\n{i}. 📄 {filename}\n"
-                output_str += f"   📝 Excerpt: {source_item['content'][:150]}...\n"
-                output_str += f"   📊 Relevance: {source_item['score']:.3f}\n"
-            return output_str
-        else:
-            return f"❌ {result.get('error', 'Failed to answer question')}"
+        search_results = run_async(search_tool_instance.search(question, top_k=5))
+        if not search_results:
+            return "❌ No relevant context found in your documents. Please make sure you have uploaded relevant documents."
+        
+        answer = run_async(generative_tool_instance.answer_question(question, search_results))
+        
+        output_str = f"❓ Question: {question}\n\n"
+        output_str += f"💡 Answer:\n{answer}\n\n"
+        output_str += f"🎯 Confidence: {'high' if len(search_results) >= 3 else 'medium'}\n\n"
+        output_str += f"📚 Sources Used ({len(search_results)}):\n"
+        for i, source in enumerate(search_results, 1):
+            filename = source.metadata.get('document_filename', 'Unknown') if source.metadata else 'Unknown'
+            output_str += f"\n{i}. 📄 {filename}\n"
+            output_str += f"   📝 Excerpt: {source.content[:150]}...\n"
+            output_str += f"   📊 Relevance: {source.score:.3f}\n"
+        return output_str
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
-def delete_document_from_library(document_id):
-    if not document_id:
-        doc_list_current = get_document_list()
-        doc_choices_current = get_document_choices()
-        return (
-            "No document selected to delete.",
-            doc_list_current,
-            gr.update(choices=doc_choices_current),
-            gr.update(choices=doc_choices_current),
-            gr.update(choices=doc_choices_current)
-        )
-    try:
-        delete_doc_store_result = mcp_server.run_async(mcp_server.document_store.delete_document(document_id))
-        delete_vec_store_result = mcp_server.run_async(mcp_server.vector_store.delete_document(document_id))
+# ============================================================================
+# VOICE ASSISTANT FUNCTIONS
+# ============================================================================
 
-        msg = ""
-        if delete_doc_store_result:
-            msg += f"🗑️ Document {document_id[:8]}... deleted from document store. "
-        else:
-            msg += f"❌ Failed to delete document {document_id[:8]}... from document store. "
-        
-        if delete_vec_store_result:
-             msg += "Embeddings deleted from vector store."
-        else:
-             msg += "Failed to delete embeddings from vector store (or no embeddings existed)."
-
-
-        doc_list_updated = get_document_list()
-        doc_choices_updated = get_document_choices()
-        return (
-            msg,
-            doc_list_updated,
-            gr.update(choices=doc_choices_updated),
-            gr.update(choices=doc_choices_updated),
-            gr.update(choices=doc_choices_updated)
-        )
-    except Exception as e:
-        logger.error(f"Error deleting document: {str(e)}")
-        doc_list_error = get_document_list()
-        doc_choices_error = get_document_choices()
-        return (
-            f"❌ Error deleting document: {str(e)}",
-            doc_list_error,
-            gr.update(choices=doc_choices_error),
-            gr.update(choices=doc_choices_error),
-            gr.update(choices=doc_choices_error)
-        )
-
-# Voice conversation state - global scope
 voice_conversation_state = {
     "session_id": None,
     "active": False,
@@ -597,16 +394,16 @@ voice_conversation_state = {
 def start_voice_conversation():
     """Start a new voice conversation session"""
     try:
-        if not mcp_server.elevenlabs_service.is_available():
+        if not elevenlabs_service_instance.is_available():
             return (
                 "⚠️ Voice assistant not configured. Please set ELEVENLABS_API_KEY and ELEVENLABS_AGENT_ID in .env",
                 gr.update(interactive=False),
                 gr.update(interactive=True),
-                ""
+                []
             )
         
         session_id = str(uuid.uuid4())
-        result = mcp_server.run_async(mcp_server.elevenlabs_service.start_conversation(session_id))
+        result = run_async(elevenlabs_service_instance.start_conversation(session_id))
         
         if result.get("success"):
             voice_conversation_state["session_id"] = session_id
@@ -635,7 +432,6 @@ def start_voice_conversation():
             []
         )
 
-
 def stop_voice_conversation():
     """Stop active voice conversation"""
     try:
@@ -649,7 +445,7 @@ def stop_voice_conversation():
         
         session_id = voice_conversation_state["session_id"]
         if session_id:
-            mcp_server.run_async(mcp_server.elevenlabs_service.end_conversation(session_id))
+            run_async(elevenlabs_service_instance.end_conversation(session_id))
         
         voice_conversation_state["active"] = False
         voice_conversation_state["session_id"] = None
@@ -669,52 +465,6 @@ def stop_voice_conversation():
             voice_conversation_state["transcript"]
         )
 
-
-def send_voice_message(message):
-    """Send a text message in voice conversation"""
-    try:
-        if not voice_conversation_state["active"]:
-            return ("Please start a conversation first", "", format_transcript(voice_conversation_state["transcript"]))
-        
-        if not message or not message.strip():
-            return ("Please enter a message", message, format_transcript(voice_conversation_state["transcript"]))
-        
-        session_id = voice_conversation_state["session_id"]
-        voice_conversation_state["transcript"].append({"role": "user", "content": message})
-        
-        result = mcp_server.run_async(mcp_server.voice_tool.voice_qa(message, session_id))
-        
-        if result.get("success"):
-            answer = result.get("answer", "No response")
-            voice_conversation_state["transcript"].append({"role": "assistant", "content": answer})
-            return ("✅ Response received", "", format_transcript(voice_conversation_state["transcript"]))
-        else:
-            return (f"❌ Error: {result.get('error')}", message, format_transcript(voice_conversation_state["transcript"]))
-    except Exception as e:
-        logger.error(f"Error sending message: {str(e)}")
-        return (f"❌ Error: {str(e)}", message, format_transcript(voice_conversation_state["transcript"]))
-
-def format_transcript(transcript):
-    """Format conversation transcript for display"""
-    if not transcript:
-        return "No conversation yet. Start talking to the AI librarian!"
-    
-    formatted = ""
-    for msg in transcript:
-        role = msg["role"]
-        content = msg["content"]
-        if role == "user":
-            formatted += f"👤 **You:** {content}\n\n"
-        else:
-            formatted += f"🤖 **AI Librarian:** {content}\n\n"
-        formatted += "---\n\n"
-    return formatted
-
-def clear_voice_transcript():
-    """Clear conversation transcript"""
-    voice_conversation_state["transcript"] = []
-    return ""
-
 def send_voice_message_v6(message, chat_history):
     """Send message in voice conversation - Gradio 6 format"""
     try:
@@ -726,11 +476,11 @@ def send_voice_message_v6(message, chat_history):
         
         session_id = voice_conversation_state["session_id"]
         
-        # Add user message in Gradio 6 format
+        # Add user message
         chat_history.append({"role": "user", "content": message})
         
         # Get AI response
-        result = mcp_server.run_async(mcp_server.voice_tool.voice_qa(message, session_id))
+        result = run_async(voice_tool_instance.voice_qa(message, session_id))
         
         if result.get("success"):
             answer = result.get("answer", "No response")
@@ -750,6 +500,10 @@ def send_voice_message_v6(message, chat_history):
         })
         return chat_history, ""
 
+# ============================================================================
+# PODCAST GENERATION FUNCTIONS
+# ============================================================================
+
 def generate_podcast_ui(doc_ids, style, duration, voice1, voice2):
     """UI wrapper for podcast generation"""
     try:
@@ -758,8 +512,8 @@ def generate_podcast_ui(doc_ids, style, duration, voice1, voice2):
         
         logger.info(f"Generating podcast: {len(doc_ids)} docs, {style}, {duration}min")
         
-        result = mcp_server.run_async(
-            mcp_server.generate_podcast_async(
+        result = run_async(
+            podcast_tool_instance.generate_podcast(
                 document_ids=doc_ids,
                 style=style,
                 duration_minutes=int(duration),
@@ -787,41 +541,42 @@ def generate_podcast_ui(doc_ids, style, duration, voice1, voice2):
         logger.error(f"Podcast UI error: {str(e)}")
         return (f"❌ Error: {str(e)}", None, "An error occurred", "")
 
+# ============================================================================
+# DASHBOARD FUNCTIONS
+# ============================================================================
+
 def load_dashboard_stats():
-    """Load dashboard statistics for the UI"""
+    """Load dashboard statistics"""
     try:
-        # Get document list
-        docs_result = mcp_server.list_documents_sync(limit=1000)
-        doc_count = 0
+        documents = run_async(document_store_service.list_documents(limit=1000))
+        doc_count = len(documents) if documents else 0
         total_chunks = 0
         total_size = 0
         recent_data = []
         
-        if docs_result.get("success"):
-            documents = docs_result.get("documents", [])
-            doc_count = len(documents)
-            total_chunks = sum(doc.get("metadata", {}).get("chunk_count", 0) for doc in documents)
-            total_size = sum(doc.get("file_size", 0) for doc in documents)
+        if documents:
+            total_chunks = sum(doc.metadata.get("chunk_count", 0) for doc in documents if doc.metadata)
+            total_size = sum(doc.file_size for doc in documents)
             storage_mb = round(total_size / (1024 * 1024), 2) if total_size > 0 else 0.0
             
             # Get recent 5 documents
             recent = documents[:5]
             recent_data = [
                 [
-                    doc.get("filename", "Unknown"), 
-                    doc.get("doc_type", "unknown"), 
-                    doc.get("created_at", "")[:10] if doc.get("created_at") else "N/A", 
-                    f"{doc.get('file_size', 0)} bytes"
+                    doc.filename, 
+                    doc.doc_type, 
+                    doc.created_at[:10] if doc.created_at else "N/A", 
+                    f"{doc.file_size} bytes"
                 ]
                 for doc in recent
             ]
         else:
             storage_mb = 0.0
         
-        # Service status indicators
-        vector_stat = "✅ Online" if getattr(mcp_server, "vector_store", None) else "❌ Offline"
-        llm_stat = "✅ Ready" if getattr(mcp_server, "llm_service", None) else "❌ Offline"
-        voice_stat = "✅ Ready" if (getattr(mcp_server, "elevenlabs_service", None) and mcp_server.elevenlabs_service.is_available()) else "⚠️ Configure API Key"
+        # Service status
+        vector_stat = "✅ Online" if vector_store_service else "❌ Offline"
+        llm_stat = "✅ Ready" if llm_service_instance else "❌ Offline"
+        voice_stat = "✅ Ready" if (elevenlabs_service_instance and elevenlabs_service_instance.is_available()) else "⚠️ Configure API Key"
         
         return (
             doc_count,
@@ -836,8 +591,14 @@ def load_dashboard_stats():
         logger.error(f"Error loading dashboard stats: {str(e)}")
         return (0, 0, 0.0, [], "❌ Error", "❌ Error", "❌ Error")
 
+# ============================================================================
+# GRADIO UI CREATION
+# ============================================================================
+
 def create_gradio_interface():
-    # Create custom theme with modern aesthetics
+    """Create the Gradio interface"""
+    
+    # Create custom theme
     custom_theme = gr.themes.Soft(
         primary_hue=gr.themes.colors.indigo,
         secondary_hue=gr.themes.colors.blue,
@@ -881,16 +642,19 @@ def create_gradio_interface():
         
         🔗 **For MCP Integration** (Claude Desktop, Cline, etc.):  
         Add this endpoint to your MCP client configuration:
-
+        ```
+        https://nihal2000-aidigitiallibrary assistant.hf.space/gradio_api/mcp/sse
+        ```
+        
          💡 **Powered by:** OpenAI, Mistral AI, Claude, ElevenLabs, LlamaIndex
         """)
+        
         with gr.Tabs():
-            # Dashboard Tab - New Landing Page
+            # Dashboard Tab
             with gr.Tab("🏠 Dashboard"):
                 gr.Markdown("# Welcome to Your AI Library Assistant")
                 gr.Markdown("*Your intelligent document management and analysis platform powered by AI*")
                 
-                # Quick Stats Section
                 gr.Markdown("## 📊 Quick Stats")
                 with gr.Row():
                     total_docs = gr.Number(
@@ -912,7 +676,6 @@ def create_gradio_interface():
                         container=True
                     )
                 
-                # Recent Activity Section
                 gr.Markdown("## 📊 Recent Activity")
                 with gr.Group():
                     recent_docs = gr.Dataframe(
@@ -924,8 +687,7 @@ def create_gradio_interface():
                         label="Recently Added Documents"
                     )
                 
-                # System Status Section
-                gr.Markdown("## � System Status")
+                gr.Markdown("## ⚙️ System Status")
                 with gr.Row():
                     vector_status = gr.Textbox(
                         label="Vector Store",
@@ -946,16 +708,29 @@ def create_gradio_interface():
                         container=True
                     )
             
+            # Document Library Tab
             with gr.Tab("📚 Document Library"):
                 with gr.Row():
                     with gr.Column():
                         gr.Markdown("### Your Document Collection")
-                        document_list_display = gr.Textbox(label="Documents in Library", value=get_document_list(), lines=20, interactive=False)
+                        document_list_display = gr.Textbox(
+                            label="Documents in Library",
+                            value=get_document_list(),
+                            lines=20,
+                            interactive=False
+                        )
                         refresh_btn_library = gr.Button("🔄 Refresh Library", variant="secondary")
-                        delete_doc_dropdown_visible = gr.Dropdown(label="Select Document to Delete", choices=get_document_choices(), value=None, interactive=True, allow_custom_value=False)
+                        delete_doc_dropdown_visible = gr.Dropdown(
+                            label="Select Document to Delete",
+                            choices=get_document_choices(),
+                            value=None,
+                            interactive=True,
+                            allow_custom_value=False
+                        )
                         delete_btn = gr.Button("🗑️ Delete Selected Document", variant="stop")
                         delete_output_display = gr.Textbox(label="Delete Status", visible=True)
             
+            # Upload Documents Tab
             with gr.Tab("📄 Upload Documents"):
                 gr.Markdown("""
                 ### 📥 Add Documents to Library
@@ -974,7 +749,6 @@ def create_gradio_interface():
                             )
                             
                             upload_btn_process = gr.Button("🚀 Upload & Process", variant="primary", size="lg")
-
                         
                         with gr.Group():
                             upload_output_display = gr.Textbox(
@@ -990,7 +764,7 @@ def create_gradio_interface():
                                 visible=False
                             )
 
-
+            # Search Documents Tab
             with gr.Tab("🔍 Search Documents"):
                 gr.Markdown("""
                 ### 🔎 Semantic Search
@@ -1024,8 +798,8 @@ def create_gradio_interface():
                                 placeholder="Search results will appear here...",
                                 show_copy_button=True
                             )
-
             
+            # Content Studio Tab
             with gr.Tab("📝 Content Studio"):
                 gr.Markdown("""
                 ### 🎨 Create & Analyze Content
@@ -1034,7 +808,6 @@ def create_gradio_interface():
                 
                 with gr.Row():
                     with gr.Column(scale=2):
-                        # Source Selection with Group
                         with gr.Group():
                             gr.Markdown("#### 📄 Content Source")
                             doc_dropdown_content = gr.Dropdown(
@@ -1054,7 +827,6 @@ def create_gradio_interface():
                                 info="For outlines, enter a topic. For other tasks, paste text to analyze."
                             )
                         
-                        # Task Configuration with Group
                         with gr.Group():
                             gr.Markdown("#### 🛠️ Task Configuration")
                             task_dropdown = gr.Dropdown(
@@ -1069,7 +841,6 @@ def create_gradio_interface():
                                 info="Choose the type of analysis to perform"
                             )
                         
-                        # Dynamic Options with Accordion
                         with gr.Accordion("⚙️ Advanced Options", open=False):
                             summary_style_opt = gr.Dropdown(
                                 label="Summary Style",
@@ -1135,7 +906,6 @@ def create_gradio_interface():
                         run_task_btn = gr.Button("🚀 Run Task", variant="primary", size="lg")
                     
                     with gr.Column(scale=3):
-                        # Results with copy button and Group
                         with gr.Group():
                             gr.Markdown("#### 📊 Result")
                             content_output_display = gr.Textbox(
@@ -1146,7 +916,7 @@ def create_gradio_interface():
                                 container=False
                             )
 
-                # Event Handlers
+                # Event Handlers for Content Studio
                 task_dropdown.change(
                     fn=update_options_visibility,
                     inputs=[task_dropdown],
@@ -1168,17 +938,36 @@ def create_gradio_interface():
                     outputs=[content_output_display]
                 )
 
+            # Generate Tags Tab
             with gr.Tab("🏷️ Generate Tags"):
                 with gr.Row():
                     with gr.Column():
                         gr.Markdown("### Generate Document Tags")
-                        doc_dropdown_tag_visible = gr.Dropdown(label="Select Document to Tag", choices=get_document_choices(), value=None, interactive=True, allow_custom_value=False)
-                        tag_text_input = gr.Textbox(label="Or Paste Text to Generate Tags", placeholder="Paste any text here to generate tags...", lines=8)
-                        max_tags_slider = gr.Slider(label="Number of Tags", minimum=3, maximum=15, value=5, step=1)
+                        doc_dropdown_tag_visible = gr.Dropdown(
+                            label="Select Document to Tag",
+                            choices=get_document_choices(),
+                            value=None,
+                            interactive=True,
+                            allow_custom_value=False
+                        )
+                        tag_text_input = gr.Textbox(
+                            label="Or Paste Text to Generate Tags",
+                            placeholder="Paste any text here to generate tags...",
+                            lines=8
+                        )
+                        max_tags_slider = gr.Slider(
+                            label="Number of Tags",
+                            minimum=3, maximum=15, value=5, step=1
+                        )
                         tag_btn_action = gr.Button("🏷️ Generate Tags", variant="primary", size="lg")
                     with gr.Column():
-                        tag_output_display = gr.Textbox(label="Generated Tags", lines=10, placeholder="Tags will appear here...")
+                        tag_output_display = gr.Textbox(
+                            label="Generated Tags",
+                            lines=10,
+                            placeholder="Tags will appear here..."
+                        )
 
+            # Voice Assistant Tab
             with gr.Tab("🎙️ Voice Assistant"):
                 gr.Markdown("""
                 ### 🗣️ Talk to Your AI Librarian
@@ -1191,7 +980,6 @@ def create_gradio_interface():
                 
                 with gr.Row():
                     with gr.Column(scale=2):
-                        # Status and Controls
                         with gr.Group():
                             voice_status_display = gr.Textbox(
                                 label="Status",
@@ -1204,7 +992,6 @@ def create_gradio_interface():
                                 start_voice_btn = gr.Button("🎤 Start Conversation", variant="primary", size="lg")
                                 stop_voice_btn = gr.Button("⏹️ Stop", variant="stop", size="lg", interactive=False)
                         
-                        # Message Input
                         with gr.Group():
                             gr.Markdown("#### 💬 Send Message")
                             voice_input_text = gr.Textbox(
@@ -1217,7 +1004,6 @@ def create_gradio_interface():
                             send_voice_btn = gr.Button("📤 Send", variant="secondary")
                     
                     with gr.Column(scale=3):
-                        # Chat Interface with Gradio 6 Chatbot
                         with gr.Group():
                             voice_chatbot = gr.Chatbot(
                                 label="Conversation",
@@ -1256,6 +1042,7 @@ def create_gradio_interface():
                     outputs=[voice_chatbot]
                 )
 
+            # Podcast Studio Tab
             with gr.Tab("🎧 Podcast Studio"):
                 gr.Markdown("""
                 ### 🎙️ AI-Powered Podcast Generation
@@ -1268,7 +1055,6 @@ def create_gradio_interface():
                 
                 with gr.Row():
                     with gr.Column(scale=2):
-                        # Configuration Panel
                         with gr.Group():
                             gr.Markdown("#### 📚 Select Content")
                             
@@ -1329,7 +1115,6 @@ def create_gradio_interface():
                         )
                     
                     with gr.Column(scale=3):
-                        # Output Panel
                         with gr.Group():
                             gr.Markdown("#### 🎵 Generated Podcast")
                             
@@ -1364,17 +1149,27 @@ def create_gradio_interface():
                     ]
                 )
                 
+            # Ask Questions Tab
             with gr.Tab("❓ Ask Questions"):
                 with gr.Row():
                     with gr.Column():
                         gr.Markdown("""### Ask Questions About Your Documents
                         The AI will search through all your uploaded documents to find relevant information 
                         and provide comprehensive answers with sources.""")
-                        qa_question_input = gr.Textbox(label="Your Question", placeholder="Ask anything about your documents...", lines=3)
+                        qa_question_input = gr.Textbox(
+                            label="Your Question",
+                            placeholder="Ask anything about your documents...",
+                            lines=3
+                        )
                         qa_btn_action = gr.Button("❓ Get Answer", variant="primary", size="lg")
                     with gr.Column():
-                        qa_output_display = gr.Textbox(label="AI Answer", lines=20, placeholder="Answer will appear here with sources...")
+                        qa_output_display = gr.Textbox(
+                            label="AI Answer",
+                            lines=20,
+                            placeholder="Answer will appear here with sources..."
+                        )
 
+        # Wire up all dropdown updates
         all_dropdowns_to_update = [delete_doc_dropdown_visible, doc_dropdown_content, doc_dropdown_tag_visible]
         
         refresh_outputs = [document_list_display] + [dd for dd in all_dropdowns_to_update]
@@ -1390,7 +1185,6 @@ def create_gradio_interface():
         tag_btn_action.click(generate_tags_for_document, inputs=[doc_dropdown_tag_visible, tag_text_input, max_tags_slider], outputs=[tag_output_display])
         qa_btn_action.click(ask_question, inputs=[qa_question_input], outputs=[qa_output_display])
 
-
         # Load dashboard stats on interface load
         interface.load(
             fn=load_dashboard_stats,
@@ -1398,8 +1192,9 @@ def create_gradio_interface():
         )
         
         interface.load(fn=refresh_library, outputs=refresh_outputs)
-        return interface           
+        
+        return interface
 
 if __name__ == "__main__":
     gradio_interface = create_gradio_interface()
-    gradio_interface.launch()
+    gradio_interface.launch(mcp_server=True)

data/podcasts/metadata_db.json

@@ -0,0 +1 @@
+[]