This architecture maintains clean separation of

app.py

@@ -19,18 +19,19 @@ class ResearchOrchestrator:
         self.citation_manager = citation_manager
         self.formatter = formatter
 
-    def run(self, query):
+    def run(self, query, progress=gr.Progress()):
         """Execute the research pipeline with streaming updates"""
         try:
+            progress(0.0, desc="Starting research...")
             logging.info(f"Starting research for query: {query}")
             
             # Step 1: Process input
-            yield "🔍 Processing your query..."
+            progress(0.1, desc="🔍 Processing your query...")
             processed_query = self.input_handler.process_query(query)
             logging.info("Query processed successfully")
             
             # Step 2: Retrieve data
-            yield "🌐 Searching for relevant information..."
+            progress(0.3, desc="🌐 Searching for relevant information...")
             search_results = self.retriever.search(processed_query)
             
             if not search_results:
@@ -41,21 +42,23 @@ class ResearchOrchestrator:
             logging.info(f"Retrieved {len(search_results)} results")
             
             # Step 3: Analyze content
+            progress(0.5, desc="🧠 Analyzing search results...")
             yield "🧠 Analyzing search results...\n\n⏳ The AI model may be initializing. This could take a few minutes if it's the first request..."
             analysis = self.analyzer.analyze(query, search_results)
             logging.info("Analysis completed")
             
             # Step 4: Manage citations
-            yield "📎 Adding citations..."
+            progress(0.8, desc="📎 Adding citations...")
             cited_analysis = self.citation_manager.add_citations(analysis, search_results)
             logging.info("Citations added")
             
             # Step 5: Format output
-            yield "✨ Formatting response..."
+            progress(0.9, desc="✨ Formatting response...")
             formatted_output = self.formatter.format_response(cited_analysis, search_results)
             logging.info("Response formatted successfully")
             
             # Add completion notification
+            progress(1.0, desc="✅ Research complete!")
             if len(search_results) >= 3:
                 completion_message = "\n\n---\n[ANALYSIS COMPLETE] ✅ Research finished with sufficient sources."
             else:
@@ -105,14 +108,32 @@ def initialize_modules():
 # Initialize orchestrator
 orchestrator = initialize_modules()
 
-def research_assistant(query):
+# Custom CSS for spinner
+custom_css = """
+.spinner {
+  border: 4px solid #f3f3f3;
+  border-top: 4px solid #3498db;
+  border-radius: 50%;
+  width: 24px;
+  height: 24px;
+  animation: spin 1s linear infinite;
+  display: inline-block;
+  margin-right: 8px;
+}
+@keyframes spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}
+"""
+
+def research_assistant(query, progress=gr.Progress()):
     """Main entry point for the research assistant with streaming"""
     logging.info(f"Research assistant called with query: {query}")
-    for step in orchestrator.run(query):
+    for step in orchestrator.run(query, progress):
         yield step
 
 # Create Gradio interface
-with gr.Blocks(title="Research Assistant") as demo:
+with gr.Blocks(css=custom_css, title="Research Assistant") as demo:
     gr.Markdown("# 🧠 AI Research Assistant")
     gr.Markdown("Enter a research topic to get a structured analysis with sources")
     
@@ -128,6 +149,9 @@ with gr.Blocks(title="Research Assistant") as demo:
         with gr.Column():
             output = gr.Markdown(label="Analysis Results")
     
+    # Status indicator with spinner
+    status_indicator = gr.HTML("<div id='status'><span class='spinner'></span> Ready for your research query</div>")
+    
     examples = gr.Examples(
         examples=[
             "Latest advancements in quantum computing",

modules/__init__.py

@@ -7,5 +7,6 @@ from .retriever import Retriever
 from .analyzer import Analyzer
 from .citation import CitationManager
 from .formatter import OutputFormatter
+from .server_cache import server_status_cache
 
-__all__ = ['InputHandler', 'Retriever', 'Analyzer', 'CitationManager', 'OutputFormatter']
+__all__ = ['InputHandler', 'Retriever', 'Analyzer', 'CitationManager', 'OutputFormatter', 'server_status_cache']

modules/analyzer.py

@@ -3,6 +3,7 @@ from openai import OpenAI
 import requests
 import time
 import logging
+from modules.server_cache import server_status_cache
 
 class Analyzer:
     def __init__(self, base_url, api_key):
@@ -12,35 +13,37 @@ class Analyzer:
         )
         self.health_check_url = base_url.rstrip('/') + "/health"
         self.headers = {"Authorization": f"Bearer {api_key}"}
+        self.cache_key = f"server_status_{base_url}"
         
-    def wait_for_server(self, timeout=300, interval=10):
-        """
-        Waits for the server to become available by polling the health endpoint.
-        
-        Parameters:
-            timeout (int): Max time in seconds to wait
-            interval (int): Time between checks
+    def is_server_ready(self):
+        # Check cache first
+        cached_status = server_status_cache.get(self.cache_key)
+        if cached_status is not None:
+            return cached_status
             
-        Returns:
-            bool: True if server is ready, False if timeout reached
-        """
-        logging.info("⏳ Waiting for the server to initialize...")
+        # If not cached, check server
+        try:
+            response = requests.get(self.health_check_url, headers=self.headers, timeout=5)
+            is_ready = response.status_code == 200
+            server_status_cache.set(self.cache_key, is_ready)
+            return is_ready
+        except requests.exceptions.RequestException:
+            server_status_cache.set(self.cache_key, False)
+            return False
+
+    def wait_for_server(self, timeout=180, interval=10):
+        if self.is_server_ready():
+            logging.info("✅ Server is already ready (from cache).")
+            return True
+            
+        logging.info("⏳ Server not ready. Starting polling...")
         start_time = time.time()
         
         while time.time() - start_time < timeout:
-            try:
-                response = requests.get(self.health_check_url, headers=self.headers, timeout=10)
-                if response.status_code == 200:
-                    logging.info("✅ Server is ready!")
-                    return True
-                else:
-                    logging.info(f"🌐 Server responded with status: {response.status_code} — still initializing...")
-            except requests.exceptions.RequestException as e:
-                logging.info("🔴 Still unreachable — retrying...")
-            
+            if self.is_server_ready():
+                return True
             time.sleep(interval)
         
-        logging.warning("⏰ Timeout reached. Server didn't initialize in time.")
         return False
 
     def analyze(self, query, search_results):

modules/server_cache.py

@@ -0,0 +1,22 @@
+# modules/server_cache.py
+import time
+
+class ServerStatusCache:
+    def __init__(self, ttl=300):  # 5 minutes default TTL
+        self.cache = {}
+        self.ttl = ttl
+
+    def get(self, server_key):
+        if server_key in self.cache:
+            timestamp, status = self.cache[server_key]
+            if time.time() - timestamp < self.ttl:
+                return status
+            else:
+                del self.cache[server_key]  # Expired
+        return None
+
+    def set(self, server_key, status):
+        self.cache[server_key] = (time.time(), status)
+
+# Global cache instance
+server_status_cache = ServerStatusCache()