Bug fix

app.py

@@ -1,174 +1,57 @@
-# import gradio as gr
-# from src.main import app as fastapi_app
-# from src.core.recommender import recommender
-# import logging
-# from src.database.mongodb import mongodb
-
-# logger = logging.getLogger(__name__)
-# # Configure basic logging if not already set up elsewhere for Gradio context
-# logging.basicConfig(level=logging.INFO)
-
-# # Manually initialize and attach recommender if not already present
-# if not hasattr(fastapi_app.state, "recommender"):
-#     recommender.load_components()
-#     fastapi_app.state.recommender = recommender
-
-# def get_recommendations_gradio(query: str, k: int = 5):
-#     try:
-#         response = fastapi_app.state.recommender.get_recommendations(query, k)
-#         return response
-#     except Exception as e:
-#         return {"error": str(e)}
-
-# def get_recommendations_by_id_gradio(msid: str, k: int = 5):
-#     try:
-#         # Corrected method name here
-#         response = fastapi_app.state.recommender.get_recommendations_by_id(msid, k)
-#         return response
-#     except Exception as e:
-#         return {"error": str(e)}
-    
-# def get_recommendations_user_feedback_gradio(user_id: str, msid: str, clicked_msid: str, k: int = 5):
-#     """
-#     Handles user feedback via Gradio:
-#     1. (Optionally) Computes recommendations based on the feedback (mimicking FastAPI endpoint action).
-#     2. Saves the feedback to MongoDB.
-#     3. Returns a success message.
-#     """
-#     try:
-#         # Step 1: (Optional) Compute recommendations based on feedback, similar to FastAPI endpoint.
-#         # The result of this call is not the final output for this Gradio UI, per the request.
-#         # This ensures the Gradio function performs similar actions to the API endpoint.
-#         _ = fastapi_app.state.recommender.get_recommendations_user_feedback(user_id, msid, clicked_msid, k)
-#         logger.info(f"Gradio: (Computed recommendations for user '{user_id}' based on click, not shown in this UI)")
-
-#         # Step 2: Save feedback to MongoDB
-#         actual_clicked_msids = [s.strip() for s in clicked_msid.split(',') if s.strip()]
-#         if not actual_clicked_msids:
-#             logger.warning(f"Gradio: Invalid clicked_msid: {clicked_msid} for user {user_id}")
-#             return {"error": "clicked_msid parameter is invalid or does not contain valid MSIDs."}
-
-#         logger.info(
-#             f"Gradio: Saving feedback for user '{user_id}', context msid: '{msid}', clicked msids: {actual_clicked_msids}"
-#         )
-        
-#         feedback_collection_name = "user_feedback_tracking"
-#         # Assuming mongodb.db is the PyMongo Database object, consistent with recommender.py
-#         feedback_collection = mongodb.db[feedback_collection_name]
-
-#         user_doc = feedback_collection.find_one({"user_id": user_id})
-
-#         if user_doc:
-#             # This update logic mirrors the one in routes.py
-#             feedback_collection.update_one(
-#                 {"user_id": user_id},
-#                 {"$addToSet": {"Articles": {"msid": msid, "Read": {"$each": actual_clicked_msids}}}}
-#             )
-#         else:
-#             feedback_collection.insert_one({
-#                 "user_id": user_id,
-#                 "Articles": [{"msid": msid, "Read": actual_clicked_msids}]
-#             })
-        
-#         logger.info(f"Gradio: Successfully saved feedback for user {user_id}")
-#         return {"message": "Response saved successfully"}
-
-#     except Exception as e:
-#         logger.error(f"Gradio: Error in get_recommendations_user_feedback_gradio for user {user_id}: {e}", exc_info=True)
-#         return {"error": f"An error occurred: {str(e)}"}
-
-# def get_recommendations_summary_gradio(msid: str, k: int = 5, summary: bool = True, smart_tip: bool = True):
-#     try:
-#         response = fastapi_app.state.recommender.get_recommendations_summary(msid, k, summary, smart_tip)
-#         return response
-#     except Exception as e:
-#         return {"error": str(e)}
-
-# iface1 = gr.Interface(
-#     fn=get_recommendations_gradio,
-#     inputs=[
-#         gr.Textbox(label="Query", placeholder="Enter your search query..."),
-#         gr.Slider(minimum=1, maximum=10, value=5, step=1, label="Number of recommendations")
-#     ],
-#     outputs=gr.JSON(),
-#     title="Recommendation System",
-#     description="Enter a query to get personalized recommendations."
-# )
-
-# iface2 = gr.Interface(
-#     fn=get_recommendations_by_id_gradio,
-#     inputs=[
-#         gr.Textbox(label="MSID", placeholder="Enter the MSID..."),
-#         gr.Slider(minimum=1, maximum=10, value=5, step=1, label="Number of recommendations")
-#         ],
-#     outputs=gr.JSON(),
-#     title="Recommendations by MSID",
-#     description="Enter an MSID to get recommendations based on it."
-# )
-
-# iface3 = gr.Interface(
-#     fn=get_recommendations_user_feedback_gradio,
-#     inputs=[
-#         gr.Textbox(label="User ID", placeholder="Enter your user ID..."),
-#         gr.Textbox(label="MSID", placeholder="Enter the MSID..."),
-#         gr.Textbox(label="Clicked MSID", placeholder="Enter the clicked MSID..."),
-#         gr.Slider(minimum=1, maximum=10, value=5, step=1, label="Number of recommendations")
-#     ],
-#     outputs=gr.JSON(),
-#     title="User Feedback Recommendations",
-#     description="Enter your user ID, MSID, and clicked MSID to get recommendations based on user feedback."
-# )
-
-# iface4 = gr.Interface(
-#     fn=get_recommendations_summary_gradio,
-#     inputs=[
-#         gr.Textbox(label="MSID", placeholder="Enter the MSID..."),
-#         gr.Slider(minimum=1, maximum=10, value=5, step=1, label="Number of recommendations"),
-#         gr.Checkbox(label="Summary", value=True),
-#         gr.Checkbox(label="Smart Tip", value=True)
-#     ],
-#     outputs=gr.JSON(),
-#     title="Recommendations Summary",
-#     description="Enter an MSID to get a summary of recommendations."
-# )
-
-# demo = gr.TabbedInterface([iface1, iface2, iface3, iface4], ["Query Recommendations", "MSID Recommendations", "User Feedback Recommendations", "Recommendations Summary"])
-
-# if __name__ == "__main__":
-#     demo.launch()
-
-# app = fastapi_app
-
-
-
-
 import logging
 import uvicorn
-from fastapi import HTTPException
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
-from typing import List
+from typing import List, Optional
+from datetime import datetime
 
-from src.main import app as fastapi_app  # Existing FastAPI app instance
 from src.core.recommender import recommender
 from src.database.mongodb import mongodb
+from src.config.settings import API_TITLE, API_DESCRIPTION, API_VERSION
 
 logger = logging.getLogger(__name__)
 # Configure basic logging if not already set up elsewhere
 if not logger.hasHandlers():
     logging.basicConfig(level=logging.INFO)
 
-# Manually initialize and attach recommender to the imported fastapi_app's state
-# This will run once when the module is loaded.
-if not hasattr(fastapi_app.state, "recommender") or fastapi_app.state.recommender is None:
-    logger.info("Recommender not found on fastapi_app.state, loading components...")
-    recommender.load_components()
-    fastapi_app.state.recommender = recommender
-    if hasattr(fastapi_app.state, "recommender") and fastapi_app.state.recommender is not None:
-        logger.info("Recommender loaded successfully onto fastapi_app.state.")
-    else:
-        logger.error("Failed to load recommender onto fastapi_app.state.")
-        # Depending on the application's needs, you might want to raise an error here
-        # or prevent the app from starting if the recommender is critical.
+# Create a new FastAPI app instance instead of importing from src.main
+app = FastAPI(
+    title=API_TITLE,
+    description=API_DESCRIPTION,
+    version=API_VERSION
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize recommender on startup
+@app.on_event("startup")
+async def startup_event():
+    """Initialize recommender system on startup."""
+    try:
+        logger.info("Initializing recommender system...")
+        recommender.load_components()
+        app.state.recommender = recommender
+        logger.info("Recommender system initialized successfully")
+    except Exception as e:
+        logger.error(f"Failed to initialize recommender system: {e}", exc_info=True)
+        # Don't raise here to allow the app to start even if recommender fails
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown."""
+    try:
+        mongodb.close()
+        logger.info("MongoDB connection closed")
+    except Exception as e:
+        logger.error(f"Error during shutdown: {e}", exc_info=True)
 
 # Pydantic models for request/response bodies
 class FeedbackPayload(BaseModel):
@@ -181,23 +64,69 @@ class FeedbackResponse(BaseModel):
     message: str
 
 # API Endpoints
-@fastapi_app.get("/recommendations/")
+@app.get("/health")
+async def health_check():
+    """
+    Health check endpoint to diagnose system status.
+    """
+    health_status = {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "components": {}
+    }
+    
+    # Check recommender system
+    if hasattr(app.state, "recommender") and app.state.recommender is not None:
+        health_status["components"]["recommender"] = {
+            "status": "available",
+            "models_loaded": {
+                "embed_model": app.state.recommender.embed_model is not None,
+                "reranker": app.state.recommender.reranker is not None,
+                "generator": app.state.recommender.generator is not None
+            },
+            "data_available": app.state.recommender.df is not None and not app.state.recommender.df.empty,
+            "faiss_index_available": app.state.recommender.index is not None,
+            "faiss_vectors": app.state.recommender.index.ntotal if app.state.recommender.index else 0
+        }
+    else:
+        health_status["components"]["recommender"] = {"status": "not_available"}
+        health_status["status"] = "degraded"
+    
+    # Check MongoDB connection
+    try:
+        if mongodb.db is not None:
+            # Try a simple operation to test connection
+            mongodb.db.command("ping")
+            health_status["components"]["mongodb"] = {"status": "connected"}
+        else:
+            health_status["components"]["mongodb"] = {"status": "not_connected"}
+            health_status["status"] = "degraded"
+    except Exception as e:
+        health_status["components"]["mongodb"] = {
+            "status": "error",
+            "error": str(e)
+        }
+        health_status["status"] = "degraded"
+    
+    return health_status
+
+@app.get("/recommendations/")
 async def get_recommendations_api(query: str, k: int = 5):
     """
     Get recommendations based on a textual query.
     """
     try:
-        if not hasattr(fastapi_app.state, "recommender") or fastapi_app.state.recommender is None:
+        if not hasattr(app.state, "recommender") or app.state.recommender is None:
             logger.error("Recommender is not available.")
             raise HTTPException(status_code=503, detail="Recommender service not available")
         
-        response = fastapi_app.state.recommender.get_recommendations(query, k)
+        response = app.state.recommender.get_recommendations(query, k)
         return response
     except Exception as e:
         logger.error(f"API Error in get_recommendations_api for query '{query}': {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
 
-@fastapi_app.get("/recommendations/msid/")
+@app.get("/recommendations/msid/")
 async def get_recommendations_by_id_api(msid: str, k: int = 5):
     """
     Get recommendations based on a given MSID.
@@ -211,13 +140,21 @@ async def get_recommendations_by_id_api(msid: str, k: int = 5):
             raise HTTPException(status_code=400, detail="k must be an integer between 1 and 10")
 
         # Check if recommender service is available
-        if not hasattr(fastapi_app.state, "recommender") or fastapi_app.state.recommender is None:
+        if not hasattr(app.state, "recommender") or app.state.recommender is None:
             logger.error("Recommender is not available.")
             raise HTTPException(status_code=503, detail="Recommender service not available")
 
+        # Check if recommender has the necessary data
+        if app.state.recommender.df is None or app.state.recommender.df.empty:
+            logger.error("Recommender data not available (MongoDB connection issue).")
+            raise HTTPException(
+                status_code=503, 
+                detail="Recommender data not available. The service is currently unable to access the required data."
+            )
+
         # Get recommendations with error handling
         try:
-            response = fastapi_app.state.recommender.get_recommendations_by_id(msid, k)
+            response = app.state.recommender.get_recommendations_by_id(msid, k)
             if not response:
                 raise HTTPException(status_code=404, detail=f"No recommendations found for MSID: {msid}")
             return response
@@ -236,7 +173,7 @@ async def get_recommendations_by_id_api(msid: str, k: int = 5):
         logger.error(f"Unexpected error in get_recommendations_by_id_api for msid '{msid}': {e}", exc_info=True)
         raise HTTPException(status_code=500, detail="An unexpected error occurred")
 
-@fastapi_app.post("/recommendations/feedback/user/", response_model=FeedbackResponse)
+@app.post("/recommendations/feedback/user/", response_model=FeedbackResponse)
 async def submit_user_feedback_api(payload: FeedbackPayload):
     """
     Submit user feedback (e.g., clicked articles) and save it.
@@ -244,49 +181,58 @@ async def submit_user_feedback_api(payload: FeedbackPayload):
     though the primary response here is the status of feedback submission.
     """
     try:
-        if not hasattr(fastapi_app.state, "recommender") or fastapi_app.state.recommender is None:
+        if not hasattr(app.state, "recommender") or app.state.recommender is None:
             logger.error("Recommender is not available.")
             raise HTTPException(status_code=503, detail="Recommender service not available")
 
         # (Optional) Compute recommendations based on feedback, similar to Gradio function.
         # The result of this call is not the primary output of this API endpoint.
-        _ = fastapi_app.state.recommender.get_recommendations_user_feedback(
-            payload.user_id, payload.msid, payload.clicked_msid, payload.k
-        )
-        logger.info(f"API: (Computed recommendations for user '{payload.user_id}' based on click, not part of this response)")
-
-        # Save feedback to MongoDB
-        actual_clicked_msids = [s.strip() for s in payload.clicked_msid.split(',') if s.strip()]
-        if not actual_clicked_msids:
-            logger.warning(f"API: Invalid clicked_msid: '{payload.clicked_msid}' for user '{payload.user_id}'")
-            raise HTTPException(status_code=400, detail="clicked_msid parameter is invalid or does not contain valid MSIDs.")
+        try:
+            _ = app.state.recommender.get_recommendations_user_feedback(
+                payload.user_id, payload.msid, payload.clicked_msid, payload.k
+            )
+            logger.info(f"API: (Computed recommendations for user '{payload.user_id}' based on click, not part of this response)")
+        except Exception as e:
+            logger.warning(f"Could not compute recommendations based on feedback: {e}")
 
-        logger.info(
-            f"API: Saving feedback for user '{payload.user_id}', context msid: '{payload.msid}', clicked msids: {actual_clicked_msids}"
-        )
-        
-        feedback_collection_name = "user_feedback_tracking"
-        # Assuming mongodb.db is the PyMongo Database object
-        if mongodb.db is None:
-            logger.error("MongoDB database connection is not available.")
-            raise HTTPException(status_code=503, detail="Database service not available")
-            
-        feedback_collection = mongodb.db[feedback_collection_name]
-        user_doc = feedback_collection.find_one({"user_id": payload.user_id})
+        # Save feedback to MongoDB (optional - only if MongoDB is available)
+        try:
+            actual_clicked_msids = [s.strip() for s in payload.clicked_msid.split(',') if s.strip()]
+            if not actual_clicked_msids:
+                logger.warning(f"API: Invalid clicked_msid: '{payload.clicked_msid}' for user '{payload.user_id}'")
+                raise HTTPException(status_code=400, detail="clicked_msid parameter is invalid or does not contain valid MSIDs.")
 
-        if user_doc:
-            feedback_collection.update_one(
-                {"user_id": payload.user_id},
-                {"$addToSet": {"Articles": {"msid": payload.msid, "Read": actual_clicked_msids}}}
+            logger.info(
+                f"API: Saving feedback for user '{payload.user_id}', context msid: '{payload.msid}', clicked msids: {actual_clicked_msids}"
             )
-        else:
-            feedback_collection.insert_one({
-                "user_id": payload.user_id,
-                "Articles": [{"msid": payload.msid, "Read": actual_clicked_msids}]
-            })
-        
-        logger.info(f"API: Successfully saved feedback for user '{payload.user_id}'")
-        return FeedbackResponse(message="Response saved successfully")
+            
+            feedback_collection_name = "user_feedback_tracking"
+            # Check if MongoDB is available
+            if mongodb.db is None:
+                logger.warning("MongoDB database connection is not available. Skipping feedback storage.")
+                return FeedbackResponse(message="Response processed successfully (feedback storage unavailable)")
+                
+            feedback_collection = mongodb.db[feedback_collection_name]
+            user_doc = feedback_collection.find_one({"user_id": payload.user_id})
+
+            if user_doc:
+                feedback_collection.update_one(
+                    {"user_id": payload.user_id},
+                    {"$addToSet": {"Articles": {"msid": payload.msid, "Read": actual_clicked_msids}}}
+                )
+            else:
+                feedback_collection.insert_one({
+                    "user_id": payload.user_id,
+                    "Articles": [{"msid": payload.msid, "Read": actual_clicked_msids}]
+                })
+            
+            logger.info(f"API: Successfully saved feedback for user '{payload.user_id}'")
+            return FeedbackResponse(message="Response saved successfully")
+            
+        except Exception as e:
+            logger.error(f"Error saving feedback to MongoDB: {e}", exc_info=True)
+            # Don't fail the entire request if MongoDB is unavailable
+            return FeedbackResponse(message="Response processed successfully (feedback storage failed)")
 
     except HTTPException:
         raise # Re-raise HTTPException directly
@@ -294,18 +240,18 @@ async def submit_user_feedback_api(payload: FeedbackPayload):
         logger.error(f"API Error in submit_user_feedback_api for user '{payload.user_id}': {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
 
-@fastapi_app.get("/recommendations/summary/")
+@app.get("/recommendations/summary/")
 async def get_recommendations_summary_api(msid: str, k: int = 5, summary: bool = True, smart_tip: bool = True):
     """
     Get recommendations with optional summary and smart tip for a given MSID.
     """
     try:
-        if not hasattr(fastapi_app.state, "recommender") or fastapi_app.state.recommender is None:
+        if not hasattr(app.state, "recommender") or app.state.recommender is None:
             logger.error("Recommender is not available.")
             raise HTTPException(status_code=503, detail="Recommender service not available")
 
         try:
-            response = fastapi_app.state.recommender.get_recommendations_summary(msid, k, summary, smart_tip)
+            response = app.state.recommender.get_recommendations_summary(msid, k, summary, smart_tip)
         except RuntimeError as e:
             # Catch the meta tensor error and return a fallback
             if "meta tensor" in str(e):
@@ -325,9 +271,5 @@ async def get_recommendations_summary_api(msid: str, k: int = 5, summary: bool =
         logger.error(f"API Error in get_recommendations_summary_api for msid '{msid}': {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"An error occurred: {str(e)}")
 
-# This makes fastapi_app (imported from src.main and extended here) available as 'app'
-# for ASGI servers like Uvicorn.
-app = fastapi_app
-
 if __name__ == "__main__":
     uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=True)

src/core/recommender.py

@@ -98,7 +98,13 @@ class RecoRecommender:
                 logger.error(f"Error during Intel XPU check: {e}. Using CPU.")
         logger.info(f"Selected device: {self.device}")
 
-        self.faiss_meta_collection = mongodb.db[MONGO_FAISS_META_COLLECTION_NAME]
+        # Initialize MongoDB collection only if connection is available
+        if mongodb.db is not None:
+            self.faiss_meta_collection = mongodb.db[MONGO_FAISS_META_COLLECTION_NAME]
+        else:
+            self.faiss_meta_collection = None
+            logger.warning("MongoDB not available. Some features may be limited.")
+        
         # Initialize model trainer
         self.model_trainer = ModelTrainer(RERANKER_MODEL_NAME, device=self.device) # Pass the determined device
         self._setup_indic_nlp()
@@ -179,6 +185,13 @@ class RecoRecommender:
     def _get_model_metadata(self) -> Dict:
         """Retrieve current model metadata from MongoDB."""
         try:
+            if self.faiss_meta_collection is None:
+                logger.warning("MongoDB not available. Returning default metadata.")
+                return {
+                    "_id": self.MODEL_METADATA_DOC_ID,
+                    "embedding_model_name": EMBED_MODEL_NAME,
+                }
+            
             metadata = self.faiss_meta_collection.find_one({"_id": self.MODEL_METADATA_DOC_ID})
             if metadata:
                 return metadata
@@ -194,11 +207,15 @@ class RecoRecommender:
         except Exception as e:
             logger.error(f"Error retrieving model metadata: {e}")
             # Return a minimal fallback to ensure core functionalities can proceed if possible
-            return {"_id": self.MODEL_METADATA_DOC_ID, "embedding_model_name": EMBED_MODEL_NAME} 
+            return {"_id": self.MODEL_METADATA_DOC_ID, "embedding_model_name": EMBED_MODEL_NAME}
 
     def _update_model_metadata(self, updates: Dict) -> bool:
         """Update model metadata in MongoDB."""
         try:
+            if self.faiss_meta_collection is None:
+                logger.warning("MongoDB not available. Cannot update model metadata.")
+                return False
+                
             result = self.faiss_meta_collection.update_one(
                 {"_id": self.MODEL_METADATA_DOC_ID},
                 {"$set": {**updates, "metadata_last_updated": datetime.now()}}, # Key changed for clarity
@@ -220,6 +237,10 @@ class RecoRecommender:
     def _needs_reembedding_batch(self, doc_ids: List[str], current_checksum: str) -> List[str]:
         """Check which documents from a batch need reembedding."""
         try:
+            if self.faiss_meta_collection is None:
+                logger.warning("MongoDB not available. Assuming all documents need reembedding.")
+                return doc_ids
+            
             # Query for all documents in one go
             metadata_docs = self.faiss_meta_collection.find(
                 {"_id": {"$in": doc_ids}}
@@ -688,30 +709,35 @@ class RecoRecommender:
             self.index = None # Ensure index is None on failure
             raise # Re-raise the exception
 
-        logger.info(f"Loading FAISS index IDs from MongoDB collection '{MONGO_FAISS_META_COLLECTION_NAME}', document_id '{self.FAISS_IDS_DOC_ID}'")
-        try:
-            ids_document = self.faiss_meta_collection.find_one({"_id": self.FAISS_IDS_DOC_ID})
-            if ids_document and "ids" in ids_document:
-                self.indexed_ids = ids_document["ids"]
-                logger.info(f"Loaded {len(self.indexed_ids)} indexed IDs from MongoDB.")
-
-                # Basic consistency check
-                if self.index and self.index.ntotal != len(self.indexed_ids):
-                    logger.warning(
-                        f"FAISS index vector count ({self.index.ntotal}) "
-                        f"does not match loaded ID count from MongoDB ({len(self.indexed_ids)}). "
-                        "Index might be inconsistent. Consider rebuilding."
-                    )
-            else:
-                logger.warning(f"FAISS index IDs document not found in MongoDB or 'ids' field missing. Will attempt to build if necessary.")
-                self.indexed_ids = [] # Initialize as empty if not found
+        # Try to load IDs from MongoDB if available
+        if self.faiss_meta_collection is not None:
+            logger.info(f"Loading FAISS index IDs from MongoDB collection '{MONGO_FAISS_META_COLLECTION_NAME}', document_id '{self.FAISS_IDS_DOC_ID}'")
+            try:
+                ids_document = self.faiss_meta_collection.find_one({"_id": self.FAISS_IDS_DOC_ID})
+                if ids_document and "ids" in ids_document:
+                    self.indexed_ids = ids_document["ids"]
+                    logger.info(f"Loaded {len(self.indexed_ids)} indexed IDs from MongoDB.")
+
+                    # Basic consistency check
+                    if self.index and self.index.ntotal != len(self.indexed_ids):
+                        logger.warning(
+                            f"FAISS index vector count ({self.index.ntotal}) "
+                            f"does not match loaded ID count from MongoDB ({len(self.indexed_ids)}). "
+                            "Index might be inconsistent. Consider rebuilding."
+                        )
+                else:
+                    logger.warning(f"FAISS index IDs document not found in MongoDB or 'ids' field missing. Will attempt to build if necessary.")
+                    self.indexed_ids = [] # Initialize as empty if not found
+
+            except Exception as e:
+                logger.error(f"Error loading FAISS index IDs from MongoDB: {e}", exc_info=True)
+                self.indexed_ids = [] # Ensure IDs list is empty on failure
+                # We don't re-raise here, as load_components will decide if a rebuild is needed
+                # based on whether self.indexed_ids is populated.
+        else:
+            logger.warning("MongoDB not available. Cannot load indexed IDs. Operating with empty ID list.")
+            self.indexed_ids = []
 
-        except Exception as e:
-            logger.error(f"Error loading FAISS index IDs from MongoDB: {e}", exc_info=True)
-            self.indexed_ids = [] # Ensure IDs list is empty on failure
-            # We don't re-raise here, as load_components will decide if a rebuild is needed
-            # based on whether self.indexed_ids is populated.
-    
     def build_indexes_and_save(self, data_already_loaded: bool = False):
         """
         Load data (if not already loaded), build FAISS index from current self.df, and save.
@@ -744,15 +770,19 @@ class RecoRecommender:
             # Save indexed_ids to MongoDB
             logger.info(f"Saving FAISS index IDs to MongoDB collection '{MONGO_FAISS_META_COLLECTION_NAME}', document_id '{self.FAISS_IDS_DOC_ID}'")
             try:
-                self.faiss_meta_collection.update_one(
-                    {"_id": self.FAISS_IDS_DOC_ID},
-                    {"$set": {"ids": self.indexed_ids, "last_updated": datetime.now()}},
-                    upsert=True
-                )
-                logger.info(f"Saved {len(self.indexed_ids)} indexed IDs to MongoDB.")
+                if self.faiss_meta_collection is not None:
+                    self.faiss_meta_collection.update_one(
+                        {"_id": self.FAISS_IDS_DOC_ID},
+                        {"$set": {"ids": self.indexed_ids, "last_updated": datetime.now()}},
+                        upsert=True
+                    )
+                    logger.info(f"Saved {len(self.indexed_ids)} indexed IDs to MongoDB.")
+                else:
+                    logger.warning("MongoDB not available. Skipping indexed IDs save.")
             except Exception as e:
                 logger.error(f"Error saving FAISS index IDs to MongoDB: {e}", exc_info=True)
-                raise # Re-raise to indicate failure in saving critical metadata
+                # Don't raise here as the FAISS index was saved successfully
+                # The IDs can be regenerated if needed
             logger.info("Index building and saving complete") # Log successful completion
         except Exception as e: # Catch any exception during the process
             logger.error(f"Error during index building: {e}", exc_info=True) # Log the error with traceback
@@ -763,64 +793,94 @@ class RecoRecommender:
         logger.info("Loading components...") # Log the start of component loading
         try: # Start a try-except block for error handling
             self.load_models() # Load all machine learning models
-            self._load_data_from_mongo() # Load data from MongoDB and preprocess it
-
-            if self.df is None or self.df.empty: # Check if the DataFrame is empty after loading
-                logger.warning("DataFrame is empty after loading from MongoDB") # Log a warning if it's empty
-                # If no data, ensure index and ids are cleared or handled appropriately
-                self.index = None
-                self.indexed_ids = []
-                logger.info("Components loaded, but no data available.")
-                return # Exit if no data
-
+            
+            # Try to load data from MongoDB, but handle failures gracefully
+            try:
+                self._load_data_from_mongo() # Load data from MongoDB and preprocess it
+                logger.info("Successfully loaded data from MongoDB")
+            except Exception as mongo_error:
+                logger.warning(f"Failed to load data from MongoDB: {mongo_error}")
+                logger.info("Attempting to work with existing FAISS index without MongoDB data...")
+                # Set df to None to indicate no MongoDB data is available
+                self.df = None
+
+            # Try to load FAISS index and IDs
             try:
                 self._load_faiss_index_and_ids() # Tries to load .bin and IDs from Mongo.
                                                 # Sets self.index and self.indexed_ids.
                                                 # self.indexed_ids will be [] if Mongo data for IDs is missing.
                                                 # Raises FileNotFoundError if .bin (INDEX_PATH) is missing.
 
-                # Consistency check and incremental update logic
-                if self.index and self.index.ntotal > 0 and not self.indexed_ids:
-                    logger.warning("FAISS index file loaded, but no corresponding IDs found in MongoDB. Rebuilding for consistency.")
-                    self.build_indexes_and_save(data_already_loaded=True)
-                elif self.index and self.indexed_ids: # Both successfully loaded and potentially non-empty
-                    logger.info("Existing FAISS index and IDs loaded from storage.")
-                    # Proceed with incremental update logic
-                    current_df_ids = set(self.df[self.id_col].tolist())
-                    indexed_ids_set = set(self.indexed_ids)
-                    new_ids_to_add = list(current_df_ids - indexed_ids_set)
- 
-                    if new_ids_to_add:
-                        logger.info(f"Found {len(new_ids_to_add)} new documents to add to the index.")
-                        new_docs_df = self.df[self.df[self.id_col].isin(new_ids_to_add)].copy()
- 
-                        new_embeddings, new_doc_ids_added = self._generate_embeddings(new_docs_df)
-
-                        if new_embeddings.size > 0:
-                            self.index.add(new_embeddings.astype(np.float32))
-                            self.indexed_ids.extend(new_doc_ids_added)
-                            logger.info(f"Added {len(new_doc_ids_added)} new vectors to FAISS index. Total vectors: {self.index.ntotal}")
-
-                            # Save the updated FAISS index
-                            faiss.write_index(self.index, INDEX_PATH)
-                            # Save the updated IDs to MongoDB
-                            self.faiss_meta_collection.update_one(
-                                {"_id": self.FAISS_IDS_DOC_ID},
-                                {"$set": {"ids": self.indexed_ids, "last_updated": datetime.now()}},
-                                upsert=True
-                            )
-                            logger.info("Updated FAISS index and IDs saved to MongoDB.")
+                if self.index and self.index.ntotal > 0:
+                    logger.info(f"FAISS index loaded successfully with {self.index.ntotal} vectors")
+                    
+                    # If we have MongoDB data, proceed with normal logic
+                    if self.df is not None and not self.df.empty:
+                        # Consistency check and incremental update logic
+                        if not self.indexed_ids:
+                            logger.warning("FAISS index file loaded, but no corresponding IDs found in MongoDB. Rebuilding for consistency.")
+                            self.build_indexes_and_save(data_already_loaded=True)
+                        else:
+                            logger.info("Existing FAISS index and IDs loaded from storage.")
+                            # Proceed with incremental update logic
+                            current_df_ids = set(self.df[self.id_col].tolist())
+                            indexed_ids_set = set(self.indexed_ids)
+                            new_ids_to_add = list(current_df_ids - indexed_ids_set)
+     
+                            if new_ids_to_add:
+                                logger.info(f"Found {len(new_ids_to_add)} new documents to add to the index.")
+                                new_docs_df = self.df[self.df[self.id_col].isin(new_ids_to_add)].copy()
+     
+                                new_embeddings, new_doc_ids_added = self._generate_embeddings(new_docs_df)
+
+                                if new_embeddings.size > 0:
+                                    self.index.add(new_embeddings.astype(np.float32))
+                                    self.indexed_ids.extend(new_doc_ids_added)
+                                    logger.info(f"Added {len(new_doc_ids_added)} new vectors to FAISS index. Total vectors: {self.index.ntotal}")
+
+                                    # Save the updated FAISS index
+                                    faiss.write_index(self.index, INDEX_PATH)
+                                    # Try to save the updated IDs to MongoDB, but don't fail if it doesn't work
+                                    try:
+                                        self.faiss_meta_collection.update_one(
+                                            {"_id": self.FAISS_IDS_DOC_ID},
+                                            {"$set": {"ids": self.indexed_ids, "last_updated": datetime.now()}},
+                                            upsert=True
+                                        )
+                                        logger.info("Updated FAISS index and IDs saved to MongoDB.")
+                                    except Exception as e:
+                                        logger.warning(f"Could not save IDs to MongoDB: {e}")
+                            else:
+                                logger.info("No new documents found to add to the index. Index is up-to-date.")
                     else:
-                        logger.info("No new documents found to add to the index. Index is up-to-date.")
+                        # No MongoDB data available, but we have a FAISS index
+                        logger.info("FAISS index available but no MongoDB data. Operating in limited mode.")
+                        if not self.indexed_ids:
+                            logger.warning("No indexed IDs available. Some functionality may be limited.")
                 else:
                     # This case handles if self.index is None (FileNotFoundError caught below)
                     # or if index was loaded but empty and no IDs from Mongo.
-                    logger.info("FAISS index and/or IDs not found or empty. Building new index.")
-                    self.build_indexes_and_save(data_already_loaded=True)
+                    if self.df is not None and not self.df.empty:
+                        logger.info("FAISS index and/or IDs not found or empty. Building new index.")
+                        self.build_indexes_and_save(data_already_loaded=True)
+                    else:
+                        logger.warning("No data available (neither MongoDB nor FAISS index). Cannot build index.")
 
             except FileNotFoundError: # This means INDEX_PATH (.bin file) was not found.
-                logger.warning(f"FAISS index file ({INDEX_PATH}) not found. Building index from scratch.")
-                self.build_indexes_and_save(data_already_loaded=True) 
+                logger.warning(f"FAISS index file ({INDEX_PATH}) not found.")
+                if self.df is not None and not self.df.empty:
+                    logger.info("Building index from scratch.")
+                    self.build_indexes_and_save(data_already_loaded=True)
+                else:
+                    logger.error("Cannot build index: no data available.")
+            except Exception as e:
+                logger.error(f"Error loading FAISS index: {e}", exc_info=True)
+                if self.df is not None and not self.df.empty:
+                    logger.info("Attempting to rebuild index due to loading error.")
+                    self.build_indexes_and_save(data_already_loaded=True)
+                else:
+                    logger.error("Cannot rebuild index: no data available.")
+                    
             logger.info("Components loaded successfully") # Log successful loading of all components
         except Exception as e: # Catch any exception during component loading
             logger.error(f"Error loading components: {e}", exc_info=True) # Log the error with traceback

src/database/mongodb.py

@@ -44,7 +44,7 @@ class MongoDB:
         """
         Establishes connection to MongoDB Atlas.
         Handles connection errors and sets up the database instance.
-        Raises exceptions if connection fails.
+        Does not raise exceptions if connection fails - allows graceful degradation.
         """
         try:
             logger.info(f"Connecting to MongoDB Atlas: DB='{MONGO_DB_NAME}'")
@@ -56,26 +56,31 @@ class MongoDB:
             self._db = self._client[MONGO_DB_NAME]
             logger.info("Successfully connected to MongoDB.")
         except (ConnectionFailure, ConfigurationError) as e:
-            logger.error(f"MongoDB connection failed: {e}", exc_info=True)
+            logger.warning(f"MongoDB connection failed: {e}")
             self._client = None
             self._db = None
-            raise
+            # Don't raise the exception - allow the application to continue without MongoDB
         except Exception as e:
-            logger.error(f"An unexpected error occurred during MongoDB connection: {e}", exc_info=True)
+            logger.warning(f"An unexpected error occurred during MongoDB connection: {e}")
             self._client = None
             self._db = None
-            raise
+            # Don't raise the exception - allow the application to continue without MongoDB
 
     @property
-    def db(self) -> Database:
+    def db(self) -> Optional[Database]:
         """
         Property to get the database instance.
-        Reconnects if the connection is lost.
+        Returns None if the connection is not available.
         Returns:
-            Database: MongoDB database instance
+            Database: MongoDB database instance or None if not connected
         """
         if self._db is None:
-            self._connect()
+            # Try to connect once, but don't keep retrying
+            try:
+                self._connect()
+            except Exception as e:
+                logger.warning(f"Failed to establish MongoDB connection: {e}")
+                return None
         return self._db
 
     @property