Update app.py

app.py

@@ -9,21 +9,17 @@ import os
 import logging
 import time
 from datetime import datetime
-from concurrent.futures import ThreadPoolExecutor
 from html.parser import HTMLParser
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, Query
 from fastapi.responses import JSONResponse
 import uvicorn
 
-# Setup logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Initialize models
-logger.info("Loading Whisper-tiny...")
+# Models
+logger.info("Loading models...")
 whisper_model = WhisperModel("tiny", device="cpu", compute_type="int8")
-
-logger.info("Loading SmolLM2-360M-Instruct...")
 model_name = "HuggingFaceTB/SmolLM2-360M-Instruct"
 tokenizer = AutoTokenizer.from_pretrained(model_name)
 model = AutoModelForCausalLM.from_pretrained(
@@ -32,14 +28,10 @@ model = AutoModelForCausalLM.from_pretrained(
     device_map="cpu",
     low_cpu_mem_usage=True
 )
-
-logger.info("All models loaded!")
-
-TAVILY_API_KEY = os.getenv('TAVILY_API_KEY', '')
-BRAVE_API_KEY = os.getenv('BRAVE_API_KEY', '')
+logger.info("Models loaded!")
 
 def search_parallel(query):
-    """Simplified search - just DuckDuckGo for speed"""
+    """DuckDuckGo search"""
     logger.info("[SEARCH] Starting...")
     try:
         response = requests.get(
@@ -81,7 +73,7 @@ def search_parallel(query):
     return "No search results", "None"
 
 def generate_answer(text_input):
-    """Main answer generation"""
+    """Generate answer"""
     logger.info(f"[AI] Question: {text_input[:60]}...")
     
     try:
@@ -90,12 +82,10 @@ def generate_answer(text_input):
         
         current_date = datetime.now().strftime("%B %d, %Y")
         
-        # Search
         search_start = time.time()
         search_results, search_engine = search_parallel(text_input)
         logger.info(f"[AI] Search: {time.time()-search_start:.2f}s")
         
-        # Generate
         messages = [
             {"role": "system", "content": f"Today is {current_date}. Answer briefly using search results (60-80 words)."},
             {"role": "user", "content": f"Search:\n{search_results}\n\nQ: {text_input}\nA:"}
@@ -127,101 +117,86 @@ def generate_answer(text_input):
         logger.error(f"[AI] Error: {str(e)}")
         return f"Error: {str(e)}"
 
-def transcribe_audio_base64(audio_base64):
-    """Transcribe audio"""
-    logger.info("[STT] Start")
+# FastAPI app
+app = FastAPI()
+
+@app.post("/api/ai")
+async def api_ai_post(request: Request):
+    """AI endpoint - POST with JSON body"""
     try:
-        audio_bytes = base64.b64decode(audio_base64)
-        
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_audio:
-            temp_audio.write(audio_bytes)
-            temp_path = temp_audio.name
+        body = await request.body()
+        logger.info(f"[API AI POST] Raw body: {body}")
         
-        segments, _ = whisper_model.transcribe(temp_path, language="en", beam_size=1)
-        transcription = " ".join([seg.text for seg in segments])
-        os.unlink(temp_path)
+        if not body:
+            return JSONResponse({"error": "Empty request body"}, status_code=400)
         
-        logger.info("[STT] ✓")
-        return transcription.strip()
+        try:
+            data = await request.json()
+        except Exception as e:
+            logger.error(f"[API AI POST] JSON parse error: {str(e)}")
+            return JSONResponse({"error": f"Invalid JSON: {str(e)}"}, status_code=400)
         
-    except Exception as e:
-        logger.error(f"[STT] Error: {str(e)}")
-        return ""
-
-# Create FastAPI app for Pluely endpoints
-app = FastAPI()
-
-@app.post("/api/stt")
-async def api_stt(request: Request):
-    """Direct STT endpoint for Pluely"""
-    try:
-        body = await request.json()
-        logger.info(f"[API STT] Received: {body}")
+        logger.info(f"[API AI POST] Parsed data: {data}")
         
-        audio_base64 = body.get("audio", "")
-        if not audio_base64:
-            return JSONResponse({"error": "No audio data"}, status_code=400)
+        question = data.get("text", "")
+        if not question:
+            return JSONResponse({"error": "No 'text' field in JSON"}, status_code=400)
         
-        text = transcribe_audio_base64(audio_base64)
-        return JSONResponse({"text": text})
+        answer = generate_answer(question)
+        return JSONResponse({"answer": answer})
         
     except Exception as e:
-        logger.error(f"[API STT] Error: {str(e)}")
+        logger.error(f"[API AI POST] Error: {str(e)}")
         return JSONResponse({"error": str(e)}, status_code=500)
 
-@app.post("/api/ai")
-async def api_ai(request: Request):
-    """Direct AI endpoint for Pluely"""
+@app.get("/api/ai")
+async def api_ai_get(text: str = Query(..., description="Question text")):
+    """AI endpoint - GET with query param (Pluely fallback)"""
     try:
-        body = await request.json()
-        logger.info(f"[API AI] Received: {body}")
+        logger.info(f"[API AI GET] Question: {text}")
         
-        question = body.get("text", "")
-        if not question:
-            return JSONResponse({"error": "No text provided"}, status_code=400)
+        if not text:
+            return JSONResponse({"error": "No text parameter"}, status_code=400)
         
-        answer = generate_answer(question)
+        answer = generate_answer(text)
         return JSONResponse({"answer": answer})
         
     except Exception as e:
-        logger.error(f"[API AI] Error: {str(e)}")
+        logger.error(f"[API AI GET] Error: {str(e)}")
         return JSONResponse({"error": str(e)}, status_code=500)
 
 @app.get("/health")
 async def health():
-    """Health check"""
     return {"status": "ok", "model": "SmolLM2-360M"}
 
-# Gradio UI (optional, for testing)
-with gr.Blocks(title="Fast Q&A", theme=gr.themes.Soft()) as demo:
+# Gradio UI
+with gr.Blocks(title="Fast Q&A") as demo:
     gr.Markdown("""
-    # ⚡ Ultra-Fast Q&A System
-    **SmolLM2-360M** + **Direct REST API** for Pluely
+    # ⚡ Ultra-Fast Q&A - SmolLM2-360M
     
-    ## Pluely Configuration:
+    ## 🎯 Pluely Configuration
     
-    ### STT Endpoint:
+    ### Option 1: GET with Query Param (EASIEST - Windows Compatible)
     ```
-    curl -X POST https://archcoder-basic-app.hf.space/api/stt -H "Content-Type: application/json" -d '{"audio": "{{AUDIO_BASE64}}"}'
+    curl https://archcoder-basic-app.hf.space/api/ai?text={{TEXT}}
     ```
-    **Response Path:** `text`
+    **Response Path:** `answer`
     
-    ### AI Endpoint:
+    ### Option 2: POST with JSON (If Option 1 doesn't work)
     ```
-    curl -X POST https://archcoder-basic-app.hf.space/api/ai -H "Content-Type: application/json" -d '{"text": "{{TEXT}}"}'
+    curl -X POST https://archcoder-basic-app.hf.space/api/ai -H "Content-Type: application/json" --data-binary @- << EOF
+    {"text":"{{TEXT}}"}
+    EOF
     ```
     **Response Path:** `answer`
     """)
     
     with gr.Tab("Test"):
-        with gr.Row():
-            test_input = gr.Textbox(label="Question", placeholder="Ask anything...")
-            test_btn = gr.Button("🚀 Test")
+        test_input = gr.Textbox(label="Question")
+        test_btn = gr.Button("🚀 Test")
         test_output = gr.Textbox(label="Answer", lines=8)
-        
         test_btn.click(fn=generate_answer, inputs=[test_input], outputs=[test_output])
 
-# Mount Gradio to FastAPI
 app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":