Upd imports

search/engines/duckduckgo.py

@@ -3,7 +3,7 @@ from bs4 import BeautifulSoup
 import logging
 from typing import List, Dict
 import time
-from models.reranker import MedicalReranker
+# Reranker removed - using simple relevance scoring for cooking content
 
 logger = logging.getLogger(__name__)
 
@@ -21,7 +21,7 @@ class DuckDuckGoEngine:
             'Upgrade-Insecure-Requests': '1',
         })
         self.timeout = timeout
-        self.reranker = MedicalReranker()
+        self.reranker = None  # No complex reranking needed for cooking content
     
     def search(self, query: str, num_results: int = 10) -> List[Dict]:
         """Search with multiple DuckDuckGo strategies and medical focus"""
@@ -74,29 +74,12 @@ class DuckDuckGoEngine:
         filtered_results = self._filter_irrelevant_sources(results)
         logger.info(f"Filtered {len(results)} results to {len(filtered_results)} relevant results")
         
-        # If we have results, use reranker; otherwise return what we have
+        # Simple cooking relevance scoring
         if filtered_results:
-            try:
-                reranked_results = self.reranker.rerank_results(clean_query, filtered_results, min_score)
-                logger.info(f"Reranked {len(filtered_results)} results to {len(reranked_results)} high-quality results")
-                
-                # If reranking filtered out too many results, be more lenient
-                if len(reranked_results) < min(3, num_results) and len(filtered_results) > 0:
-                    logger.warning(f"Reranking too strict ({len(reranked_results)} results), using fallback with lower threshold")
-                    # Try with even lower threshold
-                    fallback_results = self.reranker.rerank_results(clean_query, filtered_results, 0.05)
-                    if len(fallback_results) > len(reranked_results):
-                        return fallback_results[:num_results]
-                    else:
-                        # Last resort: return original filtered results with basic scoring
-                        for i, result in enumerate(filtered_results[:num_results]):
-                            result['composite_score'] = 0.5 - (i * 0.05)  # Decreasing score
-                        return filtered_results[:num_results]
-                
-                return reranked_results[:num_results]
-            except Exception as e:
-                logger.warning(f"Reranking failed: {e}, returning filtered results")
-                return filtered_results[:num_results]
+            # Add basic scoring based on cooking relevance
+            for i, result in enumerate(filtered_results[:num_results]):
+                result['composite_score'] = 0.8 - (i * 0.05)  # Decreasing score
+            return filtered_results[:num_results]
         
         return filtered_results[:num_results]
     

search/engines/video.py

@@ -5,12 +5,12 @@ from typing import List, Dict
 import time
 import re
 from urllib.parse import urlparse, quote
-from models.reranker import MedicalReranker
+# Reranker removed - using simple relevance scoring for cooking content
 
 logger = logging.getLogger(__name__)
 
 class VideoSearchEngine:
-    """Search engine for medical videos across multiple platforms"""
+    """Search engine for cooking videos across multiple platforms"""
     
     def __init__(self, timeout: int = 15):
         self.session = requests.Session()
@@ -22,7 +22,7 @@ class VideoSearchEngine:
             'Connection': 'keep-alive',
         })
         self.timeout = timeout
-        self.reranker = MedicalReranker()
+        self.reranker = None  # No complex reranking needed for cooking content
         
         # Video platforms by language
         self.video_platforms = {
@@ -216,13 +216,21 @@ class VideoSearchEngine:
                 except Exception as e:
                     logger.warning(f"Fallback video search failed: {e}")
         
-        # Use reranker to improve quality and relevance
+        # Simple cooking relevance filtering
         if results:
-            reranked_results = self.reranker.filter_youtube_results(results, query)
-            logger.info(f"Reranked {len(results)} video results to {len(reranked_results)} high-quality results")
-            return reranked_results[:num_results]
+            # Filter for cooking relevance
+            cooking_keywords = ['recipe', 'cooking', 'baking', 'food', 'ingredient', 'kitchen', 'chef', 'meal', 'dish', 'cuisine', 'cook', 'bake', 'roast', 'grill', 'fry', 'boil', 'steam', 'season', 'spice', 'herb', 'sauce', 'marinade', 'dressing']
+            relevant_results = []
+            for result in results:
+                title = result.get('title', '').lower()
+                if any(keyword in title for keyword in cooking_keywords):
+                    relevant_results.append(result)
+            
+            if relevant_results:
+                results = relevant_results
+                logger.info(f"Filtered to {len(results)} cooking-relevant video results")
         
-        logger.info(f"Found {len(results)} medical video results")
+        logger.info(f"Found {len(results)} cooking video results")
         return results[:num_results]
     
     def _search_platform(self, query: str, platform: Dict, num_results: int) -> List[Dict]: