Update main.py

main.py

@@ -8,67 +8,89 @@ from langdetect import detect
 from huggingface_hub import hf_hub_download
 import threading
 
+# --- Hugging Face cache settings ---
+os.environ["HF_HOME"] = "/tmp/hf_cache"
 os.environ["TRANSFORMERS_CACHE"] = "/tmp/hf_cache"
 
+# --- Configuration ---
 MODEL_PATH = './muril_combined_multilingual_model'
 CSV_PATH = './muril_multilingual_dataset.csv'
 HF_REPO = "Sp2503/muril-dataset"
 HF_FILE = "answer_embeddings.pt"
 
+# --- FastAPI app setup ---
 app = FastAPI(title="MuRIL Multilingual QA API")
 
 model = None
 df = None
 answer_embeddings = None
+load_status = {"ready": False, "error": None}
 
 
+# --- Load embeddings from Hugging Face ---
 def load_embeddings():
     print("📥 Downloading embeddings from Hugging Face...")
-    hf_path = hf_hub_download(repo_id=HF_REPO, filename=HF_FILE, repo_type="dataset", cache_dir="/tmp")
+    hf_path = hf_hub_download(
+        repo_id=HF_REPO,
+        filename=HF_FILE,
+        repo_type="dataset",
+        cache_dir="/tmp"
+    )
     print(f"✅ Embeddings available at {hf_path}")
     return torch.load(hf_path, map_location="cpu")
 
 
+# --- Background resource loading ---
 def load_resources():
-    global model, df, answer_embeddings
+    global model, df, answer_embeddings, load_status
     try:
         print("⚙️ Loading model and dataset in background...")
         model = SentenceTransformer(MODEL_PATH)
         df = pd.read_csv(CSV_PATH).dropna(subset=['question', 'answer'])
         answer_embeddings = load_embeddings()
+        load_status["ready"] = True
         print("✅ Model and embeddings ready.")
     except Exception as e:
+        load_status["error"] = str(e)
         print(f"❌ Error loading resources: {e}")
 
 
-# --- Fast startup ---
 @app.on_event("startup")
 def schedule_background_load():
-    thread = threading.Thread(target=load_resources)
+    """Run model load in a background thread to prevent startup timeout"""
+    thread = threading.Thread(target=load_resources, daemon=True)
     thread.start()
 
 
+# --- API Models ---
 class QueryRequest(BaseModel):
     question: str
     lang: str = None
 
+
 class QAResponse(BaseModel):
     answer: str
 
 
+# --- Root Endpoint ---
 @app.get("/")
 def root():
-    ready = model is not None and df is not None and answer_embeddings is not None
-    return {"status": "✅ Running", "model_loaded": ready}
+    if load_status["error"]:
+        return {"status": "❌ Error", "details": load_status["error"]}
+    return {"status": "✅ Running", "model_ready": load_status["ready"]}
 
 
+# --- QA Endpoint ---
 @app.post("/get-answer", response_model=QAResponse)
 def get_answer_endpoint(request: QueryRequest):
-    if model is None or df is None or answer_embeddings is None:
-        return {"answer": "⏳ Model still loading, please try again shortly."}
+    if not load_status["ready"]:
+        return {"answer": "⏳ Model still loading, please try again in a few seconds."}
 
     question_text = request.question.strip()
-    lang_filter = request.lang or detect(question_text)
+    try:
+        lang_filter = request.lang or detect(question_text)
+    except Exception:
+        lang_filter = None
 
     filtered_df = df
     filtered_embeddings = answer_embeddings
@@ -76,7 +98,10 @@ def get_answer_endpoint(request: QueryRequest):
         mask = df['lang'] == lang_filter
         filtered_df = df[mask].reset_index(drop=True)
         filtered_embeddings = answer_embeddings[mask.values]
+        if filtered_df.empty:
+            return {"answer": f"⚠️ No answers available for language '{lang_filter}'."}
 
+    # Semantic similarity search
     question_emb = model.encode(question_text, convert_to_tensor=True)
     cosine_scores = util.pytorch_cos_sim(question_emb, filtered_embeddings)
     best_idx = torch.argmax(cosine_scores).item()