Update app.py

app.py

@@ -7,7 +7,7 @@ import base64
 import tempfile
 import os
 import logging
-import time  # ADDED - was missing!
+import time
 from datetime import datetime
 from concurrent.futures import ThreadPoolExecutor
 from html.parser import HTMLParser
@@ -20,8 +20,8 @@ logger = logging.getLogger(__name__)
 logger.info("Loading Whisper model...")
 whisper_model = WhisperModel("tiny", device="cpu", compute_type="int8")
 
-logger.info("Loading Qwen 2.5 1.5B-Instruct...")
-model_name = "Qwen/Qwen2.5-1.5B-Instruct"
+logger.info("Loading Qwen 2.5 0.5B-Instruct (FASTEST)...")
+model_name = "Qwen/Qwen2.5-0.5B-Instruct"  # SWITCHED BACK to 0.5B for speed
 tokenizer = AutoTokenizer.from_pretrained(model_name)
 model = AutoModelForCausalLM.from_pretrained(
     model_name,
@@ -30,24 +30,21 @@ model = AutoModelForCausalLM.from_pretrained(
     low_cpu_mem_usage=True
 )
 
-logger.info("All models loaded successfully!")
+logger.info("All models loaded!")
 
-# Search APIs configuration
 TAVILY_API_KEY = os.getenv('TAVILY_API_KEY', '')
 BRAVE_API_KEY = os.getenv('BRAVE_API_KEY', '')
 
 def search_tavily(query):
-    """Priority 1: Tavily AI search"""
     logger.info("[TAVILY] Starting...")
     if not TAVILY_API_KEY:
-        logger.warning("[TAVILY] No API key")
         return None
     
     try:
         response = requests.post(
             'https://api.tavily.com/search',
             json={'api_key': TAVILY_API_KEY, 'query': query, 'max_results': 3},
-            timeout=3
+            timeout=2  # REDUCED timeout
         )
         
         if response.status_code == 200:
@@ -55,18 +52,16 @@ def search_tavily(query):
             results = data.get('results', [])
             context = ""
             for i, result in enumerate(results[:3], 1):
-                context += f"\n[Tavily {i}] {result.get('title', '')}\n{result.get('content', '')}\n"
-            logger.info(f"[TAVILY] Success - {len(results)} results")
+                context += f"\n[{i}] {result.get('title', '')}\n{result.get('content', '')}\n"
+            logger.info(f"[TAVILY] ✓")
             return context
-    except Exception as e:
-        logger.error(f"[TAVILY] Error: {str(e)}")
+    except:
+        pass
     return None
 
 def search_brave(query):
-    """Priority 2: Brave Search"""
     logger.info("[BRAVE] Starting...")
     if not BRAVE_API_KEY:
-        logger.warning("[BRAVE] No API key")
         return None
     
     try:
@@ -74,7 +69,7 @@ def search_brave(query):
             'https://api.search.brave.com/res/v1/web/search',
             params={'q': query, 'count': 3},
             headers={'X-Subscription-Token': BRAVE_API_KEY},
-            timeout=3
+            timeout=2
         )
         
         if response.status_code == 200:
@@ -82,29 +77,22 @@ def search_brave(query):
             results = data.get('web', {}).get('results', [])
             context = ""
             for i, result in enumerate(results[:3], 1):
-                context += f"\n[Brave {i}] {result.get('title', '')}\n{result.get('description', '')}\n"
-            logger.info(f"[BRAVE] Success - {len(results)} results")
+                context += f"\n[{i}] {result.get('title', '')}\n{result.get('description', '')}\n"
+            logger.info(f"[BRAVE] ✓")
             return context
-    except Exception as e:
-        logger.error(f"[BRAVE] Error: {str(e)}")
+    except:
+        pass
     return None
 
 def search_searx(query):
-    """Priority 3: Searx"""
     logger.info("[SEARX] Starting...")
     
-    searx_instances = [
-        'https://searx.be/search',
-        'https://searx.work/search',
-        'https://search.sapti.me/search'
-    ]
-    
-    for instance in searx_instances:
+    for instance in ['https://searx.be/search', 'https://searx.work/search']:
         try:
             response = requests.get(
                 instance,
                 params={'q': query, 'format': 'json', 'categories': 'general'},
-                timeout=3
+                timeout=2
             )
             
             if response.status_code == 200:
@@ -112,23 +100,21 @@ def search_searx(query):
                 results = data.get('results', [])
                 context = ""
                 for i, result in enumerate(results[:3], 1):
-                    context += f"\n[Searx {i}] {result.get('title', '')}\n{result.get('content', '')}\n"
-                logger.info(f"[SEARX] Success from {instance}")
+                    context += f"\n[{i}] {result.get('title', '')}\n{result.get('content', '')}\n"
+                logger.info(f"[SEARX] ✓")
                 return context
-        except Exception as e:
-            logger.warning(f"[SEARX] Failed {instance}: {str(e)}")
-    
+        except:
+            continue
     return None
 
 def search_duckduckgo_html(query):
-    """Priority 4: DuckDuckGo HTML"""
     logger.info("[DDG] Starting...")
     try:
         response = requests.get(
             'https://html.duckduckgo.com/html/',
             params={'q': query},
             headers={'User-Agent': 'Mozilla/5.0'},
-            timeout=3
+            timeout=2
         )
         
         if response.status_code == 200:
@@ -158,51 +144,45 @@ def search_duckduckgo_html(query):
             
             context = ""
             for i, result in enumerate(parser.results[:3], 1):
-                context += f"\n[DDG {i}] {result}\n"
+                context += f"\n[{i}] {result}\n"
             
             if context:
-                logger.info(f"[DDG] Success")
+                logger.info(f"[DDG] ✓")
                 return context
-    except Exception as e:
-        logger.error(f"[DDG] Error: {str(e)}")
+    except:
+        pass
     return None
 
 def search_parallel(query):
-    """Execute all searches in parallel"""
-    logger.info("[PARALLEL] Starting all engines...")
+    logger.info("[SEARCH] Parallel start")
     
     with ThreadPoolExecutor(max_workers=4) as executor:
         futures = {
             executor.submit(search_tavily, query): "Tavily",
             executor.submit(search_brave, query): "Brave",
             executor.submit(search_searx, query): "Searx",
-            executor.submit(search_duckduckgo_html, query): "DuckDuckGo"
+            executor.submit(search_duckduckgo_html, query): "DDG"
         }
         
-        priority_order = ["Tavily", "Brave", "Searx", "DuckDuckGo"]
         results = {}
-        
         for future in futures:
             engine = futures[future]
             try:
-                result = future.result(timeout=4)
+                result = future.result(timeout=3)
                 if result:
                     results[engine] = result
-                    logger.info(f"[PARALLEL] {engine} completed")
-            except Exception as e:
-                logger.error(f"[PARALLEL] {engine} failed: {str(e)}")
+            except:
+                pass
         
-        for engine in priority_order:
-            if engine in results and results[engine]:
-                logger.info(f"[PARALLEL] Using {engine}")
+        for engine in ["Tavily", "Brave", "Searx", "DDG"]:
+            if engine in results:
+                logger.info(f"[SEARCH] Using {engine}")
                 return results[engine], engine
         
-        logger.error("[PARALLEL] All failed")
-        return "Unable to fetch search results.", "None"
+        return "No search results available.", "None"
 
 def transcribe_audio_base64(audio_base64):
-    """Transcribe audio"""
-    logger.info("[PLUELY STT] Request")
+    logger.info("[STT] Request")
     try:
         audio_bytes = base64.b64decode(audio_base64)
         
@@ -214,61 +194,80 @@ def transcribe_audio_base64(audio_base64):
         transcription = " ".join([seg.text for seg in segments])
         os.unlink(temp_path)
         
-        logger.info(f"[PLUELY STT] Success")
+        logger.info(f"[STT] ✓")
         return {"text": transcription.strip()}
-    
     except Exception as e:
-        logger.error(f"[PLUELY STT] Error: {str(e)}")
         return {"error": str(e)}
 
 def generate_answer(text_input):
-    """Generate answer"""
-    logger.info(f"[PLUELY AI] Question: {text_input}")
+    logger.info(f"[AI] Q: {text_input}")
     try:
         if not text_input or not text_input.strip():
             return "No input provided"
         
         current_date = datetime.now().strftime("%B %d, %Y")
         
-        logger.info("[PLUELY AI] Searching...")
+        search_start = time.time()
         search_results, search_engine = search_parallel(text_input)
-        logger.info(f"[PLUELY AI] Using {search_engine}")
+        search_time = time.time() - search_start
+        logger.info(f"[AI] Search: {search_time:.2f}s")
         
+        # IMPROVED PROMPT - Structured multi-point answers
         messages = [
-            {"role": "system", "content": f"Today is {current_date}. Answer using ONLY the search results. Be concise (100-120 words)."},
-            {"role": "user", "content": f"Search Results:\n{search_results}\n\nQuestion: {text_input}\n\nAnswer based strictly on search results:"}
+            {
+                "role": "system",
+                "content": f"""Today is {current_date}. You are a concise assistant.
+
+When answering:
+- If question asks about multiple things, list each with a one-line description
+- Use bullet points for multiple items
+- Keep total answer to 80-100 words
+- Answer ONLY from search results"""
+            },
+            {
+                "role": "user",
+                "content": f"""Search Results:
+{search_results}
+
+Question: {text_input}
+
+Answer (80-100 words, use bullets if multiple topics):"""
+            }
         ]
         
         text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
         
-        logger.info("[PLUELY AI] Generating...")
-        inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=1500)
+        gen_start = time.time()
+        inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=1200)
         
         with torch.no_grad():
             outputs = model.generate(
                 **inputs,
-                max_new_tokens=150,
-                temperature=0.4,
+                max_new_tokens=100,  # REDUCED from 150
+                temperature=0.7,      # INCREASED for faster sampling
                 do_sample=True,
                 top_p=0.9,
+                top_k=50,            # ADDED for speed
                 repetition_penalty=1.1,
                 pad_token_id=tokenizer.eos_token_id
             )
         
+        gen_time = time.time() - gen_start
+        logger.info(f"[AI] Gen: {gen_time:.2f}s")
+        
         answer = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True).strip()
         answer_with_source = f"{answer}\n\n**Source:** {search_engine}"
         
-        logger.info(f"[PLUELY AI] Done")
+        logger.info(f"[AI] ✓")
         return answer_with_source
         
     except Exception as e:
-        logger.error(f"[PLUELY AI] Error: {str(e)}")
+        logger.error(f"[AI] Error: {str(e)}")
         return f"Error: {str(e)}"
 
 def process_audio(audio_path, question_text):
-    """Main pipeline"""
     start_time = time.time()
-    logger.info("="*50)
+    logger.info("="*40)
     
     if audio_path:
         try:
@@ -285,11 +284,11 @@ def process_audio(audio_path, question_text):
     answer = generate_answer(question)
     total_time = time.time() - start_time
     
-    time_emoji = "🟢" if total_time < 4.0 else "🟡" if total_time < 6.0 else "🔴"
+    time_emoji = "🟢" if total_time < 3.0 else "🟡" if total_time < 5.0 else "🔴"
     timing = f"\n\n{time_emoji} **Time:** {total_time:.2f}s"
     
-    logger.info(f"[MAIN] Total: {total_time:.2f}s")
-    logger.info("="*50)
+    logger.info(f"[TOTAL] {total_time:.2f}s")
+    logger.info("="*40)
     
     return answer + timing, total_time
 
@@ -302,8 +301,8 @@ def text_handler(text_input):
 # Gradio UI
 with gr.Blocks(title="Fast Q&A", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # ⚡ Fast Political Q&A
-    **Parallel multi-search + Qwen 2.5 1.5B**
+    # ⚡ Ultra-Fast Q&A System
+    **Qwen 0.5B + Parallel Search** (Optimized for <3s response)
     """)
     
     with gr.Tab("🎙️ Audio"):
@@ -312,7 +311,7 @@ with gr.Blocks(title="Fast Q&A", theme=gr.themes.Soft()) as demo:
                 audio_input = gr.Audio(sources=["microphone", "upload"], type="filepath")
                 audio_submit = gr.Button("🚀 Submit", variant="primary", size="lg")
             with gr.Column():
-                audio_output = gr.Textbox(label="Answer", lines=10, show_copy_button=True)
+                audio_output = gr.Textbox(label="Answer", lines=8, show_copy_button=True)
                 audio_time = gr.Number(label="Time (s)", precision=2)
         
         audio_submit.click(fn=audio_handler, inputs=[audio_input], outputs=[audio_output, audio_time], api_name="audio_query")
@@ -323,14 +322,15 @@ with gr.Blocks(title="Fast Q&A", theme=gr.themes.Soft()) as demo:
                 text_input = gr.Textbox(label="Question", placeholder="Ask anything...", lines=3)
                 text_submit = gr.Button("🚀 Submit", variant="primary", size="lg")
             with gr.Column():
-                text_output = gr.Textbox(label="Answer", lines=10, show_copy_button=True)
+                text_output = gr.Textbox(label="Answer", lines=8, show_copy_button=True)
                 text_time = gr.Number(label="Time (s)", precision=2)
         
         text_submit.click(fn=text_handler, inputs=[text_input], outputs=[text_output, text_time], api_name="text_query")
         
         gr.Examples(
             examples=[
-                ["Is internet shut down in Bareilly today?"],
+                ["What are the top 3 news stories today?"],
+                ["Is internet shut down in Bareilly?"],
                 ["Who won 2024 US election?"]
             ],
             inputs=text_input
@@ -338,14 +338,9 @@ with gr.Blocks(title="Fast Q&A", theme=gr.themes.Soft()) as demo:
     
     with gr.Tab("🔌 API"):
         gr.Markdown("""
-        **Pluely Endpoints:**
-        
-        STT: `https://archcoder-basic-app.hf.space/call/transcribe_stt`  
-        AI: `https://archcoder-basic-app.hf.space/call/answer_ai`
-        
-        **Response Paths:**  
-        STT: `data[0].text`  
-        AI: `data[0]`
+        **Endpoints:**
+        - STT: `/call/transcribe_stt` → Path: `data[0].text`
+        - AI: `/call/answer_ai` → Path: `data[0]`
         """)
         
         with gr.Row(visible=False):
@@ -357,7 +352,10 @@ with gr.Blocks(title="Fast Q&A", theme=gr.themes.Soft()) as demo:
         gr.Button("STT", visible=False).click(fn=transcribe_audio_base64, inputs=[stt_in], outputs=[stt_out], api_name="transcribe_stt")
         gr.Button("AI", visible=False).click(fn=generate_answer, inputs=[ai_in], outputs=[ai_out], api_name="answer_ai")
     
-    gr.Markdown("🟢 < 4s | 🟡 4-6s | 🔴 > 6s")
+    gr.Markdown("""
+    **Speed:** Qwen 0.5B (1-2s) + Parallel search (1s) = **2-3s total**  
+    🟢 < 3s | 🟡 3-5s | 🔴 > 5s
+    """)
 
 if __name__ == "__main__":
     demo.queue(max_size=5)