Refactor RecommendationService to remove filtering logic

- Removed the filter construction and fallback mechanism from the recommendation process, simplifying the query to Pinecone by applying no filters.
- Updated logging to reflect the changes, ensuring clarity in the absence of filters during mentor queries.
- Enhanced the overall readability and maintainability of the code by eliminating unnecessary complexity in the filtering logic.

services/recommendation_service.py

@@ -90,56 +90,18 @@ class RecommendationService:
             embedding_time = time.perf_counter() - embedding_start
             logger.info(f"[RECOMMEND] Query embedding generated in {embedding_time:.3f}s")
             
-            filter_start = time.perf_counter()
-            filter_dict = self._build_filter(mentee_data)
-            filter_time = time.perf_counter() - filter_start
-            logger.info(f"[RECOMMEND] Filter built in {filter_time:.3f}s: {filter_dict}")
-            
             pinecone_start = time.perf_counter()
             similar_mentors = self.pinecone_service.query_similar(
                 query_vector=query_embedding,
                 top_k=top_k,
-                filter=filter_dict if filter_dict else None,
+                filter=None,
                 include_metadata=True
             )
             pinecone_time = time.perf_counter() - pinecone_start
-            logger.info(f"[RECOMMEND] Pinecone query completed in {pinecone_time:.3f}s: found {len(similar_mentors)} candidates")
-            
-            if not similar_mentors and filter_dict:
-                has_strict_filters = "rating" in filter_dict or "has_availability" in filter_dict
-                
-                if has_strict_filters:
-                    logger.warning(f"[RECOMMEND] No results with strict filter (rating/availability), trying fallback with relaxed filter")
-                    logger.info(f"[RECOMMEND] Original filter: {filter_dict}")
-                    
-                    fallback_filter = {}
-                    if mentee_data.get("skill_ids"):
-                        fallback_filter["skill_ids"] = {"$in": [str(int(id)) for id in mentee_data["skill_ids"]]}
-                    if mentee_data.get("domain_ids"):
-                        fallback_filter["domain_ids"] = {"$in": [str(int(id)) for id in mentee_data["domain_ids"]]}
-                    if mentee_data.get("career_id"):
-                        fallback_filter["career_id"] = int(mentee_data["career_id"])
-                    if mentee_data.get("status"):
-                        fallback_filter["status"] = str(mentee_data["status"])
-                    else:
-                        fallback_filter["status"] = "ACTIVATED"
-                    
-                    logger.info(f"[RECOMMEND] Fallback filter (removed rating/availability constraints): {fallback_filter}")
-                    
-                    fallback_start = time.perf_counter()
-                    similar_mentors = self.pinecone_service.query_similar(
-                        query_vector=query_embedding,
-                        top_k=top_k,
-                        filter=fallback_filter if fallback_filter else None,
-                        include_metadata=True
-                    )
-                    fallback_time = time.perf_counter() - fallback_start
-                    logger.info(f"[RECOMMEND] Fallback query completed in {fallback_time:.3f}s: found {len(similar_mentors)} candidates")
-                else:
-                    logger.warning(f"[RECOMMEND] No results found even without strict filters")
+            logger.info(f"[RECOMMEND] Pinecone query completed in {pinecone_time:.3f}s: found {len(similar_mentors)} candidates (no filter applied)")
             
             if not similar_mentors:
-                logger.warning("[RECOMMEND] No similar mentors found after fallback, returning empty list")
+                logger.warning("[RECOMMEND] No similar mentors found, returning empty list")
                 return []
             
             metadata_start = time.perf_counter()
@@ -191,42 +153,6 @@ class RecommendationService:
             logger.error(f"[RECOMMEND] Failed to recommend mentors after {total_time:.3f}s: {str(e)}", exc_info=True)
             raise
     
-    def _build_filter(self, mentee_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        filter_dict = {}
-        
-        if mentee_data.get("min_rating"):
-            min_rating = float(mentee_data["min_rating"])
-            filter_dict["rating"] = {"$gte": min_rating}
-            logger.info(f"[RECOMMEND] Adding rating filter: >= {min_rating}")
-        
-        if mentee_data.get("require_availability"):
-            filter_dict["has_availability"] = True
-            logger.info(f"[RECOMMEND] Adding availability filter: has_availability=True")
-        
-        if mentee_data.get("skill_ids"):
-            skill_ids = [str(int(id)) for id in mentee_data["skill_ids"]]
-            filter_dict["skill_ids"] = {"$in": skill_ids}
-            logger.info(f"[RECOMMEND] Adding skill_ids filter: {skill_ids}")
-        
-        if mentee_data.get("domain_ids"):
-            domain_ids = [str(int(id)) for id in mentee_data["domain_ids"]]
-            filter_dict["domain_ids"] = {"$in": domain_ids}
-            logger.info(f"[RECOMMEND] Adding domain_ids filter: {domain_ids}")
-        
-        if mentee_data.get("career_id"):
-            career_id = int(mentee_data["career_id"])
-            filter_dict["career_id"] = career_id
-            logger.info(f"[RECOMMEND] Adding career_id filter: {career_id}")
-        
-        if mentee_data.get("status"):
-            filter_dict["status"] = str(mentee_data["status"])
-            logger.info(f"[RECOMMEND] Adding status filter: {mentee_data['status']}")
-        else:
-            filter_dict["status"] = "ACTIVATED"
-            logger.info(f"[RECOMMEND] Adding default status filter: ACTIVATED")
-        
-        return filter_dict if filter_dict else None
-    
     def delete_mentor(self, mentor_id: str) -> bool:
         try:
             return self.pinecone_service.delete_mentor(mentor_id)