Simplify to intelligent search: remove hardcoded ingredient lists

- Keep DialoGPT for query enhancement
- Remove all hardcoded ingredient/cuisine/meal type lists
- Pass full user query directly to TF-IDF search
- Simple but effective boosting for dessert/food word detection
- Much cleaner and more scalable approach
- Should now properly handle 'burger recipes' and 'chocolate dessert'

app.py

@@ -250,24 +250,27 @@ def load_recipes():
 
 @torch.inference_mode()
 def extract_query_features_with_llm(query_text, preferences="", max_minutes=30):
-    """Use DialoGPT and enhanced rule-based extraction for intelligent feature parsing"""
+    """Use DialoGPT to enhance query understanding, then pass full query to search"""
     global tokenizer, model
     
-    # Always use enhanced rule-based extraction as the foundation
-    enhanced_features = extract_enhanced_features(query_text, preferences, max_minutes)
+    full_query = f"{query_text} {preferences}".strip()
     
-    # If model is available, use it to enhance the extraction
+    # Start with the original query as our search terms
+    base_search_terms = [full_query]
+    
+    # If DialoGPT is available, use it to enhance understanding
+    enhanced_terms = []
     if model is not None and tokenizer is not None:
         try:
-            # Use DialoGPT conversational understanding to improve extraction
-            conversation = f"User: I want to cook {query_text} {preferences}".strip()
+            # Use DialoGPT to understand context and intent
+            conversation = f"User: I want to cook {full_query}".strip()
             
             inputs = tokenizer.encode(conversation + tokenizer.eos_token, return_tensors="pt").to(device)
             
             # Generate a response to understand intent
             outputs = model.generate(
                 inputs,
-                max_new_tokens=50,
+                max_new_tokens=30,
                 temperature=0.7,
                 top_p=0.9,
                 do_sample=True,
@@ -277,161 +280,34 @@ def extract_query_features_with_llm(query_text, preferences="", max_minutes=30):
             
             response = tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)
             
-            # Extract additional insights from DialoGPT response
-            llm_insights = extract_insights_from_response(response)
+            # Extract key food-related words from DialoGPT response
+            response_lower = response.lower()
+            food_keywords = []
+            
+            # Look for food-related words in the response
+            food_indicators = ['recipe', 'cook', 'make', 'dish', 'meal', 'food', 'ingredient', 'cuisine']
+            for word in response.split():
+                word_clean = word.lower().strip('.,!?')
+                if word_clean in food_indicators or len(word_clean) > 3:  # Capture potential food words
+                    food_keywords.append(word_clean)
             
-            # Merge enhanced features with LLM insights
-            merged_features = merge_feature_sets(enhanced_features, llm_insights)
+            enhanced_terms = food_keywords[:5]  # Limit to top 5 terms
             
-            print(f"🤖 DialoGPT-enhanced extraction: {merged_features['search_terms'][:8]}")
-            return merged_features
+            print(f"🤖 DialoGPT enhanced with: {enhanced_terms}")
             
         except Exception as e:
-            print(f"⚠️ DialoGPT enhancement failed, using rule-based: {e}")
-    
-    print(f"📋 Enhanced rule-based extraction: {enhanced_features['search_terms'][:8]}")
-    return enhanced_features
-
-def extract_enhanced_features(query_text, preferences="", max_minutes=30):
-    """Enhanced rule-based feature extraction optimized for recipe queries"""
-    query_lower = (query_text + " " + (preferences or "")).lower()
-    
-    # Comprehensive ingredient detection
-    ingredients = detect_ingredients(query_lower)
+            print(f"⚠️ DialoGPT enhancement failed: {e}")
     
-    # Meal type detection with better patterns
-    meal_types = detect_meal_types(query_lower)
-    
-    # Cuisine detection
-    cuisines = detect_cuisines(query_lower)
-    
-    # Dietary restrictions and preferences
-    dietary_restrictions = detect_dietary_preferences(query_lower)
-    
-    # Cooking styles and methods
-    cooking_styles = detect_cooking_styles(query_lower)
-    cooking_methods = detect_cooking_methods(query_lower)
-    
-    # Flavor profiles
-    flavors = detect_flavors(query_lower)
+    # Combine original query with enhanced terms
+    all_search_terms = base_search_terms + enhanced_terms
     
     return {
-        'ingredients': ingredients,
-        'meal_types': meal_types,
-        'cuisines': cuisines,
-        'dietary_restrictions': dietary_restrictions,
-        'cooking_styles': cooking_styles,
-        'cooking_methods': cooking_methods,
-        'flavors': flavors,
+        'original_query': full_query,
+        'search_terms': all_search_terms,
         'max_minutes': max_minutes,
-        'search_terms': ingredients + meal_types + cuisines + dietary_restrictions + cooking_styles + cooking_methods + flavors
-    }
-
-def detect_ingredients(query_lower):
-    """Detect ingredients with comprehensive patterns"""
-    ingredients = []
-    
-    # Comprehensive ingredient list including dessert ingredients
-    ingredient_patterns = {
-        'proteins': ['chicken', 'beef', 'pork', 'fish', 'salmon', 'shrimp', 'tofu', 'eggs', 'turkey', 'lamb'],
-        'starches': ['rice', 'pasta', 'quinoa', 'bread', 'potatoes', 'noodles', 'flour', 'oats'],
-        'vegetables': ['tomatoes', 'onion', 'garlic', 'ginger', 'peppers', 'broccoli', 'spinach', 'carrots', 'mushrooms', 'avocado'],
-        'dessert_key': ['chocolate', 'cocoa', 'sugar', 'vanilla', 'caramel', 'honey', 'maple syrup', 'cream', 'butter'],
-        'fruits': ['apple', 'banana', 'berries', 'strawberry', 'blueberry', 'lemon', 'lime', 'orange'],
-        'dairy': ['cheese', 'milk', 'yogurt', 'cream'],
-        'nuts_spices': ['nuts', 'almonds', 'walnuts', 'cinnamon', 'nutmeg', 'herbs', 'basil']
-    }
-    
-    for category, items in ingredient_patterns.items():
-        for item in items:
-            if item in query_lower:
-                ingredients.append(item)
-                # Special boost for dessert ingredients
-                if category == 'dessert_key':
-                    ingredients.append(f"sweet_{item}")  # Add emphasis for dessert context
-    
-    return list(set(ingredients))
-
-def detect_meal_types(query_lower):
-    """Enhanced meal type detection with better patterns"""
-    meal_patterns = {
-        'dessert': ['dessert', 'sweet', 'cake', 'cookie', 'pie', 'ice cream', 'pudding', 'tart', 'chocolate', 'candy'],
-        'breakfast': ['breakfast', 'morning', 'brunch', 'cereal', 'pancake', 'waffle'],
-        'lunch': ['lunch', 'midday', 'sandwich'],
-        'dinner': ['dinner', 'supper', 'evening'],
-        'snack': ['snack', 'appetizer', 'finger food'],
-        'drink': ['drink', 'beverage', 'smoothie', 'juice']
-    }
-    
-    detected = []
-    for meal_type, keywords in meal_patterns.items():
-        if any(keyword in query_lower for keyword in keywords):
-            detected.append(meal_type)
-    
-    return detected
-
-def detect_cuisines(query_lower):
-    """Detect cuisine types"""
-    cuisines = ['italian', 'mexican', 'asian', 'chinese', 'thai', 'indian', 'greek', 'french', 'mediterranean', 'american', 'japanese']
-    return [cuisine for cuisine in cuisines if cuisine in query_lower]
-
-def detect_dietary_preferences(query_lower):
-    """Detect dietary restrictions and preferences"""
-    diets = ['vegetarian', 'vegan', 'healthy', 'low-carb', 'keto', 'gluten-free', 'dairy-free']
-    return [diet for diet in diets if diet in query_lower]
-
-def detect_cooking_styles(query_lower):
-    """Detect cooking styles and preferences"""
-    styles = ['quick', 'easy', 'fast', 'slow', 'comfort', 'light', 'hearty', 'simple']
-    return [style for style in styles if style in query_lower]
-
-def detect_cooking_methods(query_lower):
-    """Detect cooking methods"""
-    methods = ['baked', 'fried', 'grilled', 'roasted', 'steamed', 'boiled', 'sauteed']
-    return [method for method in methods if method in query_lower]
-
-def detect_flavors(query_lower):
-    """Detect flavor preferences"""
-    flavors = ['sweet', 'spicy', 'savory', 'sour', 'creamy', 'crispy']
-    return [flavor for flavor in flavors if flavor in query_lower]
-
-def extract_insights_from_response(response_text):
-    """Extract insights from DialoGPT response"""
-    response_lower = response_text.lower()
-    
-    # Look for food-related words in the response
-    food_words = []
-    cooking_words = []
-    
-    # Simple extraction from response
-    food_indicators = ['recipe', 'cook', 'make', 'prepare', 'dish', 'meal', 'food']
-    for indicator in food_indicators:
-        if indicator in response_lower:
-            cooking_words.append(indicator)
-    
-    return {
-        'ingredients': food_words,
-        'cooking_context': cooking_words
+        'enhanced_by_llm': len(enhanced_terms) > 0
     }
 
-def merge_feature_sets(base_features, llm_insights):
-    """Merge rule-based features with LLM insights"""
-    # Start with base features
-    merged = base_features.copy()
-    
-    # Add LLM insights if they provide new information
-    if llm_insights.get('ingredients'):
-        merged['ingredients'].extend(llm_insights['ingredients'])
-        merged['ingredients'] = list(set(merged['ingredients']))  # Remove duplicates
-    
-    # Rebuild search terms
-    merged['search_terms'] = (
-        merged['ingredients'] + merged['meal_types'] + merged['cuisines'] + 
-        merged['dietary_restrictions'] + merged['cooking_styles'] + 
-        merged['cooking_methods'] + merged['flavors']
-    )
-    
-    return merged
 
 def parse_llm_json_response(response_text):
     """Parse LLM's JSON response into structured features"""
@@ -493,7 +369,7 @@ def extract_terms_from_text(text, terms_list):
 
 
 def search_recipes(query_features, top_k=10):
-    """Enhanced search for recipes matching the LLM-extracted features"""
+    """Simplified intelligent search using full query + DialoGPT enhancement"""
     global recipes_df, vectorizer, recipe_vectors
     
     if recipes_df is None:
@@ -505,11 +381,11 @@ def search_recipes(query_features, top_k=10):
     if len(filtered_df) == 0:
         filtered_df = recipes_df.copy()  # Fall back to all recipes
     
-    # Create search query from all LLM-extracted terms
+    # Create search query from all terms (original query + DialoGPT enhancements)
     search_query = ' '.join(query_features['search_terms'])
     
     if search_query and vectorizer is not None:
-        # Semantic search using TF-IDF
+        # Semantic search using TF-IDF on the full query
         query_vector = vectorizer.transform([search_query])
         
         # Get vectors for the filtered subset by re-indexing
@@ -538,73 +414,25 @@ def search_recipes(query_features, top_k=10):
             print(f"⚠️ Similarity length mismatch: {len(similarities)} vs {len(filtered_df)}")
             filtered_df['similarity'] = 0.5
         
-        # Apply intelligent boosting based on enhanced features
-        
-        # HIGHEST PRIORITY: Meal type matches (especially dessert)
-        if query_features.get('meal_types'):
-            for meal_type in query_features['meal_types']:
-                # Check name, tags, and search text for meal type
-                mask = (filtered_df['name'].str.lower().str.contains(meal_type, na=False) | 
-                       filtered_df['tags_text'].str.contains(meal_type, na=False) |
-                       filtered_df['search_text'].str.contains(meal_type, na=False))
-                filtered_df.loc[mask, 'similarity'] *= 3.0  # Very high boost
-                
-                # Special handling for desserts - comprehensive dessert detection
-                if meal_type == 'dessert':
-                    dessert_patterns = [
-                        'chocolate', 'cocoa', 'sugar', 'vanilla', 'cake', 'cookie', 'pie', 
-                        'sweet', 'candy', 'cream', 'frosting', 'icing', 'dessert', 'pudding',
-                        'brownie', 'tart', 'mousse', 'custard', 'fudge', 'caramel', 'honey'
-                    ]
-                    for pattern in dessert_patterns:
-                        mask = filtered_df['search_text'].str.contains(pattern, na=False)
-                        filtered_df.loc[mask, 'similarity'] *= 2.5  # Strong dessert boost
-                        
-                    # Also check recipe names for dessert indicators
-                    dessert_name_patterns = ['cake', 'cookie', 'brownie', 'pie', 'tart', 'sweet', 'chocolate']
-                    for pattern in dessert_name_patterns:
-                        mask = filtered_df['name'].str.lower().str.contains(pattern, na=False)
-                        filtered_df.loc[mask, 'similarity'] *= 2.8
-        
-        # HIGH PRIORITY: Exact ingredient matches 
-        if query_features.get('ingredients'):
-            for ingredient in query_features['ingredients']:
-                # Regular ingredient matching
-                mask = filtered_df['ingredients_text'].str.contains(ingredient.replace('sweet_', ''), na=False)
-                filtered_df.loc[mask, 'similarity'] *= 2.2
-                
-                # Special handling for dessert ingredients with sweet_ prefix
-                if ingredient.startswith('sweet_'):
-                    base_ingredient = ingredient.replace('sweet_', '')
-                    mask = filtered_df['ingredients_text'].str.contains(base_ingredient, na=False)
-                    # Check if recipe also has dessert context
-                    dessert_context_mask = (
-                        filtered_df['search_text'].str.contains('sweet|dessert|cake|cookie', na=False) |
-                        filtered_df['tags_text'].str.contains('dessert|sweet', na=False)
-                    )
-                    combined_mask = mask & dessert_context_mask
-                    filtered_df.loc[combined_mask, 'similarity'] *= 3.5  # Highest boost for dessert ingredients in dessert context
-                    
-        # MEDIUM PRIORITY: Flavor matches (sweet, spicy, etc.)
-        if query_features.get('flavors'):
-            for flavor in query_features['flavors']:
-                mask = filtered_df['search_text'].str.contains(flavor, na=False)
-                multiplier = 2.0 if flavor == 'sweet' else 1.5  # Higher boost for sweet
-                filtered_df.loc[mask, 'similarity'] *= multiplier
-                
-        # LOWER PRIORITY: Cuisine matches
-        if query_features.get('cuisines'):
-            for cuisine in query_features['cuisines']:
-                mask = (filtered_df['tags_text'].str.contains(cuisine, na=False) | 
-                       filtered_df['name'].str.lower().str.contains(cuisine, na=False))
-                filtered_df.loc[mask, 'similarity'] *= 1.4
-                
-        # LOWER PRIORITY: Cooking method matches
-        if query_features.get('cooking_methods'):
-            for method in query_features['cooking_methods']:
-                mask = (filtered_df['name'].str.lower().str.contains(method, na=False) |
-                       filtered_df['steps_text'].str.contains(method, na=False))
-                filtered_df.loc[mask, 'similarity'] *= 1.3
+        # Simple boosting based on query content detection
+        original_query = query_features.get('original_query', '').lower()
+        
+        # Boost for dessert-related queries
+        if any(word in original_query for word in ['dessert', 'sweet', 'chocolate', 'cake', 'cookie']):
+            dessert_patterns = ['chocolate', 'cake', 'cookie', 'dessert', 'sweet', 'brownie', 'pie']
+            for pattern in dessert_patterns:
+                mask = (filtered_df['name'].str.lower().str.contains(pattern, na=False) |
+                       filtered_df['search_text'].str.contains(pattern, na=False))
+                filtered_df.loc[mask, 'similarity'] *= 2.0
+        
+        # Boost for specific food mentions (burger, pasta, etc.)
+        food_words = [word for word in original_query.split() if len(word) > 3]
+        for word in food_words:
+            if word not in ['want', 'like', 'something', 'recipes', 'recipe']:
+                mask = (filtered_df['name'].str.lower().str.contains(word, na=False) |
+                       filtered_df['ingredients_text'].str.contains(word, na=False) |
+                       filtered_df['search_text'].str.contains(word, na=False))
+                filtered_df.loc[mask, 'similarity'] *= 1.5
                 
         # Sort by similarity (descending)
         filtered_df = filtered_df.sort_values('similarity', ascending=False)