fyp

app/ai/agent/nodes/search_query.py

@@ -1,367 +1,195 @@
 # app/ai/agent/nodes/search_query.py
 """
 Node: Process search queries and return matching listings.
-HYBRID SEARCH: Uses Qdrant vector search + payload filters for intelligent NLP-based search.
+INTELLIGENT HYBRID SEARCH: Uses strategy selector + hybrid/vector search + natural responses.
 """
 
-import json
-import re
 from structlog import get_logger
-from langchain_openai import ChatOpenAI
-from langchain_core.messages import SystemMessage, HumanMessage
 
 from app.ai.agent.state import AgentState, FlowState
-from app.ai.agent.validators import JSONValidator
 from app.database import get_db
-from app.config import settings
-from app.ai.services.search_service import search_listings_hybrid, infer_currency_from_location
 
-logger = get_logger(__name__)
-
-# Initialize LLM for search parameter extraction
-llm = ChatOpenAI(
-    api_key=settings.DEEPSEEK_API_KEY,
-    base_url=settings.DEEPSEEK_BASE_URL,
-    model="deepseek-chat",
-    temperature=0.3,
+# Import shared intelligent services
+from app.ai.services.search_intent_classifier import classify_search_intent
+from app.ai.services.search_extractor import extract_search_params
+from app.ai.services.search_strategy_selector import select_search_strategy, SearchStrategy
+from app.ai.services.search_responder import generate_natural_response, generate_non_search_response
+from app.ai.services.search_service import (
+    search_listings_hybrid,
+    search_mongo_then_qdrant,
+    search_qdrant_then_mongo,
+    infer_currency_from_location
 )
 
-SEARCH_EXTRACTION_PROMPT = """You are extracting search criteria from a natural language property search query.
-
-User message: "{user_message}"
-
-Extract ONLY what is EXPLICITLY mentioned (set to null if not clearly stated):
-- location: City/area/neighborhood name (e.g., "Calavi", "Lagos", "Cotonou", "Victoria Island") or null
-- min_price: Minimum price as number or null
-- max_price: Maximum price as number or null (interpret "20k" as 20000, "of 20k" as max_price: 20000)
-- bedrooms: Minimum number of bedrooms or null  
-- bathrooms: Minimum number of bathrooms or null
-- listing_type: ONLY if explicitly stated. Options: "rent", "short-stay", "sale", "roommate". Set to null otherwise.
-- price_type: Payment frequency or null. Options: "monthly", "weekly", "nightly", "yearly"
-- amenities: List of desired features (e.g., ["wifi", "balcony", "parking"]) or []
-
-IMPORTANT RULES:
-- Do NOT infer listing_type from words like "house", "apartment", "room" - these are property types, not listing types
-- ONLY set listing_type if user explicitly says "for rent", "to buy", "for sale", "short stay", "roommate"
-- "I want a house of 20k in Cotonou" → listing_type: null (not mentioned)
-- "I want to rent a house" → listing_type: "rent" (explicitly mentioned)
-- "House for sale in Lagos" → listing_type: "sale" (explicitly mentioned)
-
-Price understanding:
-- "50k" or "50K" = 50000
-- "of 20k" or "for 20k" = max_price: 20000
-- "under 50k" or "less than 50k" = max_price: 50000
-- "around 80k" = min_price: 70000, max_price: 90000
-- "per month" = price_type: "monthly"
-- "per night" = price_type: "nightly"
-
-Return ONLY valid JSON:
-{{
-  "location": string or null,
-  "min_price": number or null,
-  "max_price": number or null,
-  "bedrooms": integer or null,
-  "bathrooms": integer or null,
-  "listing_type": string or null,
-  "price_type": string or null,
-  "amenities": []
-}}"""
-
-
-async def extract_search_params(user_message: str) -> dict:
-    """
-    Extract search parameters from user message.
-    
-    Args:
-        user_message: What user searched for
-    
-    Returns:
-        Dict with search parameters
-    """
-    
-    logger.info("Extracting search parameters", message_len=len(user_message))
-    
-    try:
-        prompt = SEARCH_EXTRACTION_PROMPT.format(user_message=user_message)
-        
-        response = await llm.ainvoke([
-            SystemMessage(content="Extract search parameters from user query. Return ONLY valid JSON."),
-            HumanMessage(content=prompt)
-        ])
-        
-        response_text = response.content if hasattr(response, 'content') else str(response)
-        
-        # ✅ Validate JSON
-        validation = JSONValidator.extract_and_validate(response_text)
-        
-        if not validation.is_valid:
-            logger.warning("Search parameter validation failed")
-            return {}
-        
-        logger.info("Search parameters extracted", keys=list(validation.data.keys()))
-        return validation.data
-    
-    except Exception as e:
-        logger.error("Search extraction error", exc_info=e)
-        return {}
+logger = get_logger(__name__)
 
 
-async def search_listings(search_params: dict) -> list:
+async def search_mongodb(params: dict, limit: int = 10) -> list:
     """
-    Query MongoDB for listings matching search criteria.
-    
-    Args:
-        search_params: Dict with location, price, bedrooms, etc.
-    
-    Returns:
-        List of matching listings
+    Search MongoDB for listings (used for MONGO_ONLY strategy).
+    Consistent with the implementation in app/routes/search.py
     """
-    
-    logger.info("Searching listings", params_keys=list(search_params.keys()))
-    
     try:
         db = await get_db()
         
         # Build MongoDB query
         query = {"status": "active"}
         
-        # Location filter
-        if search_params.get("location"):
-            # Case-insensitive location search
-            location = search_params["location"]
-            query["location"] = {"$regex": location, "$options": "i"}
+        # Filters
+        if params.get("location"):
+            query["location"] = {"$regex": params["location"], "$options": "i"}
         
-        # Price filters
-        if search_params.get("min_price"):
-            query["price"] = {"$gte": search_params["min_price"]}
-        if search_params.get("max_price"):
+        if params.get("min_price"):
+            query["price"] = {"$gte": params["min_price"]}
+        
+        if params.get("max_price"):
             if "price" in query:
-                query["price"]["$lte"] = search_params["max_price"]
+                query["price"]["$lte"] = params["max_price"]
             else:
-                query["price"] = {"$lte": search_params["max_price"]}
-        
-        # Bedrooms
-        if search_params.get("bedrooms"):
-            query["bedrooms"] = {"$gte": search_params["bedrooms"]}
-        
-        # Bathrooms
-        if search_params.get("bathrooms"):
-            query["bathrooms"] = {"$gte": search_params["bathrooms"]}
+                query["price"] = {"$lte": params["max_price"]}
         
-        # Listing type
-        if search_params.get("listing_type"):
-            query["listing_type"] = search_params["listing_type"].lower()
+        if params.get("bedrooms"):
+            query["bedrooms"] = {"$gte": params["bedrooms"]}
         
-        # Amenities
-        if search_params.get("amenities"):
-            amenities = [a.lower() for a in search_params["amenities"]]
-            query["amenities"] = {"$in": amenities}
-        
-        logger.info("MongoDB query built", query=query)
+        if params.get("bathrooms"):
+            query["bathrooms"] = {"$gte": params["bathrooms"]}
+            
+        if params.get("listing_type"):
+            query["listing_type"] = {"$regex": params["listing_type"], "$options": "i"}
+
+        if params.get("amenities") and len(params["amenities"]) > 0:
+            # Note: Params amenities are already lowercased by extractor
+            amenity_regex = [{"amenities": {"$regex": a, "$options": "i"}} for a in params["amenities"]]
+            query["$and"] = amenity_regex
+
+        logger.info("Agent MongoDB query", query=query)
         
-        # Execute query with limit
-        results = await db.listings.find(query).limit(10).to_list(10)
+        # Execute query
+        results = await db.listings.find(query).limit(limit).to_list(limit)
         
-        # Convert ObjectId to string to prevent serialization errors
+        # Convert ObjectId
         for item in results:
             if "_id" in item:
                 item["_id"] = str(item["_id"])
-        
-        logger.info("Search completed", results_count=len(results))
-        
+                
         return results
     
     except Exception as e:
-        logger.error("Listing search error", exc_info=e)
+        logger.error("Agent MongoDB search error", exc_info=e)
         return []
 
 
-SEARCH_RESULTS_PROMPT = """You are presenting property search results to a user.
-
-CRITICAL LANGUAGE RULE:
-The user's query is: "{user_query}"
-- If the query is in ENGLISH, respond in ENGLISH
-- If the query is in FRENCH, respond in FRENCH
-
-USER INFO:
-- Name: {user_name}
-- Query: "{user_query}"
-- Mode: {search_mode}
-
-SEARCH RESULTS ({count} properties found):
-{listings_summary}
-
-CURRENCY: {currency}
-
-YOUR TASK - KEEP IT SHORT:
-
-1. If search_mode is "strict" or "broad":
-   - These are EXACT MATCHES for what the user asked.
-   - Start with: "Here are {count} properties in [location]! 🏠" (or similar short intro)
-   - DO NOT say "suggestions" or "alternatives" - these ARE what they asked for.
-
-2. If search_mode is "relaxed":
-   - You couldn't find exact matches, so these are alternatives.
-   - Say: "I couldn't find exactly what you're looking for, but you might like these:"
-
-3. FORMAT EACH PROPERTY (in the USER'S LANGUAGE):
-   - Show: "1. [Title] - [Price] 💰"
-   - Add ONE short sentence describing it IN THE USER'S LANGUAGE (even if title is different language)
-   - Example English: "1. Villa de Prestige - 350,000 XOF/month 💰 → A luxurious 4-bedroom villa with pool"
-   - Example French: "1. 3-Bed Rent in Cotonou - 200,000 XOF/mois 💰 → Appartement 3 chambres bien situé"
-
-4. Keep responses concise - users see full details on cards below.
-
-Write ONLY the response text."""
-
-
-async def generate_search_results_text(
-    listings: list, 
-    search_params: dict, 
-    user_query: str,
-    user_name: str = None,
-    inferred_currency: str = None,
-    search_mode: str = "strict"
-) -> str:
+async def search_query_handler(state: AgentState) -> AgentState:
     """
-    Use LLM to generate personalized, multilingual search results text.
+    Handle search flow with INTELLIGENT STRATEGY SELECTION.
+    Consistent with the API implementation.
     """
     
-    count = len(listings)
-    
-    # Build listings summary for LLM
-    if listings:
-        listings_summary = ""
-        for i, listing in enumerate(listings, 1):
-            title = listing.get("title", "Untitled")
-            loc = listing.get("location", "Unknown")
-            price = float(listing.get("price", 0) or 0)
-            currency = listing.get("currency", inferred_currency or "XOF")
-            price_type = listing.get("price_type", "monthly")
-            bedrooms = listing.get("bedrooms", "?")
-            description = str(listing.get("description", ""))[:100]
-            relevance = listing.get("_relevance_score", 0)
-            
-            listings_summary += f"""
-Property {i}:
-- Title: {title}
-- Location: {loc}
-- Price: {currency} {price:,.0f} {price_type}
-- Bedrooms: {bedrooms}
-- Description: {description}...
-- Match Score: {relevance:.2f}
-"""
-    else:
-        listings_summary = "No properties found."
-    
-    # Format prompt
-    prompt = SEARCH_RESULTS_PROMPT.format(
-        user_name=user_name or "there",
-        user_query=user_query,
-        count=count,
-        listings_summary=listings_summary,
-        currency=inferred_currency or "local currency",
-        search_mode=search_mode
-    )
+    user_query = state.last_user_message
+    logger.info("Agent handling search query", user_query=user_query)
     
     try:
-        messages = [
-            SystemMessage(content="You are AIDA, a friendly and helpful real estate AI assistant. You help users find 'closest matches' when exact ones aren't available."),
-            HumanMessage(content=prompt)
-        ]
+        # STEP 1: Classify intent
+        intent_result = await classify_search_intent(user_query)
         
-        response = await llm.ainvoke(messages)
-        return response.content.strip()
-        
-    except Exception as e:
-        logger.error("LLM search text generation failed", error=str(e))
-        return f"I found {count} properties that might interest you! Take a look below."
-
+        if not intent_result.get("is_search", False):
+            # Not a search query? The intent classifier in graph.py usually handles this,
+            # but if we end up here, treat it gracefully.
+            logger.info("Agent: Non-search input detected inside search node")
+            
+            # Helper extraction just for language detection
+            params = await extract_search_params(user_query)
+            user_lang = params.get("user_language", "en")
+            
+            response_text = await generate_non_search_response(user_query, user_lang)
+            state.temp_data["response_text"] = response_text
+            state.temp_data["action"] = "search_invalid"
+            return state
 
-async def search_query_handler(state: AgentState) -> AgentState:
-    """
-    Handle search flow with Two-Step Hybrid Search (Strict -> Relaxed).
-    """
-    
-    logger.info("Handling search query", user_id=state.user_id)
-    
-    try:
-        # STEP 1: Extract search parameters
-        search_params = await extract_search_params(state.last_user_message)
+        # STEP 2: Extract params
+        search_params = await extract_search_params(user_query)
         
         if not search_params:
             state.temp_data["response_text"] = "I couldn't quite understand your search. Could you try rephrasing it?"
             state.temp_data["action"] = "search_invalid"
             return state
-        
-        # Helper: Check if query has location
-        def has_location_filter(params: dict) -> bool:
-            return bool(params.get("location"))
-        
-        # STEP 2: PRIMARY SEARCH - Always use MongoDB for location searches (exact match)
-        # This ensures users get exact location results, not semantic "similar" results
-        if has_location_filter(search_params):
-            logger.info("Location search: Using MongoDB for exact match", location=search_params.get("location"))
-            results = await search_listings(search_params)
-            inferred_currency = await infer_currency_from_location(search_params.get("location"))
-            search_mode = "strict"
             
-            # STEP 3: If no exact matches, offer suggestions via Qdrant semantic search
+        # STEP 3: Select Strategy
+        strategy_result = await select_search_strategy(user_query, search_params)
+        strategy = strategy_result.get("strategy", SearchStrategy.MONGO_ONLY)
+        
+        logger.info(f"Agent Strategy: {strategy} - {strategy_result.get('reasoning')}")
+        
+        # STEP 4: Execute Strategy
+        results = []
+        limit = 10
+        currency = "XOF"
+        
+        if strategy == SearchStrategy.MONGO_ONLY:
+            results = await search_mongodb(search_params, limit)
+            # Infer currency
+            if search_params.get("location"):
+                 currency, _ = await infer_currency_from_location(search_params["location"])
+            
+            # Fallback if no results
             if not results:
-                logger.info("No exact matches found, trying Qdrant for suggestions...")
-                results, _ = await search_listings_hybrid(
-                    user_query=state.last_user_message,
+                logger.info("Agent: MONGO_ONLY yielded 0 results, attempting fallback")
+                results, currency = await search_listings_hybrid(
+                    user_query=user_query,
                     search_params=search_params,
+                    limit=limit,
                     mode="relaxed"
                 )
-                if results:
-                    search_mode = "relaxed"
-                    logger.info("Found semantic suggestions", count=len(results))
-        else:
-            # No location specified - use semantic search for general queries
-            logger.info("General query: Using Qdrant semantic search")
-            results, inferred_currency = await search_listings_hybrid(
-                user_query=state.last_user_message,
+                strategy = "QDRANT_FALLBACK"
+
+        elif strategy == SearchStrategy.QDRANT_ONLY:
+            results, currency = await search_listings_hybrid(
+                user_query=user_query,
                 search_params=search_params,
-                mode="strict"
+                limit=limit,
+                mode="relaxed"
             )
-            search_mode = "strict"
             
-            if not results:
-                results, _ = await search_listings_hybrid(
-                    user_query=state.last_user_message,
-                    search_params=search_params,
-                    mode="relaxed"
-                )
-                if results:
-                    search_mode = "relaxed"
-        
-        # STEP 5: Generate LLM Response
-        formatted_results = await generate_search_results_text(
-            listings=results, 
-            search_params=search_params,
-            user_query=state.last_user_message,
-            user_name=state.user_name,
-            inferred_currency=inferred_currency,
-            search_mode=search_mode
+        elif strategy == SearchStrategy.MONGO_THEN_QDRANT:
+            results, currency = await search_mongo_then_qdrant(
+                user_query=user_query,
+                search_params=search_params,
+                limit=limit
+            )
+            
+        elif strategy == SearchStrategy.QDRANT_THEN_MONGO:
+            results, currency = await search_qdrant_then_mongo(
+                user_query=user_query,
+                search_params=search_params,
+                limit=limit
+            )
+            
+        # STEP 5: Generate Natural Response
+        response_text = await generate_natural_response(
+            user_query=user_query,
+            count=len(results),
+            params=search_params,
+            listings=results,
+            strategy_used=strategy
         )
         
-        # STEP 6: Finalize state
+        # Add conversational prompt if needed
+        if not results:
+             response_text += "\n\nWould you like me to notify you if something matches this later? Just say 'notify me'!"
+             
+        # STEP 6: Finalize State
         state.search_results = results
-        state.temp_data["response_text"] = formatted_results
+        state.temp_data["response_text"] = response_text
         state.temp_data["action"] = "search_results"
-        state.temp_data["inferred_currency"] = inferred_currency
+        state.temp_data["inferred_currency"] = currency
+        state.temp_data["strategy_used"] = strategy
         
-        # Offer notification if no exact matches were found (even if suggestions were shown)
-        if search_mode == "relaxed" or not results:
-            state.temp_data["response_text"] += "\n\nWould you like me to notify you if an exact match for your request becomes available? Just say \"notify me\"!"
-
         state.transition_to(FlowState.SEARCH_RESULTS)
         state.transition_to(FlowState.IDLE)
         
         return state
-    
+        
     except Exception as e:
-        logger.error("Search flow failed", exc_info=e)
+        logger.error("Agent search flow failed", exc_info=e)
         state.set_error(str(e))
         return state

app/ai/services/search_extractor.py

@@ -0,0 +1,106 @@
+# app/ai/services/search_extractor.py
+"""
+Search Parameter Extractor - Shared service for extracting search criteria from natural language.
+Used by both the REST API and the AI Agent.
+"""
+
+import logging
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage, HumanMessage
+from app.config import settings
+from app.ai.agent.validators import JSONValidator
+
+logger = logging.getLogger(__name__)
+
+# LLM for extraction
+llm = ChatOpenAI(
+    api_key=settings.DEEPSEEK_API_KEY,
+    base_url=settings.DEEPSEEK_BASE_URL,
+    model="deepseek-chat",
+    temperature=0.1,  # Low temperature for precision
+)
+
+EXTRACTION_PROMPT = """You are a multilingual search assistant. Extract search criteria and output in ENGLISH.
+
+User's query: "{query}"
+
+TASK:
+1. Understand the query in ANY language
+2. FIX ALL TYPOS (especially city names)
+3. Translate values to ENGLISH
+4. Detect user's language
+
+LOCATION TYPO FIXES (IMPORTANT):
+- "clalavi"/"callavi"/"clavai" → "Calavi"
+- "cotonoo"/"cotonu"/"kotonoo" → "Cotonou"
+- "lagoss"/"laogs"/"lagos" → "Lagos"
+- "porto novo"/"portonovo" → "Porto-Novo"
+- "abujaa"/"abja" → "Abuja"
+
+LISTING TYPE (translate to English):
+- "en vente"/"à vendre"/"for sale" → "sale"
+- "à louer"/"for rent"/"location" → "rent"
+- "courte durée"/"short stay" → "short-stay"
+- "colocataire"/"roommate" → "roommate"
+
+PRICE PARSING:
+- "20k"/"20000" → 20000
+- "house of 20k" → min_price: 18000, max_price: 22000
+- "under 50k" → max_price: 50000
+- "above 100k" → min_price: 100000
+
+AMENITIES - Extract mentioned amenities:
+- "balcony", "pool", "swimming pool", "parking", "wifi", "gym", "security"
+- "furnished", "air conditioning", "garden", "elevator", "kitchen"
+- Also detect contextual features like "close to school", "near beach", "quiet neighborhood"
+
+Return ONLY valid JSON (fields null if not found):
+{{
+  "location": string or null,
+  "min_price": number or null,
+  "max_price": number or null,
+  "bedrooms": number or null,
+  "bathrooms": number or null,
+  "listing_type": "rent" | "sale" | "short-stay" | "roommate" | null,
+  "amenities": [],
+  "contextual_features": [],
+  "user_language": "en" | "fr" | "es" | "pt" | etc.
+}}"""
+
+
+async def extract_search_params(query: str) -> dict:
+    """
+    Extract and normalize search parameters from natural language query.
+    
+    Args:
+        query: User's natural language query
+        
+    Returns:
+        Dict of normalized parameters
+    """
+    try:
+        prompt = EXTRACTION_PROMPT.format(query=query)
+        
+        response = await llm.ainvoke([
+            SystemMessage(content="Extract search params. Fix typos. Translate to English. JSON only."),
+            HumanMessage(content=prompt)
+        ])
+        
+        response_text = response.content if hasattr(response, 'content') else str(response)
+        validation = JSONValidator.extract_and_validate(response_text)
+        
+        if not validation.is_valid:
+            logger.warning(f"Parameter extraction validation failed for: {query}")
+            return {"user_language": "en"}
+        
+        # Clean up amenities (lowercase)
+        data = validation.data
+        if data.get("amenities"):
+            data["amenities"] = [a.lower() for a in data["amenities"]]
+            
+        logger.info(f"Extracted params: {data}")
+        return data
+    
+    except Exception as e:
+        logger.error(f"Extraction error: {e}")
+        return {"user_language": "en"}

app/ai/services/search_intent_classifier.py

@@ -0,0 +1,153 @@
+# app/ai/services/search_intent_classifier.py
+"""
+Search Intent Classifier - Detects if user input is a property search query or casual conversation.
+
+This prevents the search endpoint from trying to search for greetings, thank yous, or general questions.
+"""
+
+import logging
+from typing import Dict
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage, HumanMessage
+from app.config import settings
+from app.ai.agent.validators import JSONValidator
+
+logger = logging.getLogger(__name__)
+
+# LLM for intent classification
+llm = ChatOpenAI(
+    api_key=settings.DEEPSEEK_API_KEY,
+    base_url=settings.DEEPSEEK_BASE_URL,
+    model="deepseek-chat",
+    temperature=0.1,  # Low temperature for consistent classification
+)
+
+
+INTENT_CLASSIFICATION_PROMPT = """You are a search intent classifier for a real estate platform.
+
+User input: "{user_input}"
+
+TASK: Determine if this input is a PROPERTY SEARCH QUERY or NOT.
+
+PROPERTY SEARCH indicators:
+- Mentions location (Cotonou, Lagos, Calavi, etc.)
+- Mentions property features (bedrooms, bathrooms, balcony, pool, etc.)
+- Mentions price or budget
+- Mentions property type (house, apartment, room, etc.)
+- Mentions listing type (rent, sale, short stay)
+- Uses search verbs (show me, find, search, looking for, need, want)
+- General property searches (houses, apartments, properties)
+
+NOT property search:
+- Greetings (hello, hi, hey, bonjour, salut)
+- Thanks/appreciation (thank you, thanks, merci)
+- Casual questions (how are you, what can you do, how does this work)
+- Confirmations (yes, no, ok, sure)
+- General chat (talking about weather, life, etc.)
+- Commands unrelated to search (help, contact, support)
+
+Examples:
+✅ "show me 3 bedroom apartments in Cotonou" → SEARCH
+✅ "houses with pool" → SEARCH
+✅ "apartment under 200k" → SEARCH
+✅ "properties in Lagos" → SEARCH
+✅ "je cherche maison à Calavi" → SEARCH
+✅ "cozy place near beach" → SEARCH
+❌ "hello there" → NOT SEARCH
+❌ "thank you so much" → NOT SEARCH
+❌ "how are you?" → NOT SEARCH
+❌ "yes" → NOT SEARCH
+❌ "what can you do?" → NOT SEARCH
+
+Return ONLY valid JSON:
+{{
+  "is_search": true or false,
+  "confidence": 0.0 to 1.0,
+  "reason": "brief explanation"
+}}"""
+
+
+async def classify_search_intent(user_input: str) -> Dict:
+    """
+    Classify if user input is a property search query.
+    
+    Args:
+        user_input: User's message
+    
+    Returns:
+        Dict with:
+        - is_search: bool
+        - confidence: float (0.0 - 1.0)
+        - reason: str
+    """
+    
+    # Quick pattern matching for obvious cases
+    user_lower = user_input.lower().strip()
+    
+    # Very short inputs are usually not searches
+    if len(user_lower) < 3:
+        return {
+            "is_search": False,
+            "confidence": 0.95,
+            "reason": "Input too short to be a search query"
+        }
+    
+    # Common greetings
+    greetings = ["hi", "hello", "hey", "bonjour", "salut", "good morning", "good evening"]
+    if user_lower in greetings:
+        return {
+            "is_search": False,
+            "confidence": 1.0,
+            "reason": "Common greeting detected"
+        }
+    
+    # Common thanks
+    thanks = ["thanks", "thank you", "merci", "thx", "ty"]
+    if user_lower in thanks:
+        return {
+            "is_search": False,
+            "confidence": 1.0,
+            "reason": "Thank you message detected"
+        }
+    
+    # Common confirmations
+    confirmations = ["yes", "no", "ok", "okay", "sure", "oui", "non"]
+    if user_lower in confirmations:
+        return {
+            "is_search": False,
+            "confidence": 0.9,
+            "reason": "Confirmation word detected"
+        }
+    
+    # Use LLM for complex cases
+    try:
+        prompt = INTENT_CLASSIFICATION_PROMPT.format(user_input=user_input)
+        
+        response = await llm.ainvoke([
+            SystemMessage(content="Classify if input is a property search. Return JSON only."),
+            HumanMessage(content=prompt)
+        ])
+        
+        response_text = response.content if hasattr(response, 'content') else str(response)
+        validation = JSONValidator.extract_and_validate(response_text)
+        
+        if not validation.is_valid:
+            logger.warning(f"Intent classification validation failed for: {user_input}")
+            return {
+                "is_search": True,  # Default to search if uncertain
+                "confidence": 0.5,
+                "reason": "Classification uncertain, defaulting to search"
+            }
+        
+        result = validation.data
+        logger.info(f"Intent classified: is_search={result.get('is_search')}, confidence={result.get('confidence')}")
+        return result
+    
+    except Exception as e:
+        logger.error(f"Intent classification error: {e}")
+        # Default to search on error (better to show no results than refuse valid searches)
+        return {
+            "is_search": True,
+            "confidence": 0.5,
+            "reason": "Classification failed, defaulting to search"
+        }

app/ai/services/search_responder.py

@@ -0,0 +1,170 @@
+# app/ai/services/search_responder.py
+"""
+Search Responder - Shared service for generating natural, multilingual, and enthusiastic search responses.
+Used by both the REST API and the AI Agent.
+"""
+
+import logging
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage, HumanMessage
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+# LLM for response generation
+llm = ChatOpenAI(
+    api_key=settings.DEEPSEEK_API_KEY,
+    base_url=settings.DEEPSEEK_BASE_URL,
+    model="deepseek-chat",
+    temperature=0.3,
+)
+
+RESPONSE_GENERATION_PROMPT = """You are AIDA, a friendly real estate search assistant.
+
+User's query: "{user_query}"
+User's language: {user_language}
+Found: {count} properties
+Strategy used: {strategy}
+
+Properties summary:
+{properties_summary}
+
+YOUR TASK - Generate a NATURAL, CONVERSATIONAL response:
+
+1. **Language**: Respond in {user_language} (the user's language)
+
+2. **Tone**: Friendly, enthusiastic, helpful (like a real estate agent excited to show properties)
+
+3. **Format**:
+   - If {count} > 0:
+     * Start with enthusiasm: "I found {count} amazing properties..." or "Great news! I found..."
+     * MENTION SPECIFIC FEATURES they asked for that were found (balcony, pool, close to school, etc.)
+     * Use emojis sparingly for friendliness: 🏠 🌟 ✨
+     * Example GOOD: "I found 3 fantastic properties with a balcony, swimming pool, and close to a school in Cotonou! Check them out 🏠"
+     * Example BAD: "Found 3 properties in your area"
+   
+   - If {count} == 0:
+     * Be empathetic and helpful
+     * Suggest trying different criteria
+     * Example: "I couldn't find any properties matching those exact criteria. Try adjusting your budget or location? 🔍"
+
+4. **Keep it concise**: 1-2 sentences max. The user will see full details in the property cards below.
+
+5. **NO generic responses**: Always mention specific features when available
+
+Examples:
+✅ GOOD (English): "I found 5 beautiful apartments with balconies and parking in Cotonou! Prices range from 150k to 300k 🏠"
+✅ GOOD (French): "J'ai trouvé 3 maisons magnifiques avec piscine et proche d'une école à Calavi ! Parfait pour votre famille 🌟"
+❌ BAD: "Found 3 properties in your area"
+❌ BAD: "Here are your search results"
+
+Write ONLY the response message (no quotes, no extra formatting)."""
+
+
+async def generate_natural_response(
+    user_query: str,
+    count: int,
+    params: dict,
+    listings: list,
+    strategy_used: str = "SEARCH"
+) -> str:
+    """
+    Generate natural, conversational response mentioning specific amenities.
+    
+    Args:
+        user_query: Original user text
+        count: Number of results found
+        params: Extracted search parameters
+        listings: List of found listings (for summary)
+        strategy_used: Name of strategy used (for context)
+    """
+    try:
+        user_lang = params.get("user_language", "en")
+        
+        # Build properties summary from top results
+        if listings:
+            properties_summary = ""
+            # Take top 5 for summary context
+            top_listings = listings[:5]
+            for i, listing in enumerate(top_listings, 1):
+                # Handle both dict (raw) and object (Pydantic) access
+                get_val = lambda obj, key, default: obj.get(key, default) if isinstance(obj, dict) else getattr(obj, key, default)
+                
+                title = get_val(listing, "title", "Property")
+                location = get_val(listing, "location", "Unknown")
+                price = get_val(listing, "price", 0)
+                currency = get_val(listing, "currency", "XOF")
+                bedrooms = get_val(listing, "bedrooms", "?")
+                amenities = get_val(listing, "amenities", [])
+                
+                properties_summary += f"\n{i}. {title} in {location} - {currency} {price:,.0f} - {bedrooms} beds"
+                if amenities:
+                    if isinstance(amenities, list):
+                        properties_summary += f" - Amenities: {', '.join(amenities[:3])}"
+        else:
+            properties_summary = "No properties found"
+        
+        # Generate response
+        prompt = RESPONSE_GENERATION_PROMPT.format(
+            user_query=user_query,
+            user_language=user_lang,
+            count=count,
+            strategy=strategy_used,
+            properties_summary=properties_summary
+        )
+        
+        response = await llm.ainvoke([
+            SystemMessage(content=f"Generate natural, enthusiastic search results message in {user_lang}. Mention specific features."),
+            HumanMessage(content=prompt)
+        ])
+        
+        message = response.content.strip()
+        
+        # Remove quotes if LLM added them
+        if message.startswith('"') and message.endswith('"'):
+            message = message[1:-1]
+        if message.startswith("'") and message.endswith("'"):
+            message = message[1:-1]
+        
+        return message
+    
+    except Exception as e:
+        logger.error(f"Response generation error: {e}")
+        # Fallback
+        if count > 0:
+            return f"Found {count} properties! Check them out below 🏠"
+        else:
+            return "No properties found. Try adjusting your search criteria 🔍"
+
+
+async def generate_non_search_response(user_input: str, user_language: str = "en") -> str:
+    """Generate friendly response for non-search inputs."""
+    
+    templates = {
+        "en": [
+            "Hey! I'm your property search assistant 🏠 Try asking me to find properties like 'Show me 3-bedroom apartments in Cotonou' 🔍",
+            "Hi there! I help you search for properties. Try something like 'Find houses with a pool in Lagos' 🏊‍♂️",
+            "Hello! I'm here to help you find your perfect property. Just describe what you're looking for! 🏡"
+        ],
+        "fr": [
+            "Salut ! Je suis votre assistant de recherche immobilière 🏠 Essayez de me demander 'Trouve-moi des appartements 3 chambres à Cotonou' 🔍",
+            "Bonjour ! Je vous aide à chercher des propriétés. Essayez quelque chose comme 'Maisons avec piscine à Lagos' 🏊‍♂️",
+            "Coucou ! Je suis là pour vous aider à trouver votre propriété idéale. Décrivez simplement ce que vous cherchez ! 🏡"
+        ]
+    }
+    
+    # Pick template based on language
+    lang_templates = templates.get(user_language, templates["en"])
+    
+    # Check if it's a greeting
+    user_lower = user_input.lower()
+    if any(greeting in user_lower for greeting in ["hello", "hi", "hey", "bonjour", "salut"]):
+        return lang_templates[0]
+    elif any(thanks in user_lower for thanks in ["thank", "merci", "thx"]):
+        thank_responses = {
+            "en": "You're welcome! Let me know if you need to search for more properties! 😊",
+            "fr": "De rien ! Faites-moi savoir si vous voulez chercher d'autres propriétés ! 😊"
+        }
+        return thank_responses.get(user_language, thank_responses["en"])
+    else:
+        return lang_templates[2]

app/ai/services/search_service.py

@@ -399,3 +399,242 @@ async def search_listings_hybrid(
     )
     
     return results, currency
+
+
+# ============================================================
+# ADVANCED HYBRID STRATEGIES
+# ============================================================
+
+async def search_mongo_then_qdrant(
+    user_query: str,
+    search_params: Dict[str, Any],
+    limit: int = 10
+) -> Tuple[List[Dict], str]:
+    """
+    Strategy: Filter by location/price in MongoDB first, then use Qdrant for semantic ranking.
+    
+    Use case: "house close to international school in Calavi"
+    - Step 1: MongoDB filters for Calavi
+    - Step 2: Qdrant semantic search within those results for "close to school"
+    
+    Args:
+        user_query: Original user query for semantic understanding
+        search_params: Extracted parameters (must have location or price)
+        limit: Max results to return
+    
+    Returns:
+        Tuple of (results, inferred_currency)
+    """
+    
+    logger.info("MONGO_THEN_QDRANT strategy", location=search_params.get("location"))
+    
+    if not qdrant_client:
+        logger.error("Qdrant client not available")
+        return [], "XOF"
+    
+    from app.database import get_db
+    
+    try:
+        db = await get_db()
+        
+        # Step 1: Build MongoDB filter for location/price/basic filters
+        mongo_query = {"status": "active"}
+        
+        if search_params.get("location"):
+            location = search_params["location"]
+            mongo_query["location"] = {"$regex": location, "$options": "i"}
+        
+        if search_params.get("min_price"):
+            mongo_query["price"] = {"$gte": search_params["min_price"]}
+        
+        if search_params.get("max_price"):
+            if "price" in mongo_query:
+                mongo_query["price"]["$lte"] = search_params["max_price"]
+            else:
+                mongo_query["price"] = {"$lte": search_params["max_price"]}
+        
+        if search_params.get("bedrooms"):
+            mongo_query["bedrooms"] = {"$gte": search_params["bedrooms"]}
+        
+        if search_params.get("bathrooms"):
+            mongo_query["bathrooms"] = {"$gte": search_params["bathrooms"]}
+        
+        if search_params.get("listing_type"):
+            mongo_query["listing_type"] = {"$regex": search_params["listing_type"], "$options": "i"}
+        
+        logger.info("MongoDB pre-filter", query=mongo_query)
+        
+        # Fetch more results than needed for semantic filtering
+        cursor = db.listings.find(mongo_query).limit(limit * 3)
+        mongo_results = []
+        async for doc in cursor:
+            if "_id" in doc:
+                doc["_id"] = str(doc["_id"])
+            mongo_results.append(doc)
+        
+        logger.info(f"MongoDB returned {len(mongo_results)} candidates")
+        
+        if not mongo_results:
+            # No results from MongoDB filter
+            currency = "XOF"
+            if search_params.get("location"):
+                currency, _ = await infer_currency_from_location(search_params["location"])
+            return [], currency
+        
+        # Step 2: Use Qdrant to semantically rank these MongoDB results
+        # Get their IDs
+        mongo_ids = [doc.get("_id") for doc in mongo_results]
+        
+        # Embed the user query for semantic search
+        query_vector = await embed_query(user_query)
+        
+        if not query_vector:
+            # If embedding fails, return MongoDB results as-is
+            logger.warning("Embedding failed, returning MongoDB results")
+            currency = "XOF"
+            if search_params.get("location"):
+                currency, _ = await infer_currency_from_location(search_params["location"])
+            return mongo_results[:limit], currency
+        
+        # Search Qdrant but filter to only these MongoDB IDs
+        from qdrant_client.models import Filter, FieldCondition, MatchAny
+        
+        id_filter = Filter(
+            must=[
+                FieldCondition(
+                    key="_id",
+                    match=MatchAny(any=mongo_ids)
+                )
+            ]
+        )
+        
+        qdrant_results = await qdrant_client.query_points(
+            collection_name=COLLECTION_NAME,
+            query=query_vector,
+            query_filter=id_filter,
+            limit=limit,
+            with_payload=True
+        )
+        
+        # Format results
+        final_results = []
+        for point in qdrant_results.points:
+            listing = dict(point.payload)
+            listing["_relevance_score"] = point.score
+            listing["_search_strategy"] = "MONGO_THEN_QDRANT"
+            final_results.append(listing)
+        
+        logger.info(f"Qdrant semantic ranking returned {len(final_results)} results")
+        
+        # Infer currency
+        currency = "XOF"
+        if search_params.get("location"):
+            currency, _ = await infer_currency_from_location(search_params["location"])
+        
+        return final_results, currency
+    
+    except Exception as e:
+        logger.error(f"MONGO_THEN_QDRANT error: {e}")
+        return [], "XOF"
+
+
+async def search_qdrant_then_mongo(
+    user_query: str,
+    search_params: Dict[str, Any],
+    limit: int = 10
+) -> Tuple[List[Dict], str]:
+    """
+    Strategy: Semantic search first in Qdrant, then apply MongoDB filters.
+    
+    Use case: "modern luxurious apartment" (semantic primary, filters secondary)
+    - Step 1: Qdrant semantic search for "modern luxurious"
+    - Step 2: Apply MongoDB filters to those results
+    
+    Args:
+        user_query: Original user query for semantic search
+        search_params: Extracted parameters for filtering
+        limit: Max results to return
+    
+    Returns:
+        Tuple of (results, inferred_currency)
+    """
+    
+    logger.info("QDRANT_THEN_MONGO strategy")
+    
+    if not qdrant_client:
+        logger.error("Qdrant client not available")
+        return [], "XOF"
+    
+    try:
+        # Step 1: Semantic search in Qdrant (get more results for filtering)
+        query_vector = await embed_query(user_query)
+        
+        if not query_vector:
+            logger.warning("Embedding failed in QDRANT_THEN_MONGO")
+            return [], "XOF"
+        
+        # Get semantic results (no filters yet)
+        qdrant_results = await qdrant_client.query_points(
+            collection_name=COLLECTION_NAME,
+            query=query_vector,
+            limit=limit * 3,  # Get more for filtering
+            with_payload=True
+        )
+        
+        candidates = [dict(point.payload) for point in qdrant_results.points]
+        
+        logger.info(f"Qdrant returned {len(candidates)} semantic candidates")
+        
+        # Step 2: Apply MongoDB-style filters in Python
+        filtered_results = []
+        
+        for listing in candidates:
+            # Check each filter
+            if search_params.get("location"):
+                location_filter = search_params["location"].lower()
+                listing_location = listing.get("location", "").lower()
+                if location_filter not in listing_location:
+                    continue
+            
+            if search_params.get("min_price"):
+                if listing.get("price", 0) < search_params["min_price"]:
+                    continue
+            
+            if search_params.get("max_price"):
+                if listing.get("price", float('inf')) > search_params["max_price"]:
+                    continue
+            
+            if search_params.get("bedrooms"):
+                if listing.get("bedrooms", 0) < search_params["bedrooms"]:
+                    continue
+            
+            if search_params.get("bathrooms"):
+                if listing.get("bathrooms", 0) < search_params["bathrooms"]:
+                    continue
+            
+            if search_params.get("listing_type"):
+                listing_type_filter = search_params["listing_type"].lower()
+                listing_type = listing.get("listing_type", "").lower()
+                if listing_type_filter not in listing_type:
+                    continue
+            
+            # Passed all filters
+            listing["_search_strategy"] = "QDRANT_THEN_MONGO"
+            filtered_results.append(listing)
+            
+            if len(filtered_results) >= limit:
+                break
+        
+        logger.info(f"After filtering: {len(filtered_results)} results")
+        
+        # Infer currency
+        currency = "XOF"
+        if search_params.get("location"):
+            currency, _ = await infer_currency_from_location(search_params["location"])
+        
+        return filtered_results, currency
+    
+    except Exception as e:
+        logger.error(f"QDRANT_THEN_MONGO error: {e}")
+        return [], "XOF"
+

app/ai/services/search_strategy_selector.py

@@ -0,0 +1,189 @@
+# app/ai/services/search_strategy_selector.py
+"""
+Search Strategy Selector - Intelligently chooses the optimal search strategy.
+
+Strategies:
+- MONGO_ONLY: Pure MongoDB filters (structured queries with clear filters)
+- QDRANT_ONLY: Pure semantic search (vague/descriptive queries)
+- MONGO_THEN_QDRANT: Filter by location/price in MongoDB, then semantic search within results
+- QDRANT_THEN_MONGO: Semantic search first, then apply MongoDB filters
+"""
+
+import logging
+from typing import Dict, Literal
+from enum import Enum
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage, HumanMessage
+from app.config import settings
+from app.ai.agent.validators import JSONValidator
+
+logger = logging.getLogger(__name__)
+
+
+class SearchStrategy(str, Enum):
+    """Available search strategies"""
+    MONGO_ONLY = "MONGO_ONLY"
+    QDRANT_ONLY = "QDRANT_ONLY"
+    MONGO_THEN_QDRANT = "MONGO_THEN_QDRANT"
+    QDRANT_THEN_MONGO = "QDRANT_THEN_MONGO"
+
+
+# LLM for strategy selection
+llm = ChatOpenAI(
+    api_key=settings.DEEPSEEK_API_KEY,
+    base_url=settings.DEEPSEEK_BASE_URL,
+    model="deepseek-chat",
+    temperature=0.2,
+)
+
+
+STRATEGY_SELECTION_PROMPT = """You are a search strategy selector for a real estate platform.
+
+User query: "{user_query}"
+
+Extracted parameters:
+{search_params}
+
+AVAILABLE STRATEGIES:
+
+1. MONGO_ONLY - Fast MongoDB filtering
+   Use when: Query has clear structured filters (location, price, bedrooms, etc.) and NO semantic/contextual requirements
+   Example: "3 bedroom apartment in Cotonou under 200k"
+   
+2. QDRANT_ONLY - Pure semantic search
+   Use when: Query is vague, descriptive, or contextual with NO specific location/price filters
+   Example: "cozy modern apartment with good vibes"
+   
+3. MONGO_THEN_QDRANT - Filter first, then semantic search
+   Use when: Query has a specific location/price filter AND semantic requirements
+   Example: "house close to international school in Calavi" (MongoDB for Calavi, Qdrant for "close to school")
+   Example: "family-friendly apartment in Cotonou" (MongoDB for Cotonou, Qdrant for "family-friendly")
+   
+4. QDRANT_THEN_MONGO - Semantic first, then filter
+   Use when: Primary focus is semantic/descriptive, but has minor filters
+   Example: "luxurious modern apartment" (Qdrant for "luxurious modern", then MongoDB can filter)
+
+DECISION RULES:
+- If location specified + semantic features (near school, quiet, family-friendly, etc.) → MONGO_THEN_QDRANT
+- If only structured filters (location, price, beds, baths) → MONGO_ONLY
+- If only semantic/descriptive (cozy, modern, good vibes, spacious) → QDRANT_ONLY
+- If semantic is primary but has some filters → QDRANT_THEN_MONGO
+
+Return ONLY valid JSON:
+{{
+  "strategy": "MONGO_ONLY" | "QDRANT_ONLY" | "MONGO_THEN_QDRANT" | "QDRANT_THEN_MONGO",
+  "reasoning": "brief explanation of why this strategy was chosen",
+  "has_semantic_features": true or false,
+  "has_structured_filters": true or false
+}}"""
+
+
+async def select_search_strategy(user_query: str, search_params: Dict) -> Dict:
+    """
+    Select optimal search strategy based on query and extracted parameters.
+    
+    Args:
+        user_query: Original user query
+        search_params: Extracted search parameters
+    
+    Returns:
+        Dict with:
+        - strategy: SearchStrategy enum value
+        - reasoning: str
+        - has_semantic_features: bool
+        - has_structured_filters: bool
+    """
+    
+    # Quick heuristics for obvious cases
+    has_location = bool(search_params.get("location"))
+    has_price = bool(search_params.get("min_price") or search_params.get("max_price"))
+    has_bedrooms = bool(search_params.get("bedrooms"))
+    has_bathrooms = bool(search_params.get("bathrooms"))
+    has_listing_type = bool(search_params.get("listing_type"))
+    has_amenities = bool(search_params.get("amenities") and len(search_params.get("amenities", [])) > 0)
+    
+    structured_count = sum([has_location, has_price, has_bedrooms, has_bathrooms, has_listing_type])
+    
+    # Detect semantic keywords in query
+    semantic_keywords = [
+        "close to", "near", "nearby", "walking distance",
+        "quiet", "peaceful", "calm", "serene",
+        "family-friendly", "family", "safe",
+        "modern", "contemporary", "new", "renovated",
+        "cozy", "comfortable", "warm",
+        "luxurious", "luxury", "prestigious", "elegant",
+        "spacious", "large", "big", "roomy",
+        "bright", "sunny", "well-lit",
+        "good vibes", "nice area", "good neighborhood",
+        "beach", "school", "market", "downtown", "city center",
+    ]
+    
+    query_lower = user_query.lower()
+    has_semantic = any(keyword in query_lower for keyword in semantic_keywords)
+    
+    # Simple rule-based decision for clear cases
+    if structured_count >= 2 and not has_semantic and not has_amenities:
+        # Pure structured query
+        return {
+            "strategy": SearchStrategy.MONGO_ONLY,
+            "reasoning": "Query has multiple structured filters and no semantic features",
+            "has_semantic_features": False,
+            "has_structured_filters": True
+        }
+    
+    if structured_count == 0 and (has_semantic or has_amenities):
+        # Pure semantic query
+        return {
+            "strategy": SearchStrategy.QDRANT_ONLY,
+            "reasoning": "Query is purely semantic/descriptive with no structured filters",
+            "has_semantic_features": True,
+            "has_structured_filters": False
+        }
+    
+    if has_location and has_semantic:
+        # Location + semantic features
+        return {
+            "strategy": SearchStrategy.MONGO_THEN_QDRANT,
+            "reasoning": "Query has location filter and semantic features - filter by location first, then semantic search",
+            "has_semantic_features": True,
+            "has_structured_filters": True
+        }
+    
+    # Use LLM for complex cases
+    try:
+        params_str = "\n".join([f"- {k}: {v}" for k, v in search_params.items() if v])
+        prompt = STRATEGY_SELECTION_PROMPT.format(
+            user_query=user_query,
+            search_params=params_str if params_str else "No parameters extracted"
+        )
+        
+        response = await llm.ainvoke([
+            SystemMessage(content="Select optimal search strategy. Return JSON only."),
+            HumanMessage(content=prompt)
+        ])
+        
+        response_text = response.content if hasattr(response, 'content') else str(response)
+        validation = JSONValidator.extract_and_validate(response_text)
+        
+        if not validation.is_valid:
+            logger.warning(f"Strategy selection validation failed, defaulting to MONGO_ONLY")
+            return {
+                "strategy": SearchStrategy.MONGO_ONLY,
+                "reasoning": "Strategy selection failed, using MongoDB filters",
+                "has_semantic_features": False,
+                "has_structured_filters": True
+            }
+        
+        result = validation.data
+        logger.info(f"Strategy selected: {result.get('strategy')} - {result.get('reasoning')}")
+        return result
+    
+    except Exception as e:
+        logger.error(f"Strategy selection error: {e}")
+        # Default to MONGO_ONLY on error
+        return {
+            "strategy": SearchStrategy.MONGO_ONLY,
+            "reasoning": "Strategy selection error, defaulting to MongoDB",
+            "has_semantic_features": False,
+            "has_structured_filters": True
+        }

app/routes/search.py

@@ -1,15 +1,14 @@
 # ============================================================
-# app/routes/search.py - AIDA Reliable Hybrid Search
+# app/routes/search.py - AIDA Intelligent Search System
 # ============================================================
 """
-BULLETPROOF SEARCH:
-1. User types in ANY language with ANY typos
-2. AI normalizes to English
-3. MongoDB tries first (fast, strict)
-4. Qdrant fallback if no results (semantic, fuzzy)
-5. Response in user's language
+SUPER INTELLIGENT SEARCH:
+1. Detects if input is a search query or casual conversation
+2. Intelligently chooses optimal search strategy (MongoDB, Qdrant, or combinations)
+3. Generates natural, conversational responses mentioning specific amenities
+4. Handles non-search inputs gracefully
 
-Goal: If property exists, user WILL find it.
+Goal: Provide an exceptional search experience with smart strategy selection.
 """
 
 import logging
@@ -21,27 +20,21 @@ from app.database import get_db
 from app.models.listing import Listing
 from app.guards.jwt_guard import get_current_user
 
-# Import LLM
-from langchain_openai import ChatOpenAI
-from langchain_core.messages import SystemMessage, HumanMessage
-from app.config import settings
-from app.ai.agent.validators import JSONValidator
-
-# Import Qdrant hybrid search
-from app.ai.services.search_service import search_listings_hybrid
+# Import shared AI services
+from app.ai.services.search_intent_classifier import classify_search_intent
+from app.ai.services.search_strategy_selector import select_search_strategy, SearchStrategy
+from app.ai.services.search_extractor import extract_search_params
+from app.ai.services.search_responder import generate_natural_response, generate_non_search_response
+from app.ai.services.search_service import (
+    search_listings_hybrid,
+    search_mongo_then_qdrant,
+    search_qdrant_then_mongo,
+)
 
 router = APIRouter(tags=["AIDA Search"])
 
 logger = logging.getLogger(__name__)
 
-# LLM
-llm = ChatOpenAI(
-    api_key=settings.DEEPSEEK_API_KEY,
-    base_url=settings.DEEPSEEK_BASE_URL,
-    model="deepseek-chat",
-    temperature=0.2,
-)
-
 
 # ============================================================
 # SCHEMAS
@@ -58,76 +51,7 @@ class SearchResponseDto(BaseModel):
     data: List[dict]
     total: int
     search_params: Optional[dict] = None
-
-
-# ============================================================
-# EXTRACTION PROMPT
-# ============================================================
-
-EXTRACTION_PROMPT = """You are a multilingual search assistant. Extract search criteria and output in ENGLISH.
-
-User's query: "{query}"
-
-TASK:
-1. Understand the query in ANY language
-2. FIX ALL TYPOS (especially city names)
-3. Translate values to ENGLISH
-4. Detect user's language
-
-LOCATION TYPO FIXES (IMPORTANT):
-- "clalavi"/"callavi"/"clavai" → "Calavi"
-- "cotonoo"/"cotonu"/"kotonoo" → "Cotonou"
-- "lagoss"/"laogs"/"lagos" → "Lagos"
-- "porto novo"/"portonovo" → "Porto-Novo"
-- "abujaa"/"abja" → "Abuja"
-
-LISTING TYPE (translate to English):
-- "en vente"/"à vendre"/"for sale" → "sale"
-- "à louer"/"for rent"/"location" → "rent"
-- "courte durée"/"short stay" → "short-stay"
-- "colocataire"/"roommate" → "roommate"
-
-PRICE PARSING:
-- "20k"/"20000" → 20000
-- "house of 20k" → min_price: 18000, max_price: 22000
-- "under 50k" → max_price: 50000
-- "above 100k" → min_price: 100000
-
-Return ONLY valid JSON:
-{{
-  "location": string or null,
-  "min_price": number or null,
-  "max_price": number or null,
-  "bedrooms": number or null,
-  "bathrooms": number or null,
-  "listing_type": "rent" | "sale" | "short-stay" | "roommate" | null,
-  "amenities": [],
-  "user_language": "en" | "fr" | "es" | "pt" | etc.
-}}"""
-
-
-async def extract_search_params(query: str) -> dict:
-    """Extract and normalize search parameters."""
-    try:
-        prompt = EXTRACTION_PROMPT.format(query=query)
-        
-        response = await llm.ainvoke([
-            SystemMessage(content="Extract search params. Fix typos. Translate to English. JSON only."),
-            HumanMessage(content=prompt)
-        ])
-        
-        response_text = response.content if hasattr(response, 'content') else str(response)
-        validation = JSONValidator.extract_and_validate(response_text)
-        
-        if not validation.is_valid:
-            return {"user_language": "en"}
-        
-        logger.info(f"Extracted: {validation.data}")
-        return validation.data
-    
-    except Exception as e:
-        logger.error(f"Extraction error: {e}")
-        return {"user_language": "en"}
+    strategy_used: Optional[str] = None
 
 
 # ============================================================
@@ -155,6 +79,9 @@ async def search_mongodb(params: dict, limit: int = 10) -> list:
     if params.get("bedrooms"):
         query["bedrooms"] = {"$gte": params["bedrooms"]}
     
+    if params.get("bathrooms"):
+        query["bathrooms"] = {"$gte": params["bathrooms"]}
+    
     if params.get("listing_type"):
         query["listing_type"] = {"$regex": params["listing_type"], "$options": "i"}
     
@@ -177,84 +104,6 @@ async def search_mongodb(params: dict, limit: int = 10) -> list:
         return []
 
 
-# ============================================================
-# QDRANT FALLBACK (Semantic, but still respect location)
-# ============================================================
-
-async def search_qdrant_fallback(query: str, params: dict, limit: int = 10) -> list:
-    """Semantic search fallback - but STILL filter by location if specified."""
-    try:
-        logger.info("Trying Qdrant semantic fallback...")
-        results, _ = await search_listings_hybrid(
-            user_query=query,
-            search_params=params,
-            limit=limit * 3,  # Get more results to filter
-            mode="relaxed"
-        )
-        
-        # IMPORTANT: Filter by location if user specified one
-        # This prevents returning random listings from other cities
-        location_filter = params.get("location")
-        if location_filter and results:
-            filtered = []
-            for doc in results:
-                doc_location = doc.get("location", "")
-                # Case-insensitive partial match
-                if location_filter.lower() in doc_location.lower():
-                    filtered.append(doc)
-            logger.info(f"Qdrant: {len(results)} raw → {len(filtered)} after location filter")
-            return filtered[:limit]
-        
-        return results[:limit]
-    except Exception as e:
-        logger.error(f"Qdrant fallback error: {e}")
-        return []
-
-
-# ============================================================
-# RESPONSE GENERATOR
-# ============================================================
-
-async def generate_message(query: str, count: int, params: dict, used_fallback: bool) -> str:
-    """Generate response in user's language."""
-    try:
-        user_lang = params.get("user_language", "en")
-        location = params.get("location", "")
-        
-        # Quick templates for common cases (no LLM call needed)
-        if count == 0:
-            templates = {
-                "en": "No properties found. Try adjusting your search.",
-                "fr": "Aucune propriété trouvée. Essayez d'autres critères.",
-                "es": "No se encontraron propiedades. Intente otra búsqueda.",
-                "pt": "Nenhuma propriedade encontrada. Tente outros critérios."
-            }
-            return templates.get(user_lang, templates["en"])
-        
-        # Build response with LLM for natural phrasing
-        prompt = f"""Generate a 1-sentence search result message.
-Count: {count} properties found
-Location: {location or 'search area'}
-Language: {user_lang}
-
-Examples:
-- en: "Found {count} properties in {location}!"
-- fr: "Voici {count} propriétés à {location} !"
-
-Write ONLY the message."""
-        
-        response = await llm.ainvoke([
-            SystemMessage(content=f"Respond in {user_lang}. One sentence only."),
-            HumanMessage(content=prompt)
-        ])
-        
-        return response.content.strip()
-    
-    except Exception as e:
-        logger.error(f"Message error: {e}")
-        return f"Found {count} properties!" if count > 0 else "No properties found."
-
-
 # ============================================================
 # MAIN SEARCH ENDPOINT
 # ============================================================
@@ -265,33 +114,89 @@ async def aida_search(
     current_user: dict = Depends(get_current_user),
 ):
     """
-    RELIABLE HYBRID SEARCH
-    
-    1. Extract & normalize query (any language → English)
-    2. Search MongoDB first (fast, strict)
-    3. If no results → Qdrant fallback (semantic, fuzzy)
-    4. Respond in user's language
+    SUPER INTELLIGENT SEARCH
     
-    If a property exists, the user WILL find it.
+    1. Detects if input is a search query or casual conversation
+    2. Intelligently chooses optimal strategy (MongoDB, Qdrant, combinations)
+    3. Generates natural responses mentioning specific amenities
+    4. Handles non-search inputs gracefully
     """
     
-    logger.info(f"AIDA Search: {dto.query}")
+    logger.info(f"AIDA Search Request: {dto.query}")
     
     try:
-        # Step 1: Extract parameters
+        # Step 1: Classify intent - is this a search query?
+        intent_result = await classify_search_intent(dto.query)
+        
+        if not intent_result.get("is_search", False):
+            # Not a search query - handle gracefully
+            logger.info(f"Non-search input detected: {intent_result.get('reason')}")
+            
+            # Extract language for response
+            params = await extract_search_params(dto.query)
+            user_lang = params.get("user_language", "en")
+            
+            message = await generate_non_search_response(dto.query, user_lang)
+            
+            return SearchResponseDto(
+                success=True,
+                message=message,
+                data=[],
+                total=0,
+                search_params={"is_search": False, "confidence": intent_result.get("confidence")},
+                strategy_used="NON_SEARCH"
+            )
+        
+        # Step 2: Extract search parameters
         search_params = await extract_search_params(dto.query)
         
-        # Step 2: Try MongoDB first (fast)
-        results = await search_mongodb(search_params, dto.limit)
-        used_fallback = False
+        # Step 3: Select optimal search strategy
+        strategy_result = await select_search_strategy(dto.query, search_params)
+        strategy = strategy_result.get("strategy", SearchStrategy.MONGO_ONLY)
         
-        # Step 3: If no results, try Qdrant (semantic fallback)
-        if not results:
-            logger.info("MongoDB found nothing, trying Qdrant fallback...")
-            results = await search_qdrant_fallback(dto.query, search_params, dto.limit)
-            used_fallback = True
+        logger.info(f"Strategy selected: {strategy} - {strategy_result.get('reasoning')}")
         
-        # Step 4: Format listings
+        # Step 4: Execute search based on strategy
+        results = []
+        
+        if strategy == SearchStrategy.MONGO_ONLY:
+            results = await search_mongodb(search_params, dto.limit)
+            
+            # Fallback for structured searches if NO results
+            if not results:
+                logger.info("MONGO_ONLY yielded no results, falling back to QDRANT_ONLY as safety net")
+                from app.ai.services.search_service import search_listings_hybrid
+                results, _ = await search_listings_hybrid(
+                    user_query=dto.query,
+                    search_params=search_params,
+                    limit=dto.limit,
+                    mode="relaxed"
+                )
+                strategy = "QDRANT_FALLBACK"
+        
+        elif strategy == SearchStrategy.QDRANT_ONLY:
+            results, _ = await search_listings_hybrid(
+                user_query=dto.query,
+                search_params=search_params,
+                limit=dto.limit,
+                mode="relaxed"
+            )
+        
+        elif strategy == SearchStrategy.MONGO_THEN_QDRANT:
+            results, _ = await search_mongo_then_qdrant(
+                user_query=dto.query,
+                search_params=search_params,
+                limit=dto.limit
+            )
+        
+        elif strategy == SearchStrategy.QDRANT_THEN_MONGO:
+            results, _ = await search_qdrant_then_mongo(
+                user_query=dto.query,
+                search_params=search_params,
+                limit=dto.limit
+            )
+        
+        # Step 5: Format listings
         formatted_listings = []
         for doc in results:
             if "_id" in doc and not isinstance(doc["_id"], str):
@@ -300,6 +205,7 @@ async def aida_search(
             # Clean up internal fields
             doc.pop("_relevance_score", None)
             doc.pop("_is_suggestion", None)
+            doc.pop("_search_strategy", None)
             doc.pop("location_lower", None)
             doc.pop("listing_type_lower", None)
             
@@ -310,21 +216,28 @@ async def aida_search(
                 logger.warning(f"Format warning: {e}")
                 formatted_listings.append(doc)
         
-        # Step 5: Generate response in user's language
-        message = await generate_message(dto.query, len(formatted_listings), search_params, used_fallback)
+        # Step 6: Generate natural response
+        message = await generate_natural_response(
+            user_query=dto.query,
+            count=len(formatted_listings),
+            params=search_params,
+            listings=formatted_listings,
+            strategy_used=strategy
+        )
         
-        logger.info(f"Search complete: {len(formatted_listings)} results (fallback: {used_fallback})")
+        logger.info(f"Search complete: {len(formatted_listings)} results via {strategy}")
         
         return SearchResponseDto(
             success=True,
             message=message,
             data=formatted_listings,
             total=len(formatted_listings),
-            search_params=search_params
+            search_params=search_params,
+            strategy_used=strategy
         )
     
     except Exception as e:
-        logger.error(f"Search error: {e}")
+        logger.error(f"Search error: {e}", exc_info=True)
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=f"Search failed: {str(e)}"

test_intelligent_search.py

@@ -0,0 +1,135 @@
+# test_intelligent_search.py
+"""
+Test suite for the intelligent AIDA search system.
+"""
+
+import asyncio
+import httpx
+import json
+
+# Base URL - adjust if needed
+BASE_URL = "http://localhost:8000"
+
+# You'll need a valid JWT token
+JWT_TOKEN = "YOUR_JWT_TOKEN_HERE"
+
+async def test_search(query: str, description: str):
+    """Test a single search query."""
+    print(f"\n{'='*70}")
+    print(f"TEST: {description}")
+    print(f"Query: {query}")
+    print(f"{'='*70}")
+    
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(
+                f"{BASE_URL}/api/search/",
+                json={"query": query, "limit": 5},
+                headers={"Authorization": f"Bearer {JWT_TOKEN}"},
+                timeout=30.0
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                print(f"✅ SUCCESS")
+                print(f"Message: {data.get('message')}")
+                print(f"Strategy Used: {data.get('strategy_used')}")
+                print(f"Results: {data.get('total')} properties")
+                
+                if data.get('search_params'):
+                    print(f"Extracted Params: {json.dumps(data['search_params'], indent=2)}")
+                
+                # Show first property if available
+                if data.get('data') and len(data['data']) > 0:
+                    prop = data['data'][0]
+                    print(f"\nFirst Property:")
+                    print(f"  - Title: {prop.get('title')}")
+                    print(f"  - Location: {prop.get('location')}")
+                    print(f"  - Price: {prop.get('price')} {prop.get('currency')}")
+                    print(f"  - Bedrooms: {prop.get('bedrooms')}")
+                    if prop.get('amenities'):
+                        print(f"  - Amenities: {', '.join(prop['amenities'][:5])}")
+            else:
+                print(f"❌ FAILED: Status {response.status_code}")
+                print(f"Response: {response.text}")
+        
+        except Exception as e:
+            print(f"❌ ERROR: {str(e)}")
+
+
+async def main():
+    """Run all search tests."""
+    
+    print("\n" + "="*70)
+    print("INTELLIGENT SEARCH SYSTEM - TEST SUITE")
+    print("="*70)
+    
+    # Test 1: Non-search input (greeting)
+    await test_search(
+        "hello",
+        "Non-search input: Greeting"
+    )
+    
+    # Test 2: Non-search input (thanks)
+    await test_search(
+        "thank you so much",
+        "Non-search input: Thank you"
+    )
+    
+    # Test 3: Structured query - should use MONGO_ONLY
+    await test_search(
+        "3 bedroom apartment in Cotonou under 200k",
+        "Structured query (expect: MONGO_ONLY strategy)"
+    )
+    
+    # Test 4: Semantic query - should use QDRANT_ONLY
+    await test_search(
+        "cozy modern apartment with good vibes",
+        "Semantic query (expect: QDRANT_ONLY strategy)"
+    )
+    
+    # Test 5: Hybrid query - should use MONGO_THEN_QDRANT
+    await test_search(
+        "house close to international school in Calavi",
+        "Hybrid query with location + context (expect: MONGO_THEN_QDRANT)"
+    )
+    
+    # Test 6: Amenity-focused query
+    await test_search(
+        "apartment with balcony and swimming pool in Cotonou",
+        "Amenity-focused query"
+    )
+    
+    # Test 7: French query
+    await test_search(
+        "maison avec piscine à Calavi",
+        "French query (expect: French response)"
+    )
+    
+    # Test 8: Query with typos
+    await test_search(
+        "apartmnt in cotonoo with parkng",
+        "Query with typos (expect: typo correction)"
+    )
+    
+    # Test 9: Price range query
+    await test_search(
+        "houses under 150k in Lagos",
+        "Price range query"
+    )
+    
+    # Test 10: Vague semantic query
+    await test_search(
+        "family-friendly neighborhood quiet area",
+        "Vague semantic query (expect: QDRANT_ONLY)"
+    )
+    
+    print("\n" + "="*70)
+    print("TEST SUITE COMPLETE")
+    print("="*70)
+    print("\nNOTE: Update JWT_TOKEN at the top of this file with a valid token")
+    print("Run this script with: python test_intelligent_search.py")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())