fyp

app/ai/agent/graph.py

@@ -20,6 +20,7 @@ from app.ai.agent.nodes.my_listings import my_listings_handler
 from app.ai.agent.nodes.edit_listing import edit_listing_handler
 from app.ai.agent.nodes.casual_chat import casual_chat_handler
 from app.ai.agent.nodes.validate_output import validate_output_node
+from app.ai.agent.nodes.notification import notification_handler
 from app.ai.agent.nodes.respond import respond_to_user
 
 logger = get_logger(__name__)
@@ -41,6 +42,7 @@ def route_by_intent(state: AgentState) -> str:
         "listing": "listing_collect",
         "publish": "listing_publish",
         "search": "search_query",
+        "set_notification": "notification",
         "my_listings": "my_listings",
         "edit_listing": "edit_listing",
         "casual_chat": "casual_chat",
@@ -180,6 +182,7 @@ def build_aida_graph():
     graph.add_node("search_query", search_query_handler)
     graph.add_node("my_listings", my_listings_handler)
     graph.add_node("edit_listing", edit_listing_handler)
+    graph.add_node("notification", notification_handler)
     graph.add_node("casual_chat", casual_chat_handler)
     graph.add_node("validate_output", validate_output_node)
     graph.add_node("respond", respond_to_user)
@@ -205,6 +208,7 @@ def build_aida_graph():
             "listing_collect": "listing_collect",
             "listing_publish": "listing_publish",
             "search_query": "search_query",
+            "notification": "notification",
             "my_listings": "my_listings",
             "edit_listing": "edit_listing",
             "casual_chat": "casual_chat",
@@ -241,6 +245,9 @@ def build_aida_graph():
     # Search → validate_output
     graph.add_edge("search_query", "validate_output")
     
+    # Notification → validate_output
+    graph.add_edge("notification", "validate_output")
+    
     # My Listings → validate_output
     graph.add_edge("my_listings", "validate_output")
     

app/ai/agent/nodes/classify_intent.py

@@ -38,12 +38,13 @@ Classify into ONE of these intents:
 4. "my_listings" - User wants to view THEIR OWN listings (show my listings, view my properties, my homes)
 5. "edit_listing" - User wants to EDIT an existing listing (edit listing [id], update my listing, modify listing)
 6. "publish" - User wants to publish the current listing
-7. "casual_chat" - Other conversation
-8. "unknown" - You don't understand
+7. "set_notification" - User wants to be notified/alerted about properties (notify me, set alert, keep me posted, waitlist)
+8. "casual_chat" - Other conversation
+9. "unknown" - You don't understand
 
 - "Return ONLY valid JSON (no markdown, no extra text):
 {{
-  "type": "greeting|listing|search|my_listings|edit_listing|publish|casual_chat|unknown",
+  "type": "greeting|listing|search|my_listings|edit_listing|publish|set_notification|casual_chat|unknown",
   "confidence": 0.0-1.0,
   "reasoning": "Why you chose this intent",
   "requires_auth": true/false,
@@ -261,6 +262,23 @@ async def classify_intent(state: AgentState) -> AgentState:
             logger.info("Staying in listing_collect for save/publish - letting save logic handle transition")
             return state
         
+        # ✅ SPECIAL: When in listing_collect and message contains image URL, stay in flow
+        # This prevents breaking the listing flow when user sends an image
+        if state.current_flow == FlowState.LISTING_COLLECT:
+            message_lower = state.last_user_message.lower() if state.last_user_message else ""
+            has_image_url = any(domain in message_lower for domain in [
+                "imagedelivery.net", "cloudflare", "imgur", "cloudinary",
+                ".jpg", ".jpeg", ".png", ".webp", ".gif",
+                "http://", "https://"
+            ])
+            
+            # If message has image URL OR intent is unknown/casual_chat, treat as listing update
+            if has_image_url or state.intent_type in ["unknown", "casual_chat"]:
+                logger.info("Staying in listing_collect - image URL or continuing listing flow", 
+                           has_image_url=has_image_url, original_intent=state.intent_type)
+                state.intent_type = "listing"  # Override to stay in listing flow
+                return state
+        
         # Transition with validation
         success, error = state.transition_to(next_flow, reason=f"Intent: {state.intent_type}")
         if not success:

app/ai/agent/nodes/edit_listing.py

@@ -104,6 +104,8 @@ async def edit_listing_handler(state: AgentState) -> AgentState:
 
         # Convert to draft format for editing
         draft = {
+            "user_id": state.user_id,  # Required for validation
+            "user_role": state.user_role,  # Required for validation
             "title": listing.get("title", ""),
             "description": listing.get("description", ""),
             "location": listing.get("location", ""),

app/ai/agent/nodes/listing_collect.py

@@ -170,12 +170,24 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
         from app.ai.tools.listing_conversation_manager import generate_smart_listing_response
         from app.ai.tools.listing_tool import extract_listing_fields_smart
         
-        # Generate dynamic example
-        listing_example = await generate_listing_example(
-            user_role=state.user_role,
-            user_name=state.user_name,
-            user_location=state.user_location
+        # ✅ SMART TUTORIAL SKIP: Only show example if user provided NO details
+        # If user said "I want to list my 3-bed in Lagos for 500k/month", skip the tutorial
+        # First, do a quick extraction to see if they provided details
+        quick_extraction = await extract_listing_fields_smart(
+            state.last_user_message,
+            state.user_role,
+            state.provided_fields
         )
+        has_details_in_message = len(quick_extraction) > 0
+        
+        # Only generate example if no details provided AND no existing fields
+        listing_example = None
+        if not has_details_in_message and not state.provided_fields:
+            listing_example = await generate_listing_example(
+                user_role=state.user_role,
+                user_name=state.user_name,
+                user_location=state.user_location
+            )
         
         # ✅ STEP 1: Generate intelligent response using LLM
         # This analyzes the message, detects intent, and creates contextual reply
@@ -186,7 +198,9 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
             provided_fields=state.provided_fields,
             missing_required_fields=state.missing_required_fields or [],
             last_action=state.temp_data.get("action"),
-            listing_example=listing_example, # Pass the generated example
+            listing_example=listing_example, # Only passed if truly fresh start
+            needs_address_refinement=state.temp_data.get("needs_address_refinement", False),
+            vague_location=state.temp_data.get("vague_location"),
         )
         
         logger.info("Smart response received",
@@ -204,6 +218,27 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
             state.temp_data["new_intent"] = detected_intent
             return state
         
+        # ✅ STEP 2.5: Extract image URLs directly from message (don't rely on LLM)
+        # This ensures image URLs are captured even if LLM misses them
+        # Supports: multiple images, text alongside images (text will be processed separately by LLM)
+        import re
+        image_url_pattern = r'https?://[^\s<>"{}|\\^`\[\]]+\.(?:jpg|jpeg|png|gif|webp)|https?://imagedelivery\.net/[^\s<>"{}|\\^`\[\]]+'
+        found_image_urls = re.findall(image_url_pattern, state.last_user_message or "", re.IGNORECASE)
+        
+        if found_image_urls:
+            logger.info("📸 Image URLs extracted directly from message", 
+                       count=len(found_image_urls), 
+                       urls=found_image_urls[:3])  # Log first 3 to avoid spam
+            # Add to existing images (handles multiple images in one message)
+            current_images = state.provided_fields.get("images", [])
+            new_images = list(set(current_images + found_image_urls))  # Avoid duplicates
+            state.update_listing_progress("images", new_images)
+            logger.info("✅ Images updated", new_count=len(found_image_urls), total=len(new_images))
+        
+        # NOTE: Any text alongside the images will still be processed below by the LLM
+        # Example: "Here are pics https://img1.jpg https://img2.jpg, it has wifi and pool"
+        # → Images extracted above, "it has wifi and pool" processed below for amenities
+        
         # ✅ STEP 3: Extract fields (LLM does this smartly)
         extracted = await extract_listing_fields_smart(
             state.last_user_message,
@@ -214,21 +249,42 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
         if extracted:
             # Get operation modes for list fields (default to "add" for backward compat)
             images_operation = extracted.pop("images_operation", "add")
+            image_index = extracted.pop("image_index", None)  # NEW: Get target image index
             amenities_operation = extracted.pop("amenities_operation", "add")
             
             for field, value in extracted.items():
                 # Fix: Handle 0 as a valid value for price/bedrooms
                 if value is not None and value != "" and (value != [] or field in ["images", "amenities"]):
                     
-                    # Special handling for images: add or replace
-                    if field == "images" and isinstance(value, list) and value:
+                    # Special handling for images: add, replace, replace_at, remove_at
+                    if field == "images":
+                        current_imgs = state.provided_fields.get("images", [])
+                        
                         if images_operation == "replace":
                             # Replace all images
-                            state.update_listing_progress(field, value)
-                            logger.info("Images REPLACED", count=len(value))
-                        else:
+                            state.update_listing_progress(field, value if isinstance(value, list) else [])
+                            logger.info("Images REPLACED", count=len(value) if isinstance(value, list) else 0)
+                            
+                        elif images_operation == "replace_at" and image_index is not None:
+                            # Replace image at specific index (1-indexed)
+                            if isinstance(value, list) and value and 1 <= image_index <= len(current_imgs):
+                                current_imgs[image_index - 1] = value[0]  # Replace with first new URL
+                                state.update_listing_progress(field, current_imgs)
+                                logger.info(f"Image REPLACED at index {image_index}")
+                            else:
+                                logger.warning(f"Invalid replace_at: index={image_index}, images_count={len(current_imgs)}")
+                        
+                        elif images_operation == "remove_at" and image_index is not None:
+                            # Remove image at specific index (1-indexed)
+                            if 1 <= image_index <= len(current_imgs):
+                                removed = current_imgs.pop(image_index - 1)
+                                state.update_listing_progress(field, current_imgs)
+                                logger.info(f"Image REMOVED at index {image_index}: {removed}")
+                            else:
+                                logger.warning(f"Invalid remove_at: index={image_index}, images_count={len(current_imgs)}")
+                        
+                        elif isinstance(value, list) and value:
                             # Add to existing images (default)
-                            current_imgs = state.provided_fields.get("images", [])
                             new_imgs = list(set(current_imgs + value))  # Avoid duplicates
                             state.update_listing_progress(field, new_imgs)
                             logger.info("Images ADDED", added=len(value), total=len(new_imgs))
@@ -270,6 +326,84 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
                                 state.listing_draft["currency"] = currency
                             state.update_listing_progress("currency", currency)
         
+        # ✅ ADDRESS REFINEMENT & GEOCODING
+        # Handle address extraction and geocoding for precise map display
+        from app.ai.tools.listing_tool import is_vague_location, geocode_address
+        
+        # Check if we extracted an address in this message
+        extracted_address = extracted.get("address") if extracted else None
+        current_location = state.provided_fields.get("location")
+        current_address = state.provided_fields.get("address")
+        
+        # Scenario 1: User provided address → geocode and extract city
+        if extracted_address and extracted_address != current_address:
+            # Build full address for geocoding
+            search_address = extracted_address
+            if current_location:
+                search_address = f"{extracted_address}, {current_location}"
+            
+            geo_result = await geocode_address(search_address, current_location)
+            
+            if geo_result.get("success"):
+                # Store the full address with city appended
+                full_address = f"{extracted_address}, {geo_result.get('city', current_location)}"
+                state.update_listing_progress("address", full_address)
+                state.update_listing_progress("latitude", geo_result.get("latitude"))
+                state.update_listing_progress("longitude", geo_result.get("longitude"))
+                
+                # If we didn't have a location, extract city from geocoding result
+                if not current_location and geo_result.get("city"):
+                    state.update_listing_progress("location", geo_result.get("city"))
+                    # Also update currency for the new location
+                    try:
+                        from app.ai.tools.listing_tool import get_currency_for_location
+                        currency = await get_currency_for_location(geo_result.get("city"))
+                        state.update_listing_progress("currency", currency)
+                    except Exception:
+                        pass
+                
+                logger.info("Address geocoded successfully", 
+                           address=full_address, 
+                           lat=geo_result.get("latitude"), 
+                           lon=geo_result.get("longitude"))
+            else:
+                # Geocoding failed, still store the address
+                if current_location:
+                    full_address = f"{extracted_address}, {current_location}"
+                else:
+                    full_address = extracted_address
+                state.update_listing_progress("address", full_address)
+                logger.warning("Geocoding failed, storing address without coordinates", address=full_address)
+            
+            # Clear address refinement flags since we now have an address
+            state.temp_data.pop("needs_address_refinement", None)
+            state.temp_data.pop("vague_location", None)
+        
+        # Scenario 2: No address but we have a location - geocode the location for city-level coordinates
+        # This gives us temporary coords, but we still ask for the neighborhood for more accuracy
+        if current_location and not current_address and not state.provided_fields.get("latitude"):
+            # Geocode the location to get at least city-level coordinates (temporary)
+            geo_result = await geocode_address(current_location, None)
+            
+            if geo_result.get("success"):
+                # Store city-level coords temporarily (will be overwritten when we get neighborhood)
+                state.update_listing_progress("latitude", geo_result.get("latitude"))
+                state.update_listing_progress("longitude", geo_result.get("longitude"))
+                # DON'T store city as address - we want the actual neighborhood
+                logger.info("City-level geocoding done (temporary coords)", 
+                           location=current_location, 
+                           lat=geo_result.get("latitude"), 
+                           lon=geo_result.get("longitude"))
+            else:
+                logger.warning("Location geocoding failed", location=current_location)
+            
+            # Check if location is vague (just city name) and we need to ask for neighborhood
+            if is_vague_location(current_location):
+                state.temp_data["needs_address_refinement"] = True
+                state.temp_data["vague_location"] = current_location
+                logger.info("City only detected, will ask for neighborhood", location=current_location)
+
+
         # ✅ SYNC: Update listing_draft with all provided_fields when in edit mode
         is_editing_flag = state.temp_data.get("is_editing")
         editing_id = state.temp_data.get("editing_listing_id")
@@ -299,14 +433,49 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
                 state.provided_fields["listing_type"] = "sale"
                 logger.info("Auto-inferred listing_type to sale from one-time price_type")
             
-            # ✅ REGENERATE title and description with updated fields
-            from app.ai.tools.listing_tool import generate_title_and_description
-            title, description = await generate_title_and_description(state.listing_draft, state.user_role)
-            state.listing_draft["title"] = title
-            state.listing_draft["description"] = description
-            state.provided_fields["title"] = title
-            state.provided_fields["description"] = description
-            logger.info("Title/description regenerated", title=title)
+            # ✅ AUTO-DETECT CURRENCY: Ensure currency matches location (important for auto-save)
+            location = state.listing_draft.get("location")
+            if location:
+                try:
+                    from app.ai.tools.listing_tool import get_currency_for_location
+                    detected_currency = await get_currency_for_location(location)
+                    if detected_currency and detected_currency != state.listing_draft.get("currency"):
+                        state.listing_draft["currency"] = detected_currency
+                        state.provided_fields["currency"] = detected_currency
+                        logger.info("💰 Currency auto-detected for edit mode", location=location, currency=detected_currency)
+                except Exception as e:
+                    logger.warning(f"Currency detection failed for {location}: {e}")
+            
+            # ✅ CHECK FOR DESCRIPTION REGENERATION REQUEST
+            from app.ai.tools.listing_tool import is_description_regeneration_request, regenerate_description_with_prompt
+            
+            if state.last_user_message and is_description_regeneration_request(state.last_user_message):
+                # User wants to regenerate description with their specific prompt
+                logger.info("✍️ Description regeneration requested", user_prompt=state.last_user_message[:50])
+                new_description = await regenerate_description_with_prompt(
+                    state.listing_draft, 
+                    state.last_user_message, 
+                    state.user_role
+                )
+                state.listing_draft["description"] = new_description
+                state.provided_fields["description"] = new_description
+                logger.info("✅ Description regenerated per user request", desc_len=len(new_description))
+                
+                # Still regenerate title (keep it SEO-friendly)
+                from app.ai.tools.listing_tool import generate_title_and_description
+                title, _ = await generate_title_and_description(state.listing_draft, state.user_role)
+                state.listing_draft["title"] = title
+                state.provided_fields["title"] = title
+            else:
+                # Standard regeneration
+                from app.ai.tools.listing_tool import generate_title_and_description
+                title, description = await generate_title_and_description(state.listing_draft, state.user_role)
+                state.listing_draft["title"] = title
+                state.listing_draft["description"] = description
+                state.provided_fields["title"] = title
+                state.provided_fields["description"] = description
+            
+            logger.info("Title/description updated", title=state.listing_draft.get("title"))
             
             # ✅ Regenerate draft_ui so frontend gets updated card
             from app.ai.agent.nodes.listing_validate import build_draft_ui_from_dict
@@ -314,11 +483,67 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
             draft_ui["status"] = "editing"
             state.temp_data["draft_ui"] = draft_ui
             logger.info("Draft UI regenerated for edit mode", ui_location=draft_ui.get("details", {}).get("location"))
+            
+            # ✅ AUTO-SAVE: Save changes to database immediately
+            # Always attempt auto-save in edit mode (draft is already synced above)
+            logger.info("🔄 Attempting auto-save", editing_id=editing_id, has_extracted=bool(extracted))
+            try:
+                from app.database import get_db
+                from bson import ObjectId
+                from datetime import datetime
+                
+                # Validate the listing before saving
+                from app.ai.agent.validators import ListingValidator
+                validation = ListingValidator.validate_draft(state.listing_draft)
+                
+                if validation.is_valid:
+                    # Prepare update document
+                    update_doc = {
+                        "title": state.listing_draft.get("title"),
+                        "description": state.listing_draft.get("description"),
+                        "location": state.listing_draft.get("location"),
+                        "address": state.listing_draft.get("address"),  # Precise address
+                        "latitude": state.listing_draft.get("latitude"),  # Geocoded lat
+                        "longitude": state.listing_draft.get("longitude"),  # Geocoded lon
+                        "price": state.listing_draft.get("price"),
+                        "currency": state.listing_draft.get("currency"),
+                        "price_type": state.listing_draft.get("price_type"),
+                        "bedrooms": state.listing_draft.get("bedrooms"),
+                        "bathrooms": state.listing_draft.get("bathrooms"),
+                        "amenities": state.listing_draft.get("amenities", []),
+                        "images": state.listing_draft.get("images", []),
+                        "listing_type": state.listing_draft.get("listing_type"),
+                        "updated_at": datetime.utcnow(),
+                    }
+                    
+                    logger.info("💾 Saving to database", listing_id=editing_id, location=update_doc.get("location"))
+                    
+                    # Save to database
+                    db = await get_db()
+                    result = await db.listings.update_one(
+                        {"_id": ObjectId(editing_id)},
+                        {"$set": update_doc}
+                    )
+                    
+                    if result.matched_count > 0:
+                        logger.info("✅ AUTO-SAVED listing to database", listing_id=editing_id, modified_count=result.modified_count)
+                        # Add subtle save indicator to temp_data
+                        state.temp_data["auto_saved"] = True
+                    else:
+                        logger.warning("⚠️ Auto-save: Listing not found in database", listing_id=editing_id)
+                else:
+                    logger.warning("⚠️ Skipping auto-save: validation failed", errors=validation.errors)
+                    
+            except Exception as e:
+                logger.error("❌ Auto-save failed", exc_info=e, listing_id=editing_id)
+                # Don't fail the entire flow - just log the error
+                # User can still manually save later
+
         
         logger.info("Current provided fields after update", fields=state.provided_fields)
         
         # ✅ STEP 4: Check completion status
-        required_fields = ["location", "bedrooms", "bathrooms", "price", "price_type", "images"]
+        required_fields = ["location", "address", "bedrooms", "bathrooms", "price", "price_type", "images"]
         
         # Fix: Check for None OR empty values (empty list/string)
         missing_required = []
@@ -407,13 +632,15 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
 
 Changes made: {changes_text}
 New listing title: "{new_title}"
+Auto-saved: {state.temp_data.get("auto_saved", False)}
 
 The message should:
 - Confirm the updates naturally (1-2 sentences)
+- If auto-saved is True, add a subtle "✓ Saved" indicator at the start
 - Mention the new title
-- End by asking if they want to change anything else OR say 'save' when done
+- End by asking if they want to change anything else
 
-Example tone: "Done! Updated your location and price. Your listing is now '...'. What else, or say 'save' when ready!"
+Example tone: "Done! ✓ Saved. Updated your location and price. Your listing is now '...'. What else?"
 
 Just return the message, no quotes."""
 
@@ -422,7 +649,8 @@ Just return the message, no quotes."""
                             acknowledgment = response.content.strip().strip('"')
                         except Exception:
                             # Fallback
-                            acknowledgment = f"Done! ✅ Updated {changes_text}.\n\nYour listing: **\"{new_title}\"**\n\nWhat else? Or say **'save'** when ready!"
+                            save_indicator = "✓ Saved. " if state.temp_data.get("auto_saved") else ""
+                            acknowledgment = f"Done! {save_indicator}Updated {changes_text}.\n\nYour listing: **\"{new_title}\"**\n\nWhat else would you like to change?"
                         
                         state.temp_data["response_text"] = acknowledgment
                         state.temp_data["action"] = "edit_field_updated"

app/ai/agent/nodes/listing_publish.py

@@ -10,6 +10,7 @@ from datetime import datetime
 from app.ai.agent.state import AgentState, FlowState
 from app.ai.agent.schemas import ListingDraft
 from app.database import get_db
+from app.ai.services.vector_service import upsert_listing_to_vector_db
 
 logger = get_logger(__name__)
 
@@ -78,6 +79,9 @@ async def listing_publish_handler(state: AgentState) -> AgentState:
             "title": draft.title,
             "description": draft.description,
             "location": draft.location,
+            "address": draft.address,  # Precise address for display
+            "latitude": draft.latitude,  # Geocoded latitude for map
+            "longitude": draft.longitude,  # Geocoded longitude for map
             "bedrooms": draft.bedrooms,
             "bathrooms": draft.bathrooms,
             "price": draft.price,
@@ -152,6 +156,17 @@ async def listing_publish_handler(state: AgentState) -> AgentState:
                 except Exception as user_update_err:
                     logger.warning("Failed to increment totalListings", error=str(user_update_err))
             
+            # ✅ STEP 3.1: Sync to Qdrant for real-time smart search
+            listing_document["_id"] = listing_id
+            await upsert_listing_to_vector_db(listing_document)
+            
+            # ✅ STEP 3.2: Check for waitlist matches and notify users
+            try:
+                from app.ai.services.notification_service import check_matches_for_new_listing
+                await check_matches_for_new_listing(listing_document)
+            except Exception as notify_err:
+                logger.warning("Proactive notification check failed", error=str(notify_err))
+            
         except Exception as e:
             logger.error("MongoDB save failed", exc_info=e)
             error_msg = f"Failed to save listing: {str(e)}"
@@ -193,16 +208,37 @@ async def listing_publish_handler(state: AgentState) -> AgentState:
         user_name = state.user_name or "there"
         is_update = bool(state.temp_data.get("editing_listing_id"))
         
+        # Detect language from conversation history
+        user_messages = ""
+        if state.conversation_history:
+            user_msgs = [msg.get("content", "") for msg in state.conversation_history if msg.get("role") == "user"]
+            user_messages = " ".join(user_msgs[:2])  # First 2 messages
+        
         if is_update:
             prompt = f"""Generate a SHORT, excited message for {user_name} that their listing "{draft.title}" has been successfully UPDATED!
-Write in this exact style:
-"Great news {user_name}! ✨ Your '{draft.title}' listing has been UPDATED successfully! The changes are now live. What else would you like to do?"
+
+CRITICAL LANGUAGE RULE:
+User's messages: "{user_messages[:200]}"
+Detect the language and write your ENTIRE message in that SAME language (French, English, Spanish, etc.).
+
+Examples:
+English: "Great news {user_name}! ✨ Your '{draft.title}' listing has been UPDATED successfully! The changes are now live. What else would you like to do?"
+French: "Super nouvelle {user_name}! ✨ Ton annonce '{draft.title}' a été MISE À JOUR avec succès! Les changements sont maintenant en ligne. Que veux-tu faire d'autre?"
+
 Be super excited and clear. 2 sentences max."""
             fallback_msg = f"Great news {user_name}! ✨ Your '{draft.title}' listing has been UPDATED successfully! What else would you like to do?"
         else:
             prompt = f"""Generate a SHORT, excited message for {user_name} that their listing "{draft.title}" in {draft.location} is NOW LIVE!
-Write in this exact style:
-"Wow {user_name}! 🎉🏠 Your '{draft.title}' listing is now LIVE on Lojiz! Anyone searching can now find it. What else can I help you with?"
+
+CRITICAL LANGUAGE RULE:
+User's messages: "{user_messages[:200]}"
+Detect the language and write your ENTIRE message in that SAME language (French, English, Spanish, etc.).
+
+Examples:
+English: "Wow {user_name}! 🎉🏠 Your '{draft.title}' listing is now LIVE on Lojiz! Anyone searching can now find it. What else can I help you with?"
+French: "Wow {user_name}! 🎉🏠 Ton annonce '{draft.title}' est maintenant EN LIGNE sur Lojiz! Tout le monde peut la trouver maintenant. Que puis-je faire d'autre pour toi?"
+Spanish: "¡Wow {user_name}! 🎉🏠 ¡Tu anuncio '{draft.title}' está ahora EN VIVO en Lojiz! Cualquiera puede encontrarlo ahora. ¿En qué más puedo ayudarte?"
+
 Be super excited and celebratory. Use emojis. 2 sentences max."""
             fallback_msg = f"Wow {user_name}! 🎉🏠 Your '{draft.title}' listing is now LIVE on Lojiz! What else can I help you with?"
 

app/ai/agent/nodes/listing_validate.py

@@ -59,6 +59,7 @@ def build_draft_ui(draft: ListingDraft) -> dict:
         "description": draft.description,
         "details": {
             "location": draft.location,
+            "address": draft.address,  # Precise address for display
             "bedrooms": draft.bedrooms,
             "bathrooms": draft.bathrooms,
             "price": f"{draft.price} {draft.currency}",
@@ -69,6 +70,10 @@ def build_draft_ui(draft: ListingDraft) -> dict:
         "requirements": draft.requirements or "No special requirements",
         "images_count": len(draft.images),
         "images": draft.images[:5],  # Show first 5
+        "coordinates": {
+            "latitude": draft.latitude,
+            "longitude": draft.longitude,
+        } if draft.latitude else None,
         "status": "ready_for_review",
         "actions": ["publish", "edit", "discard"],
     }
@@ -76,6 +81,7 @@ def build_draft_ui(draft: ListingDraft) -> dict:
     return ui_component
 
 
+
 def build_draft_ui_from_dict(draft_dict: dict) -> dict:
     """
     Build UI preview component from a draft dictionary.
@@ -120,6 +126,7 @@ def build_draft_ui_from_dict(draft_dict: dict) -> dict:
         "description": draft_dict.get("description", ""),
         "details": {
             "location": draft_dict.get("location", "Unknown"),
+            "address": draft_dict.get("address"),  # Precise address for display
             "bedrooms": draft_dict.get("bedrooms", 0),
             "bathrooms": draft_dict.get("bathrooms", 0),
             "price": f"{draft_dict.get('price', 0)} {draft_dict.get('currency', 'NGN')}",
@@ -130,6 +137,10 @@ def build_draft_ui_from_dict(draft_dict: dict) -> dict:
         "requirements": draft_dict.get("requirements") or "No special requirements",
         "images_count": len(images),
         "images": images[:5],  # Show first 5
+        "coordinates": {
+            "latitude": draft_dict.get("latitude"),
+            "longitude": draft_dict.get("longitude"),
+        } if draft_dict.get("latitude") else None,
         "status": "ready_for_review",
         "actions": ["publish", "edit", "discard"],
     }
@@ -220,7 +231,13 @@ async def listing_validate_handler(state: AgentState) -> AgentState:
             "amenities": amenities,
         }
         
-        title, description = await generate_title_and_description(draft_data, state.user_role)
+        # Pass conversation history so LLM can detect language from user's actual words
+        title, description = await generate_title_and_description(
+            draft_data, 
+            state.user_role,
+            user_language=None,
+            conversation_history=state.conversation_history
+        )
         
         logger.info("Title and description generated", title=title)
         
@@ -228,12 +245,20 @@ async def listing_validate_handler(state: AgentState) -> AgentState:
         # STEP 5: Build ListingDraft
         # ============================================================
         
+        # Get address and coordinates from provided fields
+        address = state.provided_fields.get("address")
+        latitude = state.provided_fields.get("latitude")
+        longitude = state.provided_fields.get("longitude")
+        
         draft_dict = {
             "user_id": state.user_id,
             "user_role": state.user_role,
             "title": title,
             "description": description,
             "location": location,
+            "address": address,
+            "latitude": latitude,
+            "longitude": longitude,
             "bedrooms": int(bedrooms),
             "bathrooms": int(bathrooms),
             "price": float(price),
@@ -290,21 +315,38 @@ async def listing_validate_handler(state: AgentState) -> AgentState:
         
         user_name = state.user_name or "there"
         
+        # Detect language from conversation history
+        user_messages = ""
+        if state.conversation_history:
+            user_msgs = [msg.get("content", "") for msg in state.conversation_history if msg.get("role") == "user"]
+            user_messages = " ".join(user_msgs[:2])  # First 2 messages
+        
         if is_update:
             state.temp_data["replace_last_message"] = True
             prompt = f"""Write a casual 1-2 sentence message for {user_name} confirming their listing "{draft.title}" was updated.
+
+CRITICAL: The user speaks in this language: "{user_messages[:200]}"
+Detect the language and write your message in THE SAME LANGUAGE (French, English, Spanish, etc.).
+
 Flow naturally into mentioning they can say "publish" or keep editing.
-Example: "All done, {user_name}! ✨ Your listing's looking great. Just say 'publish' when you're ready, or keep making changes!"
+Example (English): "All done, {user_name}! ✨ Your listing's looking great. Just say 'publish' when you're ready, or keep making changes!"
+Example (French): "C'est fait, {user_name}! ✨ Ton annonce est superbe. Dis 'publier' quand tu es prêt, ou continue à modifier!"
 Be creative and vary your wording each time."""
         else:
             prompt = f"""Write a casual, friendly message for {user_name} presenting their listing "{draft.title}" in {draft.location}.
+
+CRITICAL LANGUAGE RULE:
+User's messages: "{user_messages[:200]}"
+Detect the language from above and write your ENTIRE message in that SAME language (French, English, Spanish, etc.).
+
 Write like you're texting a friend - flow naturally from one sentence to the next.
 Include ALL THREE actions in NATURAL sentences (not bullet points):
-- publishing ("say 'publish' and I'll handle it")
-- editing ("tell me what to change")  
-- discarding ("say 'discard' if you've changed your mind")
+- publishing ("say 'publish' and I'll handle it" / "dis 'publier' et je m'en occupe")
+- editing ("tell me what to change" / "dis-moi ce que tu veux changer")  
+- discarding ("say 'discard' if you've changed your mind" / "dis 'annuler' si tu as changé d'avis")
 
-Example: "Alright {user_name}! 🏠 Here's your listing preview! To publish it, just say 'publish' and I'll handle the rest. Want to change something? Just tell me what to edit. Or say 'discard' if you've changed your mind."
+Example (English): "Alright {user_name}! 🏠 Here's your listing preview! To publish it, just say 'publish' and I'll handle the rest. Want to change something? Just tell me what to edit. Or say 'discard' if you've changed your mind."
+Example (French): "Ça y est {user_name}! 🏠 Voici l'aperçu de ton annonce! Pour la publier, dis simplement 'publier' et je m'en occupe. Tu veux modifier quelque chose? Dis-moi ce que tu veux changer. Ou dis 'annuler' si tu as changé d'avis."
 
 Be creative and vary your wording. Use emojis. 2-3 natural flowing sentences."""
 

app/ai/agent/nodes/notification.py

@@ -0,0 +1,60 @@
+# app/ai/agent/nodes/notification.py
+"""
+Node: Handle notification/waitlist registration.
+"""
+
+from structlog import get_logger
+from app.ai.agent.state import AgentState, FlowState
+from app.ai.services.notification_service import create_waitlist_request
+from app.ai.agent.nodes.search_query import extract_search_params
+
+logger = get_logger(__name__)
+
+async def notification_handler(state: AgentState) -> AgentState:
+    """
+    Register a user for proactive notifications based on their last search.
+    """
+    logger.info("Handling notification request", user_id=state.user_id)
+    
+    try:
+        # 1. Identify what they want to be notified about
+        # We use the conservation history to find their last search intent
+        # Or re-extract from the current message if it contains details
+        
+        search_params = await extract_search_params(state.last_user_message)
+        
+        # Fallback: if they just said "notify me", look at state.temp_data for previous params
+        if not search_params or all(v is None for v in search_params.values()):
+            # Logic to find last search in history could be more complex, 
+            # for now we check if they just finished a search in this session
+            search_params = state.search_results[0] if state.search_results else {}
+            # This is a simplification; in a real app, we'd store search_params in state explicitly
+        
+        if not search_params:
+            state.temp_data["response_text"] = "What exactly should I notify you about? (e.g., 'Notify me when you find a 2-bed in Calavi')"
+            state.transition_to(FlowState.IDLE)
+            return state
+
+        # 2. Store the request
+        waitlist_id = await create_waitlist_request(
+            user_id=state.user_id,
+            search_params=search_params,
+            original_query=state.last_user_message
+        )
+        
+        if waitlist_id:
+            state.temp_data["response_text"] = (
+                "Done! ✅ I've added you to my waitlist. "
+                "The moment I find a property matching your criteria, I'll reach out to you immediately! 🔔"
+            )
+            state.temp_data["action"] = "notification_set"
+        else:
+            state.temp_data["response_text"] = "I had a little trouble setting that up. Could you try again in a moment?"
+            
+        state.transition_to(FlowState.IDLE)
+        return state
+        
+    except Exception as e:
+        logger.error("Notification handling error", exc_info=e)
+        state.set_error(str(e))
+        return state

app/ai/agent/nodes/search_query.py

@@ -180,32 +180,39 @@ 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 (like "show me houses"), respond in ENGLISH
-- If the query is in FRENCH (like "montre moi des maisons"), respond in FRENCH
-- IGNORE the location name when determining language (Cotonou is just a place, not a language indicator)
-- The query "{user_query}" is in ENGLISH if it contains words like "show", "me", "house", "find", "looking"
+- 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:
-Write a friendly, personalized response presenting these search results. Rules:
-1. RESPOND IN THE SAME LANGUAGE AS THE QUERY TEXT (not the location!)
-2. Start with a warm greeting using the user's name if provided
-3. Give a brief 1-2 sentence summary about EACH property (title, location, price, key features)
-4. End by mentioning they can view the cards below for details and ask for more info
-5. Keep it concise but friendly and helpful
-6. Use emojis appropriately (🏠 💰 etc.)
+YOUR TASK - KEEP IT SHORT:
 
-If no properties found, give helpful suggestions.
+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.
 
-Write ONLY the response text, no JSON or formatting instructions."""
+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(
@@ -213,24 +220,14 @@ async def generate_search_results_text(
     search_params: dict, 
     user_query: str,
     user_name: str = None,
-    inferred_currency: str = None
+    inferred_currency: str = None,
+    search_mode: str = "strict"
 ) -> str:
     """
     Use LLM to generate personalized, multilingual search results text.
-    
-    Args:
-        listings: List of matching listings
-        search_params: Original search parameters
-        user_query: Original user query (determines language)
-        user_name: User's name for personalization
-        inferred_currency: Currency for the location
-    
-    Returns:
-        LLM-generated response text in user's language
     """
     
     count = len(listings)
-    location = search_params.get("location", "")
     
     # Build listings summary for LLM
     if listings:
@@ -242,21 +239,20 @@ async def generate_search_results_text(
             currency = listing.get("currency", inferred_currency or "XOF")
             price_type = listing.get("price_type", "monthly")
             bedrooms = listing.get("bedrooms", "?")
-            bathrooms = listing.get("bathrooms", "?")
-            amenities = listing.get("amenities", [])
             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}, Bathrooms: {bathrooms}
-- Amenities: {', '.join(amenities[:4]) if amenities else 'Not specified'}
+- Bedrooms: {bedrooms}
 - Description: {description}...
+- Match Score: {relevance:.2f}
 """
     else:
-        listings_summary = f"No properties found matching criteria in {location or 'the specified area'}."
+        listings_summary = "No properties found."
     
     # Format prompt
     prompt = SEARCH_RESULTS_PROMPT.format(
@@ -264,175 +260,108 @@ Property {i}:
         user_query=user_query,
         count=count,
         listings_summary=listings_summary,
-        currency=inferred_currency or "local currency"
+        currency=inferred_currency or "local currency",
+        search_mode=search_mode
     )
     
     try:
         messages = [
-            SystemMessage(content="You are AIDA, a friendly and helpful real estate AI assistant."),
+            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)
         ]
         
         response = await llm.ainvoke(messages)
-        result_text = response.content.strip()
-        
-        logger.info("LLM generated search results text", text_len=len(result_text))
-        return result_text
+        return response.content.strip()
         
     except Exception as e:
-        logger.error("LLM search text generation failed, using fallback", error=str(e))
-        # Fallback to simple format
-        return _fallback_format_results(listings, search_params, inferred_currency)
-
-
-def _fallback_format_results(listings: list, search_params: dict, inferred_currency: str = None) -> str:
-    """Simple fallback if LLM fails."""
-    if not listings:
-        return f"😕 No listings found matching your criteria. Try adjusting your search."
-    
-    location = search_params.get("location", "")
-    count = len(listings)
-    
-    text = f"🏠 Found {count} properties"
-    if location:
-        text += f" in {location}"
-    text += "!\n\n"
-    
-    for listing in listings:
-        title = listing.get("title", "Property")
-        price = listing.get("price", 0)
-        currency = listing.get("currency", inferred_currency or "")
-        text += f"• **{title}** - {currency} {price:,.0f}\n"
-    
-    text += "\nCheck the cards below for details!"
-    return text
+        logger.error("LLM search text generation failed", error=str(e))
+        return f"I found {count} properties that might interest you! Take a look below."
 
 
 async def search_query_handler(state: AgentState) -> AgentState:
     """
-    Handle search flow with HYBRID SEARCH.
-    
-    Flow:
-    1. Extract search criteria from message (LLM)
-    2. Infer currency from location
-    3. Perform hybrid search (Qdrant vector + filters)
-    4. Format and display results
-    5. Transition to IDLE
-    
-    Args:
-        state: Agent state
-    
-    Returns:
-        Updated state
+    Handle search flow with Two-Step Hybrid Search (Strict -> Relaxed).
     """
     
-    logger.info(
-        "Handling search query (HYBRID MODE)",
-        user_id=state.user_id,
-        message=state.last_user_message[:50]
-    )
+    logger.info("Handling search query", user_id=state.user_id)
     
     try:
-        # ============================================================
-        # STEP 1: Extract search parameters with enhanced LLM
-        # ============================================================
-        
+        # STEP 1: Extract search parameters
         search_params = await extract_search_params(state.last_user_message)
         
         if not search_params:
-            logger.warning("No search parameters extracted")
-            state.temp_data["response_text"] = (
-                "I couldn't understand your search. Try asking:\n"
-                "- \"I want a house in Calavi for 50k per month with wifi\"\n"
-                "- \"2-bedroom apartments in Lagos under 500k\"\n" 
-                "- \"Short-stay rentals with balcony and parking\""
-            )
+            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
         
-        logger.info("Search parameters extracted", params=search_params)
-        
-        # ============================================================
-        # STEP 2: Hybrid Search (Qdrant Vector + Filters)
-        # ============================================================
+        # Helper: Check if query has location
+        def has_location_filter(params: dict) -> bool:
+            return bool(params.get("location"))
         
-        results, inferred_currency = await search_listings_hybrid(
-            user_query=state.last_user_message,
-            search_params=search_params,
-            limit=10
-        )
-        
-        logger.info(
-            "Hybrid search completed",
-            results_count=len(results),
-            currency=inferred_currency
-        )
-        
-        # ============================================================
-        # STEP 3: Fallback to MongoDB if Qdrant returns no results
-        # ============================================================
-        
-        if not results:
-            logger.info("Qdrant returned no results, trying MongoDB fallback")
+        # 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)
-            logger.info("MongoDB fallback results", count=len(results))
-        
-        # ============================================================
-        # STEP 4: Generate LLM-based personalized response text
-        # ============================================================
-        
+            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
+            if not results:
+                logger.info("No exact matches found, trying Qdrant for suggestions...")
+                results, _ = await search_listings_hybrid(
+                    user_query=state.last_user_message,
+                    search_params=search_params,
+                    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,
+                search_params=search_params,
+                mode="strict"
+            )
+            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
+            inferred_currency=inferred_currency,
+            search_mode=search_mode
         )
         
-        logger.info("LLM results formatted", length=len(formatted_results))
-        
-        # ============================================================
-        # STEP 5: Store in state
-        # ============================================================
-        
+        # STEP 6: Finalize state
         state.search_results = results
         state.temp_data["response_text"] = formatted_results
         state.temp_data["action"] = "search_results"
         state.temp_data["inferred_currency"] = inferred_currency
         
-        # ============================================================
-        # STEP 6: Transition to SEARCH_RESULTS then IDLE
-        # ============================================================
-        
-        # First transition: search_query → search_results
-        success, error = state.transition_to(FlowState.SEARCH_RESULTS, reason="Hybrid search completed")
-        
-        if not success:
-            logger.error("Transition to SEARCH_RESULTS failed", error=error)
-            state.set_error(error, should_retry=False)
-        else:
-            # Second transition: search_results → idle
-            success2, error2 = state.transition_to(FlowState.IDLE, reason="Search results shown")
-            if not success2:
-                logger.warning("Transition to IDLE failed", error=error2)
-        
-        logger.info(
-            "Hybrid search flow completed",
-            user_id=state.user_id,
-            results_count=len(results),
-            currency=inferred_currency
-        )
+        # 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 query error", exc_info=e)
-        error_msg = f"Search error: {str(e)}"
-        
-        state.set_error(error_msg, should_retry=True)
-        state.temp_data["response_text"] = (
-            "I had trouble searching for listings. Please try again with a simpler query."
-        )
-        state.temp_data["action"] = "search_error"
-        
-        return state
+        logger.error("Search flow failed", exc_info=e)
+        state.set_error(str(e))
+        return state

app/ai/agent/nodes/validate_output.py

@@ -16,6 +16,30 @@ from app.ai.tools.listing_tool import get_currency_for_location
 logger = get_logger(__name__)
 
 
+def count_sentences(text: str) -> int:
+    """
+    Count the number of sentences in a text.
+    A sentence ends with ., !, or ?
+    
+    Args:
+        text: Text to count sentences in
+        
+    Returns:
+        Number of sentences
+    """
+    if not text:
+        return 0
+    
+    # Count sentence endings: . ! ?
+    import re
+    # Split by sentence endings and filter out empty strings
+    sentences = re.split(r'[.!?]+', text.strip())
+    # Filter out empty or whitespace-only sentences
+    sentences = [s.strip() for s in sentences if s.strip()]
+    return len(sentences)
+
+
+
 class OutputValidator:
     """Comprehensive output validation"""
     
@@ -125,6 +149,12 @@ class OutputValidator:
             elif len(description) > 1500:
                 warnings.append("Description is very long")
             
+            # Check for minimum 3 sentences
+            sentence_count = count_sentences(description)
+            if sentence_count < 3:
+                errors.append(f"Description must have at least 3 sentences (currently has {sentence_count})")
+
+            
             # Check price is positive
             price = draft.get("price")
             if isinstance(price, (int, float)) and price <= 0:

app/ai/agent/schemas.py

@@ -32,7 +32,7 @@ class UserMessage(BaseModel):
 
 class Intent(BaseModel):
     """LLM classification output"""
-    type: Literal["greeting", "listing", "search", "my_listings", "edit_listing", "publish", "casual_chat", "unknown"]
+    type: Literal["greeting", "listing", "search", "my_listings", "edit_listing", "publish", "set_notification", "casual_chat", "unknown"]
     confidence: float = Field(..., ge=0.0, le=1.0)
     reasoning: str = Field(..., min_length=1, max_length=500)
     requires_auth: bool = False
@@ -73,6 +73,9 @@ class ListingDraft(BaseModel):
     listing_type: Literal["rent", "short-stay", "sale", "roommate"]
     amenities: List[str] = Field(default_factory=list)
     requirements: Optional[str] = None
+    address: Optional[str] = None  # Full precise address (e.g., "Akpakpa, Cotonou, Benin")
+    latitude: Optional[float] = None  # Geocoded latitude for map display
+    longitude: Optional[float] = None  # Geocoded longitude for map display
     images: List[str] = Field(default_factory=list)
     
     @validator("images")

app/ai/agent/state.py

@@ -38,6 +38,7 @@ class FlowState(str, Enum):
     
     # Other flows
     GREETING = "greeting"
+    SET_NOTIFICATION = "set_notification"
     CASUAL_CHAT = "casual_chat"
     
     # Terminal states
@@ -121,6 +122,7 @@ class AgentState(BaseModel):
                 FlowState.SEARCH_QUERY,
                 FlowState.MY_LISTINGS,  # Added for my listings
                 FlowState.EDIT_LISTING,  # Added for edit listing
+                FlowState.SET_NOTIFICATION,  # Added for notifications
                 FlowState.CASUAL_CHAT,
                 FlowState.ERROR,
             ],
@@ -169,6 +171,11 @@ class AgentState(BaseModel):
                 FlowState.IDLE,
                 FlowState.ERROR,
             ],
+            FlowState.SET_NOTIFICATION: [
+                FlowState.IDLE,
+                FlowState.CLASSIFY_INTENT,
+                FlowState.ERROR,
+            ],
             FlowState.CASUAL_CHAT: [
                 FlowState.IDLE,
                 FlowState.CLASSIFY_INTENT,

app/ai/prompts/system_prompt.py

@@ -194,10 +194,11 @@ Title Generation:
 - MUST include location name
 
 Description Generation:
-- Professional, clean, 2-3 sentences
+- Professional, clean, at least 3 sentences (MINIMUM REQUIREMENT)
 - Include: bedrooms, bathrooms, location, amenities (if any), price, requirements (if any)
 - Make it appealing and detailed
 - Example: "Spacious 3-bedroom, 2-bathroom rental in Lagos with wifi, parking, and balcony. Priced at 50,000 NGN per month. Tenants must provide 3-month security deposit."
+- CRITICAL: Always ensure at least 3 complete sentences
 
 STEP 5: WHEN ALL FIELDS COLLECTED
 Once all required fields complete:
@@ -292,7 +293,7 @@ Title
 - Example: "3-Bed Rent in Lagos"
 
 Description
-- Auto-generated: Professional, 2-3 sentences
+- Auto-generated: Professional, at least 3 sentences (MINIMUM)
 - Includes: bedrooms, bathrooms, location, amenities, price, requirements
 
 ========== IMPORTANT RULES ==========
@@ -404,7 +405,7 @@ Title Format:
 - "{{Bedrooms}}-Bed {{ListingType}} in {{Location}}"
 
 Description:
-- Professional, 2-3 sentences
+- Professional, at least 3 sentences (MINIMUM REQUIREMENT)
 - Includes all key details
 
 FIELDS COLLECTED:

app/ai/routes/chat.py

@@ -447,7 +447,7 @@ async def handle_image_upload_result(body: ImageUploadResult) -> AgentResponse:
                 user_id=user_id,
                 user_role="landlord"
             )
-            return await ask(ask_body)
+            return await ask_ai(ask_body)
             
         else:
             # Image rejected - generate friendly error via AIDA

app/ai/services/notification_service.py

@@ -0,0 +1,78 @@
+# app/ai/services/notification_service.py
+"""
+Notification Service - Handles user waitlists and proactive alerts.
+"""
+
+from typing import Dict, Any, List
+from datetime import datetime
+from structlog import get_logger
+from bson import ObjectId
+
+from app.database import get_db
+
+logger = get_logger(__name__)
+
+async def create_waitlist_request(user_id: str, search_params: Dict[str, Any], original_query: str) -> str:
+    """
+    Store a user's search criteria for future notifications.
+    """
+    try:
+        db = await get_db()
+        
+        waitlist_entry = {
+            "user_id": user_id,
+            "search_params": search_params,
+            "original_query": original_query,
+            "status": "active",
+            "created_at": datetime.utcnow(),
+            "last_checked_at": datetime.utcnow()
+        }
+        
+        result = await db.waitlist.insert_one(waitlist_entry)
+        logger.info("Waitlist entry created", user_id=user_id, entry_id=str(result.inserted_id))
+        return str(result.inserted_id)
+        
+    except Exception as e:
+        logger.error("Failed to create waitlist entry", error=str(e), user_id=user_id)
+        return ""
+
+async def check_matches_for_new_listing(listing_doc: Dict[str, Any]):
+    """
+    Scan the waitlist for users who might be interested in this new listing.
+    In a real production app, this would trigger Push Notifications or emails.
+    For now, we log the matches.
+    """
+    try:
+        db = await get_db()
+        
+        # Simple matching logic: Location + Price (Max) + Bedrooms
+        location = listing_doc.get("location", "").lower()
+        price = float(listing_doc.get("price", 0))
+        bedrooms = int(listing_doc.get("bedrooms", 0))
+        
+        # Find active waitlist entries matching this criteria
+        # This is a simplified example of proactive matching
+        query = {
+            "status": "active",
+            "search_params.location": {"$regex": f"^{location}$", "$options": "i"},
+            "search_params.max_price": {"$gte": price} if price > 0 else {"$exists": True},
+            "search_params.bedrooms": {"$lte": bedrooms} if bedrooms > 0 else {"$exists": True}
+        }
+        
+        matches = await db.waitlist.find(query).to_list(100)
+        
+        if matches:
+            logger.info("Found waitlist matches for new listing!", count=len(matches), listing_id=str(listing_doc.get("_id")))
+            for match in matches:
+                # Logic to notify user would go here (e.g., Firebase Cloud Messaging)
+                # For this task, we assume the system registers the match.
+                logger.info("PROACTIVE MATCH FOUND", user_id=match["user_id"], listing_title=listing_doc.get("title"))
+                
+                # Mark as notified or update last checked
+                await db.waitlist.update_one(
+                    {"_id": match["_id"]},
+                    {"$set": {"last_match_at": datetime.utcnow()}}
+                )
+                
+    except Exception as e:
+        logger.error("Proactive match check failed", error=str(e))

app/ai/services/search_service.py

@@ -222,115 +222,101 @@ def normalize_amenities(amenities: List[str]) -> List[str]:
 async def hybrid_search(
     query_text: str,
     search_params: Dict[str, Any],
-    limit: int = 10
+    limit: int = 10,
+    mode: str = "strict"
 ) -> List[Dict]:
     """
     Perform hybrid search: vector similarity + payload filters.
     
     Args:
         query_text: Original user query for semantic search
-        search_params: Extracted search parameters (location, price, amenities, etc.)
-        limit: Maximum results to return
+        search_params: Extracted search parameters
+        limit: Max results
+        mode: "strict" (apply all filters) or "relaxed" (skip filters, use vector similarity)
     
     Returns:
         List of matching listings sorted by relevance
     """
     
-    logger.info("Starting hybrid search", query=query_text[:50], params_keys=list(search_params.keys()))
+    logger.info("Starting hybrid search", query=query_text[:50], mode=mode)
     
     if not qdrant_client:
         logger.error("Qdrant client not available")
         return []
     
     # ============================================================
-    # STEP 1: Build filter conditions
+    # STEP 1: Build filter conditions (ONLY for strict mode)
     # ============================================================
     
     filter_conditions = []
     
-    # Location filter (exact match on lowercase - uses KEYWORD index)
-    if search_params.get("location"):
-        location_lower = search_params["location"].lower()
-        filter_conditions.append(
-            FieldCondition(
-                key="location_lower",
-                match=MatchValue(value=location_lower)
-            )
-        )
-        logger.info("Added location filter", location=location_lower)
-    
-    # Max price filter
-    if search_params.get("max_price"):
-        filter_conditions.append(
-            FieldCondition(
-                key="price",
-                range=Range(lte=float(search_params["max_price"]))
-            )
-        )
-        logger.info("Added max_price filter", max_price=search_params["max_price"])
-    
-    # Min price filter
-    if search_params.get("min_price"):
-        filter_conditions.append(
-            FieldCondition(
-                key="price",
-                range=Range(gte=float(search_params["min_price"]))
+    if mode == "strict":
+        # Location filter
+        if search_params.get("location"):
+            location_lower = search_params["location"].lower()
+            filter_conditions.append(
+                FieldCondition(
+                    key="location_lower",
+                    match=MatchValue(value=location_lower)
+                )
             )
-        )
-        logger.info("Added min_price filter", min_price=search_params["min_price"])
-    
-    # Bedrooms filter
-    if search_params.get("bedrooms"):
-        filter_conditions.append(
-            FieldCondition(
-                key="bedrooms",
-                range=Range(gte=int(search_params["bedrooms"]))
+        
+        # Max price filter
+        if search_params.get("max_price"):
+            filter_conditions.append(
+                FieldCondition(
+                    key="price",
+                    range=Range(lte=float(search_params["max_price"]))
+                )
             )
-        )
-        logger.info("Added bedrooms filter", bedrooms=search_params["bedrooms"])
-    
-    # Bathrooms filter
-    if search_params.get("bathrooms"):
-        filter_conditions.append(
-            FieldCondition(
-                key="bathrooms",
-                range=Range(gte=int(search_params["bathrooms"]))
+        
+        # Min price filter
+        if search_params.get("min_price"):
+            filter_conditions.append(
+                FieldCondition(
+                    key="price",
+                    range=Range(gte=float(search_params["min_price"]))
+                )
             )
-        )
-        logger.info("Added bathrooms filter", bathrooms=search_params["bathrooms"])
-    
-    # Listing type filter
-    if search_params.get("listing_type"):
-        filter_conditions.append(
-            FieldCondition(
-                key="listing_type_lower",
-                match=MatchValue(value=search_params["listing_type"].lower())
+        
+        # Bedrooms filter
+        if search_params.get("bedrooms"):
+            filter_conditions.append(
+                FieldCondition(
+                    key="bedrooms",
+                    range=Range(gte=int(search_params["bedrooms"]))
+                )
             )
-        )
-        logger.info("Added listing_type filter", listing_type=search_params["listing_type"])
-    
-    # Price type filter (monthly, weekly, etc.)
-    if search_params.get("price_type"):
-        filter_conditions.append(
-            FieldCondition(
-                key="price_type_lower",
-                match=MatchValue(value=search_params["price_type"].lower())
+        
+        # Bathrooms filter
+        if search_params.get("bathrooms"):
+            filter_conditions.append(
+                FieldCondition(
+                    key="bathrooms",
+                    range=Range(gte=int(search_params["bathrooms"]))
+                )
             )
-        )
-        logger.info("Added price_type filter", price_type=search_params["price_type"])
-    
-    # Amenities filter - ALL must match
-    if search_params.get("amenities"):
-        normalized = normalize_amenities(search_params["amenities"])
-        for amenity in normalized:
+        
+        # Listing type filter
+        if search_params.get("listing_type"):
             filter_conditions.append(
                 FieldCondition(
-                    key="amenities",
-                    match=MatchValue(value=amenity)
+                    key="listing_type_lower",
+                    match=MatchValue(value=search_params["listing_type"].lower())
                 )
             )
-        logger.info("Added amenities filter", amenities=normalized)
-    
+        
+        # Amenities filter
+        if search_params.get("amenities"):
+            normalized = normalize_amenities(search_params["amenities"])
+            for amenity in normalized:
+                filter_conditions.append(
+                    FieldCondition(
+                        key="amenities",
+                        match=MatchValue(value=amenity)
+                    )
+                )
+
     # ============================================================
     # STEP 2: Build query filter
     # ============================================================
@@ -338,7 +324,6 @@ async def hybrid_search(
     query_filter = None
     if filter_conditions:
         query_filter = Filter(must=filter_conditions)
-        logger.info("Filter built", conditions_count=len(filter_conditions))
     
     # ============================================================
     # STEP 3: Embed the query for semantic search
@@ -348,7 +333,6 @@ async def hybrid_search(
     
     if not query_vector:
         logger.warning("Query embedding failed, falling back to filter-only search")
-        # Fallback: scroll with filters only
         try:
             results, _ = await qdrant_client.scroll(
                 collection_name=COLLECTION_NAME,
@@ -366,7 +350,6 @@ async def hybrid_search(
     # ============================================================
     
     try:
-        # Use query method (not search) for async client
         results = await qdrant_client.query_points(
             collection_name=COLLECTION_NAME,
             query=query_vector,
@@ -375,13 +358,11 @@ async def hybrid_search(
             with_payload=True
         )
         
-        logger.info("Hybrid search completed", results_count=len(results.points))
-        
-        # Extract payloads with scores
         listings = []
         for point in results.points:
             listing = dict(point.payload)
             listing["_relevance_score"] = point.score
+            listing["_is_suggestion"] = (mode == "relaxed")
             listings.append(listing)
         
         return listings
@@ -390,7 +371,6 @@ async def hybrid_search(
         logger.error("Hybrid search failed", error=str(e))
         return []
 
-
 # ============================================================
 # MAIN SEARCH FUNCTION (Public API)
 # ============================================================
@@ -398,31 +378,24 @@ async def hybrid_search(
 async def search_listings_hybrid(
     user_query: str,
     search_params: Dict[str, Any],
-    limit: int = 10
+    limit: int = 10,
+    mode: str = "strict"
 ) -> Tuple[List[Dict], str]:
     """
     Main entry point for hybrid property search.
-    
-    Args:
-        user_query: Original natural language query
-        search_params: Extracted search parameters
-        limit: Max results
-    
-    Returns:
-        Tuple of (listings, inferred_currency)
     """
     
     # Infer currency from location
-    currency = "XOF"  # Default
+    currency = "XOF"
     if search_params.get("location"):
-        currency, confidence = await infer_currency_from_location(search_params["location"])
-        logger.info("Currency for search", currency=currency, confidence=confidence)
+        currency, _ = await infer_currency_from_location(search_params["location"])
     
-    # Perform hybrid search
+    # Perform search
     results = await hybrid_search(
         query_text=user_query,
         search_params=search_params,
-        limit=limit
+        limit=limit,
+        mode=mode
     )
     
     return results, currency

app/ai/services/vector_service.py

@@ -0,0 +1,127 @@
+# app/ai/services/vector_service.py
+"""
+Vector Service - Handles automated Qdrant indexing for listings.
+Ensures real-time synchronization between MongoDB and Qdrant.
+"""
+
+import uuid
+from typing import Dict, Any, Optional
+from structlog import get_logger
+from qdrant_client.models import PointStruct
+
+from app.ai.config import qdrant_client
+from app.ai.services.search_service import embed_query, COLLECTION_NAME
+
+logger = get_logger(__name__)
+
+def get_deterministic_uuid(mongo_id: str) -> str:
+    """
+    Generate a deterministic UUID from a MongoDB ObjectId string.
+    Ensures that multiple upserts for the same MongoDB listing result
+    in the same Qdrant point ID, correctly handling updates.
+    """
+    if not mongo_id:
+        return str(uuid.uuid4())
+    
+    # MongoDB ID is 24 hex chars. UUID needs 32 hex chars.
+    # We pad the mongo_id with zeros to make it a valid UUID hex.
+    # Pattern: 00000000-0000-0000-0000-xxxxxxxxxxxx
+    padded_hex = mongo_id.zfill(32)
+    return str(uuid.UUID(hex=padded_hex))
+
+async def upsert_listing_to_vector_db(listing_doc: Dict[str, Any]) -> bool:
+    """
+    Index or update a listing in the Qdrant vector database.
+    
+    Args:
+        listing_doc: Dictionary containing listing details from MongoDB
+    
+    Returns:
+        True if successful, False otherwise
+    """
+    if not qdrant_client:
+        logger.error("Qdrant client not configured, skipping vector indexing")
+        return False
+
+    try:
+        mongo_id = str(listing_doc.get("_id"))
+        point_id = get_deterministic_uuid(mongo_id)
+        
+        # Build text for embedding
+        bedrooms = listing_doc.get("bedrooms") or 0
+        location = listing_doc.get("location") or ""
+        address = listing_doc.get("address") or ""
+        title = listing_doc.get("title") or ""
+        description = listing_doc.get("description") or ""
+        
+        # We include address and title for better semantic matching
+        text = f"{title}. {bedrooms}-bed in {location} ({address}). {description}".strip()
+        
+        vector = await embed_query(text)
+        if not vector:
+            logger.error("Failed to generate embedding for listing", mongo_id=mongo_id)
+            return False
+
+        # Prepare payload - keep it in sync with search_service.py filters
+        price_type = listing_doc.get("price_type") or ""
+        listing_type = listing_doc.get("listing_type") or listing_doc.get("type") or ""
+        
+        payload = {
+            "mongo_id": mongo_id,
+            "title": title,
+            "description": description,
+            "location": location,
+            "location_lower": location.lower() if location else "",
+            "address": address,
+            "price": float(listing_doc.get("price") or 0),
+            "price_type": price_type,
+            "price_type_lower": price_type.lower() if price_type else "",
+            "listing_type": listing_type,
+            "listing_type_lower": listing_type.lower() if listing_type else "",
+            "bedrooms": int(bedrooms),
+            "bathrooms": int(listing_doc.get("bathrooms") or 0),
+            "amenities": [a.lower() for a in (listing_doc.get("amenities") or [])],
+            "currency": listing_doc.get("currency", "XOF"),
+            "status": listing_doc.get("status", "active"),
+            "latitude": listing_doc.get("latitude"),
+            "longitude": listing_doc.get("longitude"),
+            "images": listing_doc.get("images", []),  # ✅ FIX: Include images array
+        }
+
+        # Upsert point
+        await qdrant_client.upsert(
+            collection_name=COLLECTION_NAME,
+            points=[
+                PointStruct(
+                    id=point_id,
+                    vector=vector,
+                    payload=payload
+                )
+            ]
+        )
+        
+        logger.info("Listing synced to Qdrant", mongo_id=mongo_id, point_id=point_id)
+        return True
+
+    except Exception as e:
+        logger.error("Failed to sync listing to Qdrant", error=str(e), mongo_id=str(listing_doc.get("_id")))
+        return False
+
+async def delete_listing_from_vector_db(mongo_id: str) -> bool:
+    """
+    Remove a listing from the Qdrant vector database.
+    """
+    if not qdrant_client:
+        return False
+
+    try:
+        point_id = get_deterministic_uuid(mongo_id)
+        await qdrant_client.delete(
+            collection_name=COLLECTION_NAME,
+            points_selector=[point_id]
+        )
+        logger.info("Listing removed from Qdrant", mongo_id=mongo_id, point_id=point_id)
+        return True
+    except Exception as e:
+        logger.error("Failed to remove listing from Qdrant", error=str(e), mongo_id=mongo_id)
+        return False

app/ai/tools/listing_conversation_manager.py

@@ -32,6 +32,8 @@ async def generate_smart_listing_response(
     missing_required_fields: list,
     last_action: str = None,
     listing_example: str = None,
+    needs_address_refinement: bool = False,
+    vague_location: str = None,
 ) -> Dict:
     """
     Generate FULLY INTELLIGENT response for listing flow
@@ -68,6 +70,25 @@ IMPORTANT: This is the user's first interaction in the listing flow.
 You MUST show them this example to get them started:
 "{listing_example}"
 State your intention is "show_example".
+"""
+
+    # If location is vague, guide LLM to ask for precise neighborhood/area
+    address_refinement_instruction = ""
+    if needs_address_refinement and vague_location:
+        address_refinement_instruction = f"""
+🏠 NEIGHBORHOOD/AREA REQUIRED:
+The user only provided the city: "{vague_location}"
+You MUST ask them for the specific NEIGHBORHOOD or AREA (NOT a full street address).
+We need this to pin the property on a map more accurately.
+
+Examples of what we want:
+- In Cotonou: "Akpakpa", "Kpondehou", "Cadjehoun", "Haie Vive", "Fidjrossè"
+- In Lagos: "Victoria Island", "Lekki", "Ikeja", "Yaba"
+
+Example question: "Where exactly in {vague_location} is your property? (e.g., Akpakpa, Kpondehou, Fidjrossè...)"
+
+This takes PRIORITY over "all_collected" - do NOT transition to draft preview until you have the neighborhood!
+Set action to "ask_address".
 """
 
     prompt = f"""{system_prompt}
@@ -107,11 +128,12 @@ Last action I took:
    - If only images are missing, say something like: "Almost done! Just need a photo of your property. Can you share an image?"
 
 {example_instruction}
+{address_refinement_instruction}
 
 OUTPUT JSON format:
 {{
   "intent_still_listing": boolean,
-  "action": "ask_fields" | "answer_question" | "show_draft" | "show_example",
+  "action": "ask_fields" | "ask_address" | "answer_question" | "show_draft" | "show_example",
   "response_text": "Your natural, friendly response here",
   "reasoning": "Why you chose this action"
 }}

app/ai/tools/listing_tool.py

@@ -22,6 +22,123 @@ llm = ChatOpenAI(
     temperature=0.3,
 )
 
+# ============================================================
+# ADDRESS REFINEMENT & GEOCODING
+# ============================================================
+
+def is_vague_location(location: str) -> bool:
+    """
+    Detect if a location is too vague (city-only, needs precise address).
+    
+    Returns:
+        True if location is vague (e.g., "Cotonou", "Lagos")
+        False if location is precise (e.g., "Akpakpa, Cotonou", "Victoria Island Lagos")
+    """
+    if not location:
+        return True
+    
+    location = location.strip()
+    
+    # If location contains comma or multiple words with neighborhood indicators, it's likely precise
+    if "," in location:
+        return False
+    
+    # Check for common neighborhood/area indicators
+    words = location.split()
+    if len(words) >= 2:
+        # Multiple words like "Akpakpa Midombo" or "Victoria Island" are likely precise
+        return False
+    
+    # Single word like "Cotonou", "Lagos" is vague
+    return True
+
+
+async def geocode_address(address: str, city: str = None) -> Dict:
+    """
+    Geocode an address using Nominatim (OpenStreetMap).
+    
+    Args:
+        address: The precise address/neighborhood (e.g., "Akpakpa")
+        city: Optional city to append for better accuracy (e.g., "Cotonou")
+    
+    Returns:
+        {
+            "success": True/False,
+            "full_address": "Akpakpa, Cotonou, Benin",
+            "city": "Cotonou",
+            "latitude": 6.3654,
+            "longitude": 2.4183
+        }
+    """
+    import aiohttp
+    
+    if not address:
+        return {"success": False, "error": "No address provided"}
+    
+    # Build search query
+    search_query = address.strip()
+    if city and city.lower() not in search_query.lower():
+        search_query = f"{search_query}, {city}"
+    
+    try:
+        async with aiohttp.ClientSession() as session:
+            # URL-encode the search query to handle special characters, spaces, and accents
+            from urllib.parse import quote
+            encoded_query = quote(search_query, safe='')
+            url = f"https://nominatim.openstreetmap.org/search?q={encoded_query}&format=json&limit=1&addressdetails=1"
+            headers = {"User-Agent": "AIDA-RealEstate-App/1.0"}
+            
+            async with session.get(url, headers=headers, timeout=10) as resp:
+                if resp.status == 200:
+                    data = await resp.json()
+                    
+                    if data and len(data) > 0:
+                        result = data[0]
+                        address_details = result.get("address", {})
+                        
+                        # Extract city from Nominatim response
+                        extracted_city = (
+                            address_details.get("city") or
+                            address_details.get("town") or
+                            address_details.get("municipality") or
+                            address_details.get("county") or
+                            address_details.get("village") or
+                            city  # Fallback to provided city
+                        )
+                        
+                        # Build full address
+                        full_address = result.get("display_name", search_query)
+                        
+                        logger.info(
+                            "Geocoding successful",
+                            query=search_query,
+                            city=extracted_city,
+                            lat=result.get("lat"),
+                            lon=result.get("lon")
+                        )
+                        
+                        return {
+                            "success": True,
+                            "full_address": full_address,
+                            "city": extracted_city,
+                            "latitude": float(result.get("lat")),
+                            "longitude": float(result.get("lon")),
+                        }
+                    else:
+                        logger.warning("Geocoding returned no results", query=search_query)
+                        return {
+                            "success": False,
+                            "error": "No results found",
+                            "city": city,
+                        }
+                else:
+                    logger.error("Geocoding API error", status=resp.status)
+                    return {"success": False, "error": f"API error: {resp.status}"}
+                    
+    except Exception as e:
+        logger.error("Geocoding failed", error=str(e), query=search_query)
+        return {"success": False, "error": str(e), "city": city}
+
 # ============================================================
 # FIELD EXTRACTION - FIXED TO RETURN VALUES
 # ============================================================
@@ -47,45 +164,79 @@ User role: {user_role}
 User message: "{user_message}"{context}
 
 Extract these fields (IMPORTANT: return the ACTUAL VALUES, not just field names!):
-- location: City/area name (e.g., "Lagos", "Cotonou") or null
+- location: City name ONLY (e.g., "Lagos", "Cotonou") or null
+- address: Precise neighborhood/area/street (e.g., "Akpakpa", "Victoria Island", "Akpakpa Midombo") or null
+  - If user provides "Akpakpa, Cotonou" → location: "Cotonou", address: "Akpakpa"
+  - If user provides just "Cotonou" → location: "Cotonou", address: null
+  - If user provides "my apartment in Akpakpa" → location: null, address: "Akpakpa"
 - bedrooms: Number as integer (e.g., 2, 3, 4) or null
 - bathrooms: Number as integer (e.g., 1, 2) or null
 - price: Amount as number (e.g., 50000, 1200) or null - understand "50k" as 50000
-- price_type: "monthly", "yearly", "weekly", "daily", "nightly" or null
-- amenities: List of amenities ["wifi", "parking", "furnished", "ac"] or [] 
+- price_type: "monthly", "yearly", "weekly", "daily", "nightly", "total", "one-time" or null
+- listing_type: "rent", "sale", "short-stay", "roommate" or null (infer from context: "selling"->"sale", "renting"->"rent", "airbnb"->"short-stay")
+- amenities: List of property features/amenities in ANY LANGUAGE - extract the EXACT words the user used
+  
+  🌍 AMENITY DETECTION (UNIVERSAL - ANY LANGUAGE):
+  Detect ANY property features, facilities, or amenities mentioned by the user.
+  Return them in their ORIGINAL language as the user wrote them.
+  
+  Examples of amenities in different languages:
+  • English: "wifi", "parking", "pool", "gym", "garden", "balcony", "furnished", "air conditioning", "modern kitchen"
+  • French: "wifi", "parking", "piscine", "salle de sport", "jardin", "balcon", "meublé", "climatisation", "cuisine moderne"
+  • Spanish: "wifi", "estacionamiento", "piscina", "gimnasio", "jardín", "balcón", "amueblado", "aire acondicionado"
+  • Portuguese: "wifi", "estacionamento", "piscina", "academia", "jardim", "varanda", "mobilado", "ar condicionado"
+  
+  CRITICAL: Extract amenities in the EXACT language the user used. Do NOT translate.
+  - User says "grand jardin, parking, wifi" → amenities: ["grand jardin", "parking", "wifi"]
+  - User says "large garden, parking, wifi" → amenities: ["large garden", "parking", "wifi"]
+  - User says "piscina, gimnasio, wifi" → amenities: ["piscina", "gimnasio", "wifi"]
+  
 - amenities_operation: "add" (append to existing) or "replace" (replace all) - default is "add"
 - requirements: Text of requirements or null
 - images: List of valid URLs (start with http/https) found in message or []
-- images_operation: "add" (append to existing) or "replace" (replace all) - default is "add"
+- images_operation: "add", "replace", "replace_at", or "remove_at" - default is "add"
+- image_index: Integer (1-indexed) if user specifies which image to modify (e.g., "image 2", "first photo") or null
 - title: If user explicitly wants to change title, the new title or null
 - description: If user explicitly wants to change description, the new description or null
 
-OPERATION DETECTION:
-- "add image" / "here is another photo" / "one more" → images_operation: "add"
-- "replace images" / "change images to" / "use this instead" / "new images" → images_operation: "replace"
+IMAGE OPERATION DETECTION:
+- "add image" / "here is another photo" / "one more" → images_operation: "add", image_index: null
+- "replace all images" / "change images to" / "new images" → images_operation: "replace", image_index: null
+- "replace image 2" / "change the second photo" / "swap image 3" → images_operation: "replace_at", image_index: 2 (or 3)
+- "remove image 1" / "delete the first photo" / "remove image 4" → images_operation: "remove_at", image_index: 1 (or 4)
 - "add wifi" / "also has parking" → amenities_operation: "add"  
 - "replace amenities" / "only wifi" / "change amenities to" → amenities_operation: "replace"
 - If user just says "swimming pool, wifi" while editing → amenities_operation: "replace" (replacing)
 - If user says "add swimming pool" → amenities_operation: "add" (appending)
 
 CRITICAL: Extract ACTUAL VALUES!
-- "50k per month" → price: 50000, price_type: "monthly"
+- "50k per month" → price: 50000, price_type: "monthly", listing_type: "rent"
+- "Selling for 50M" → price: 50000000, price_type: "total", listing_type: "sale"
+- "20k per night" → price: 20000, price_type: "nightly", listing_type: "short-stay"
+- "grand jardin, cuisine moderne, parking" → amenities: ["grand jardin", "cuisine moderne", "parking"]
 - "2-bed, 1-bath" → bedrooms: 2, bathrooms: 1
-- "Lagos" → location: "Lagos"
+- "Lagos" → location: "Lagos", address: null
+- "Akpakpa, Cotonou" → location: "Cotonou", address: "Akpakpa"
+- "Victoria Island Lagos" → location: "Lagos", address: "Victoria Island"
 - "Here is the photo: https://example.com/img.jpg" → images: ["https://example.com/img.jpg"]
+- "Replace image 2 with this" + URL → images_operation: "replace_at", image_index: 2, images: ["https://..."]
+- "Delete the first photo" → images_operation: "remove_at", image_index: 1, images: []
 
 Return ONLY valid JSON:
 {{
   "location": "Lagos" or null,
+  "address": "Victoria Island" or null,
   "bedrooms": 2 or null,
   "bathrooms": 1 or null,
   "price": 50000 or null,
   "price_type": "monthly" or null,
-  "amenities": ["wifi", "parking"] or [],
+  "listing_type": "rent" or null,
+  "amenities": ["grand jardin", "cuisine moderne", "parking"] or [],
   "amenities_operation": "add" or "replace",
   "requirements": "3-month deposit" or null,
   "images": ["https://..."] or [],
-  "images_operation": "add" or "replace",
+  "images_operation": "add" or "replace" or "replace_at" or "remove_at",
+  "image_index": 2 or null,
   "title": "New Title" or null,
   "description": "New description" or null
 }}"""
@@ -157,39 +308,69 @@ Return ONLY the example, no extra text."""
 # AUTO-DETECT LISTING TYPE (Role-Based Restrictions)
 # ============================================================
 
-async def auto_detect_listing_type(price_type: str, user_role: str, user_message: str = "") -> str:
+async def auto_detect_listing_type(price_type: str, user_role: str, user_message: str = "", extracted_type: str = None) -> str:
     """
-    Auto-detect listing type from context with role-based restrictions.
+    Auto-detect listing type using LLM extraction + price rules.
     
-    Rules:
-    - Renter: Can ONLY list "roommate" (anything else is blocked)
-    - Landlord: Can list "rent", "short-stay", "sale" (but NOT "roommate")
-    
-    Detection logic:
-    - "for sale" keywords → "sale"
-    - weekly/daily/nightly price_type → "short-stay"
-    - monthly/yearly price_type → "rent"
+    Priority:
+    1. Role restrictions (Renter -> roommate)
+    2. LLM extracted type (if valid)
+    3. Price type inference
+    4. Default (rent)
     """
     
-    # RENTER: Can ONLY list roommate
-    if user_role == "renter":
+    # RENTER/ROOMMATE role: Always roommate listings
+    if user_role in ["renter", "roommate"]:
         return "roommate"
+        
+    # If LLM explicitly extracted a valid type, trust it (but validate)
+    if extracted_type:
+        valid_types = ["rent", "sale", "short-stay", "roommate"]
+        if extracted_type in valid_types:
+            # Landlords can't list roommates usually, but if explicitly said...
+            if extracted_type == "roommate" and user_role == "landlord":
+                 pass # Allow or block? Let's strictly block for now
+            else:
+                return extracted_type
+    
+    # LANDLORD: Detect from price_type as backup
+    price_type_lower = (price_type or "").lower().strip()
+    
+    # ============================================================
+    # SHORT-STAY: daily, nightly, weekly (any language)
+    # ============================================================
+    SHORT_STAY_TYPES = [
+        # English
+        "daily", "day", "per day", 
+        "nightly", "night", "per night",
+        "weekly", "week", "per week",
+        # French
+        "jour", "journalier", "par jour",
+        "nuit", "nuitée", "par nuit",
+        "semaine", "hebdomadaire", "par semaine",
+    ]
     
-    # LANDLORD: Detect type from context (cannot list roommate)
-    message_lower = (user_message or "").lower()
-    
-    # Check for sale keywords
-    if any(word in message_lower for word in ["sell", "sale", "selling", "for sale", "buy"]):
-        return "sale"
+    if any(t in price_type_lower for t in SHORT_STAY_TYPES):
+        return "short-stay"
     
-    # Check price_type for short-stay vs rent
-    price_type_lower = (price_type or "").lower()
+    # ============================================================
+    # SALE: one-time/total price
+    # ============================================================
+    SALE_TYPES = [
+        # English
+        "total", "one-time", "once", "fixed", "purchase",
+        # French
+        "unique", "forfait", "total", "achat",
+    ]
     
-    # Short-stay: weekly, daily, nightly
-    if price_type_lower in ["weekly", "week", "daily", "day", "nightly", "night"]:
-        return "short-stay"
+    if any(t in price_type_lower for t in SALE_TYPES):
+        return "sale"
     
-    # Rent: monthly, yearly (default for landlord)
+    # ============================================================
+    # RENT: monthly, yearly (default for landlord)
+    # ============================================================
+    # This includes: "monthly", "yearly", "annual", "par mois", "par an", "mensuel", "annuel"
+    # But also anything else that isn't short-stay or sale
     return "rent"
 
 
@@ -260,8 +441,156 @@ async def get_currency_for_location(location: str) -> str:
 # GENERATE TITLE AND DESCRIPTION
 # ============================================================
 
-async def generate_title_and_description(draft_data: Dict, user_role: str) -> Tuple[str, str]:
-    """Auto-generate title and description for listing"""
+async def generate_title_and_description(
+    draft_data: Dict, 
+    user_role: str, 
+    user_language: str = None,
+    conversation_history: list = None
+) -> Tuple[str, str]:
+    """Auto-generate attractive title and description for listing using LLM.
+    
+    Args:
+        draft_data: Listing data
+        user_role: Role of the user
+        user_language: Detected language (e.g., 'fr', 'en'). If None, LLM will detect from context.
+        conversation_history: User's messages to detect language from
+    """
+    bedrooms = draft_data.get("bedrooms", "?")
+    bathrooms = draft_data.get("bathrooms", "?")
+    location = draft_data.get("location", "Unknown")
+    listing_type = draft_data.get("listing_type", "property")
+    price = draft_data.get("price", "?")
+    price_type = draft_data.get("price_type", "monthly")
+    currency = draft_data.get("currency", "")
+    amenities = draft_data.get("amenities", [])
+    requirements = draft_data.get("requirements", "")
+    
+    # Use LLM to generate BOTH title and description in the correct language
+    try:
+        from langchain_openai import ChatOpenAI
+        from langchain_core.messages import HumanMessage
+        from app.config import settings
+        
+        llm = ChatOpenAI(
+            api_key=settings.DEEPSEEK_API_KEY,
+            base_url=settings.DEEPSEEK_BASE_URL,
+            model="deepseek-chat",
+            temperature=0.7,
+        )
+        
+        amenities_str = ", ".join(amenities) if amenities else "standard features"
+        
+        # Extract user's actual words from conversation history
+        user_messages = ""
+        if conversation_history:
+            user_msgs = [msg.get("content", "") for msg in conversation_history if msg.get("role") == "user"]
+            user_messages = " ".join(user_msgs[:3])  # First 3 messages
+        
+        # Language instruction - universal language detection
+        lang_instruction = f"""
+
+🌍 CRITICAL LANGUAGE RULE:
+The user described their property in their own language. You MUST generate the title and description in the EXACT SAME LANGUAGE.
+
+User's original messages: "{user_messages[:300] if user_messages else 'Not available'}"
+
+INSTRUCTIONS:
+1. Detect the language from the user's messages above (French, English, Spanish, Portuguese, Arabic, Chinese, etc.)
+2. Generate BOTH title and description in that EXACT language
+3. Do NOT translate - use the same language the user used
+4. This applies to ANY language, not just English or French
+
+Examples:
+- User speaks French → Title and description in French
+- User speaks Spanish → Title and description in Spanish  
+- User speaks English → Title and description in English
+"""
+        
+        prompt = f"""Generate an attractive TITLE and DESCRIPTION for a real estate listing.
+{lang_instruction}
+
+Property Details:
+- Type: {listing_type}
+- Bedrooms: {bedrooms}
+- Bathrooms: {bathrooms}
+- Location: {location}
+- Price: {price} {currency} per {price_type}
+- Amenities: {amenities_str}
+{f'- Requirements: {requirements}' if requirements else ''}
+
+Guidelines:
+1. TITLE: Short, SEO-friendly (e.g., "Villa 4 chambres à Cotonou" in French, "4-Bed Villa in Lagos" in English)
+2. DESCRIPTION: 3-4 engaging sentences that would attract renters/buyers
+3. Start with a compelling hook about the property
+4. Highlight the location and key features naturally
+5. End with a call-to-action
+6. Do NOT use bullet points
+
+Return ONLY valid JSON:
+{{
+  "title": "Your generated title here",
+  "description": "Your generated description here"
+}}"""
+
+        response = await llm.ainvoke([HumanMessage(content=prompt)])
+        response_text = response.content.strip()
+        
+        # Extract JSON
+        import re
+        json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+        if json_match:
+            result = json.loads(json_match.group())
+            title = result.get("title", "").strip()
+            description = result.get("description", "").strip()
+            
+            if title and description and len(description) > 50:
+                logger.info("Title and description generated via LLM", title=title, desc_len=len(description))
+                return title, description
+        
+        raise ValueError("Failed to parse LLM response")
+        
+    except Exception as e:
+        logger.warning(f"LLM description failed, using fallback: {e}")
+        
+        # Fallback to English template
+        title = f"{bedrooms}-Bed {listing_type.capitalize()} in {location}"
+        
+        amenities_text = ""
+        if amenities:
+            if len(amenities) == 1:
+                amenities_text = f"featuring {amenities[0]}"
+            elif len(amenities) == 2:
+                amenities_text = f"featuring {amenities[0]} and {amenities[1]}"
+            else:
+                amenities_text = f"featuring {', '.join(amenities[:-1])}, and {amenities[-1]}"
+        
+        description = f"This charming {bedrooms}-bedroom, {bathrooms}-bathroom {listing_type} is located in {location}. "
+        
+        if amenities_text:
+            description += f"The property comes {amenities_text}, offering comfort and convenience. "
+        else:
+            description += f"The property offers a perfect blend of comfort and modern living. "
+        
+        description += f"Available at {price} {currency} per {price_type}. "
+        description += "Don't miss this opportunity - schedule a viewing today!"
+        
+        if requirements:
+            description += f" Requirements: {requirements}."
+        
+        logger.info("Title and description generated (fallback)", title=title, sentence_count=description.count('.'))
+        return title, description
+
+
+async def regenerate_description_with_prompt(draft_data: Dict, user_prompt: str, user_role: str) -> str:
+    """
+    Regenerate description based on user's specific prompt/guidance.
+    
+    Examples:
+    - "make it more appealing"
+    - "add more details about the location"
+    - "make it sound luxurious"
+    - "give my property a better description"
+    """
     bedrooms = draft_data.get("bedrooms", "?")
     bathrooms = draft_data.get("bathrooms", "?")
     location = draft_data.get("location", "Unknown")
@@ -269,16 +598,79 @@ async def generate_title_and_description(draft_data: Dict, user_role: str) -> Tu
     price = draft_data.get("price", "?")
     price_type = draft_data.get("price_type", "monthly")
     currency = draft_data.get("currency", "")
-    amenities = ", ".join(draft_data.get("amenities", [])) if draft_data.get("amenities") else "No amenities"
+    amenities = draft_data.get("amenities", [])
+    current_description = draft_data.get("description", "")
+    
+    try:
+        from langchain_openai import ChatOpenAI
+        from langchain_core.messages import HumanMessage
+        from app.config import settings
+        
+        llm = ChatOpenAI(
+            api_key=settings.DEEPSEEK_API_KEY,
+            base_url=settings.DEEPSEEK_BASE_URL,
+            model="deepseek-chat",
+            temperature=0.8,  # Slightly higher for more creativity
+        )
+        
+        amenities_str = ", ".join(amenities) if amenities else "standard features"
+        
+        prompt = f"""You are a professional real estate copywriter. Rewrite this property description based on the user's request.
+
+Current Description:
+"{current_description}"
+
+Property Details:
+- Type: {listing_type}
+- Bedrooms: {bedrooms}
+- Bathrooms: {bathrooms}
+- Location: {location}
+- Price: {price} {currency} per {price_type}
+- Amenities: {amenities_str}
+
+User's Request: "{user_prompt}"
+
+Guidelines:
+1. Follow the user's request carefully
+2. Write 3-5 engaging sentences
+3. Make it feel welcoming, desirable, and professional
+4. Include a compelling hook and call-to-action
+5. Highlight key features naturally (don't just list them)
+6. Do NOT use bullet points or lists
+7. Be creative and paint a picture
+
+Write ONLY the new description, no quotes or extra text:"""
+
+        response = await llm.ainvoke([HumanMessage(content=prompt)])
+        description = response.content.strip().strip('"').strip("'")
+        
+        # Ensure minimum length
+        if len(description) < 50:
+            raise ValueError("Description too short")
+            
+        logger.info("Description regenerated via user prompt", desc_len=len(description), user_prompt=user_prompt[:50])
+        return description
+        
+    except Exception as e:
+        logger.warning(f"LLM description regeneration failed: {e}")
+        # Return original if failed
+        return current_description
+
+
+def is_description_regeneration_request(message: str) -> bool:
+    """
+    Detect if user is asking to regenerate/improve the description.
+    """
+    message_lower = message.lower()
     
-    title = f"{bedrooms}-Bed {listing_type.capitalize()} in {location}"
+    description_keywords = ["description", "describe", "describing"]
+    action_keywords = ["better", "improve", "regenerate", "rewrite", "change", "update", "new", "make", "give", "write", "create", "more", "different", "attractive", "appealing", "professional", "nice", "cool"]
     
-    description = f"Beautiful {bedrooms}-bedroom, {bathrooms}-bathroom {listing_type} in {location}. "
-    description += f"Price: {price} {currency}/{price_type}. "
-    description += f"Amenities: {amenities}."
+    has_description = any(kw in message_lower for kw in description_keywords)
+    has_action = any(kw in message_lower for kw in action_keywords)
     
-    logger.info("Title and description generated", title=title)
-    return title, description
+    return has_description and has_action
+
 
 
 # ============================================================
@@ -418,7 +810,8 @@ async def process_listing(
     listing_type = await auto_detect_listing_type(
         price_type=provided_fields.get("price_type", ""),
         user_role=user_role,
-        user_message=user_message
+        user_message=user_message,
+        extracted_type=provided_fields.get("listing_type")
     )
     provided_fields["listing_type"] = listing_type
     

app/ml/models/ml_listing_extractor.py

@@ -45,9 +45,13 @@ class CurrencyManager:
         try:
             # Use Nominatim (free, no API key needed)
             async with aiohttp.ClientSession() as session:
-                url = f"https://nominatim.openstreetmap.org/search?q={location}&format=json&limit=1&addressdetails=1"
+                # URL-encode the location to handle special characters
+                from urllib.parse import quote
+                encoded_location = quote(location, safe='')
+                url = f"https://nominatim.openstreetmap.org/search?q={encoded_location}&format=json&limit=1&addressdetails=1"
+                headers = {"User-Agent": "AIDA-RealEstate-App/1.0"}
                 
-                async with session.get(url, timeout=5) as resp:
+                async with session.get(url, headers=headers, timeout=10) as resp:
                     if resp.status == 200:
                         data = await resp.json()
                         
@@ -417,9 +421,13 @@ class MLListingExtractor:
         
         try:
             async with aiohttp.ClientSession() as session:
-                url = f"https://nominatim.openstreetmap.org/search?q={address}&format=json&limit=1&addressdetails=1"
+                # URL-encode the address to handle special characters
+                from urllib.parse import quote
+                encoded_address = quote(address, safe='')
+                url = f"https://nominatim.openstreetmap.org/search?q={encoded_address}&format=json&limit=1&addressdetails=1"
+                headers = {"User-Agent": "AIDA-RealEstate-App/1.0"}
                 
-                async with session.get(url, timeout=5) as resp:
+                async with session.get(url, headers=headers, timeout=10) as resp:
                     if resp.status == 200:
                         data = await resp.json()
                         

app/models/listing.py

@@ -19,6 +19,9 @@ class Listing(BaseModel):
     bedrooms: Optional[int] = None
     bathrooms: Optional[int] = None
     location: str
+    address: Optional[str] = None
+    latitude: Optional[float] = None
+    longitude: Optional[float] = None
     amenities: Optional[List[str]] = None
     currency: str = "XOF"
     status: str = "draft"  # draft | active | archived

app/routes/listing.py

@@ -34,7 +34,7 @@ async def get_active_listings(
             try:
                 # Pydantic will handle datetime conversion
                 listing = Listing(**doc)
-                listings.append(listing.dict(by_alias=True))
+                listings.append(listing.model_dump(by_alias=True))
             except Exception as e:
                 print(f"[WARNING] Error parsing listing {doc.get('_id', 'unknown')}: {e}")
                 continue
@@ -81,6 +81,10 @@ async def delete_listing(
         if result.deleted_count == 0:
             raise HTTPException(status_code=500, detail="Failed to delete listing")
         
+        # ✅ Sync to Qdrant - remove the vector
+        from app.ai.services.vector_service import delete_listing_from_vector_db
+        await delete_listing_from_vector_db(listing_id)
+        
         # Decrement user's totalListings counter
         try:
             await db.users.update_one(

app/routes/websocket_listings.py

@@ -96,7 +96,7 @@ async def websocket_listings_endpoint(websocket: WebSocket, token: str = Query(.
                 doc["_id"] = str(doc["_id"])
             try:
                 listing = Listing(**doc)
-                listings.append(listing.dict(by_alias=True))
+                listings.append(listing.model_dump(by_alias=True))
             except Exception as e:
                 logger.warning(f"[WS] Error parsing listing: {e}")
                 continue
@@ -136,7 +136,7 @@ async def websocket_listings_endpoint(websocket: WebSocket, token: str = Query(.
                             doc["_id"] = str(doc["_id"])
                         try:
                             listing = Listing(**doc)
-                            listings.append(listing.dict(by_alias=True))
+                            listings.append(listing.model_dump(by_alias=True))
                         except Exception as e:
                             logger.warning(f"[WS] Error parsing listing: {e}")
                             continue

backfill_geocoding.py

@@ -0,0 +1,93 @@
+"""
+Backfill geocoding for existing listings
+This script geocodes addresses for listings that have an address but no coordinates
+"""
+import asyncio
+from app.database import connect_db, get_db
+from app.ai.tools.listing_tool import geocode_address
+from bson import ObjectId
+
+async def backfill_geocoding():
+    # Initialize database connection
+    await connect_db()
+    db = await get_db()
+    
+    # Find listings that have a location but no latitude/longitude
+    query = {
+        "$or": [
+            # Has address but no coordinates
+            {"address": {"$ne": None}, "latitude": None},
+            {"address": {"$ne": None}, "latitude": {"$exists": False}},
+            # Has location but no coordinates (for city-level geocoding)
+            {"location": {"$ne": None}, "latitude": None},
+            {"location": {"$ne": None}, "latitude": {"$exists": False}},
+        ]
+    }
+    
+    cursor = db.listings.find(query)
+    
+    print("=== Backfilling Geocoding for Existing Listings ===\n")
+    
+    updated_count = 0
+    failed_count = 0
+    
+    async for doc in cursor:
+        listing_id = str(doc.get("_id"))
+        title = doc.get("title", "No title")[:40]
+        location = doc.get("location")
+        address = doc.get("address")
+        
+        # Build search query - prefer address if available
+        if address and location:
+            search_query = f"{address}, {location}"
+        elif address:
+            search_query = address
+        elif location:
+            search_query = location
+        else:
+            print(f"⏭️  Skipping {title} - no location or address")
+            continue
+        
+        print(f"🔍 Geocoding: {title}")
+        print(f"   Query: {search_query}")
+        
+        # Call geocode function
+        geo_result = await geocode_address(search_query, location)
+        
+        if geo_result.get("success"):
+            lat = geo_result.get("latitude")
+            lon = geo_result.get("longitude")
+            
+            # Update the listing in the database
+            update_data = {
+                "latitude": lat,
+                "longitude": lon,
+            }
+            
+            # If we didn't have an address, store the location as address
+            if not address and location:
+                update_data["address"] = location
+            
+            result = await db.listings.update_one(
+                {"_id": ObjectId(listing_id)},
+                {"$set": update_data}
+            )
+            
+            if result.modified_count > 0:
+                print(f"   ✅ Updated: lat={lat}, lon={lon}")
+                updated_count += 1
+            else:
+                print(f"   ⚠️ No change made")
+        else:
+            print(f"   ❌ Geocoding failed: {geo_result.get('error', 'Unknown error')}")
+            failed_count += 1
+        
+        # Small delay to respect Nominatim rate limits
+        await asyncio.sleep(1.1)
+    
+    print(f"\n=== Summary ===")
+    print(f"✅ Updated: {updated_count} listings")
+    print(f"❌ Failed: {failed_count} listings")
+
+if __name__ == "__main__":
+    asyncio.run(backfill_geocoding())

check_db_listings.py

@@ -0,0 +1,45 @@
+"""Check what's in the database for listings"""
+import asyncio
+from app.database import connect_db, get_db
+from app.models.listing import Listing
+
+async def check_listings():
+    # Initialize database connection
+    await connect_db()
+    db = await get_db()
+    
+    # Get the 3 most recent active listings
+    cursor = db.listings.find({"status": "active"}).sort("created_at", -1).limit(3)
+    
+    print("=== Checking Recent Listings in MongoDB ===\n")
+    
+    async for doc in cursor:
+        listing_id = str(doc.get("_id"))
+        title = doc.get("title", "No title")[:50]
+        
+        print(f"Listing: {title}")
+        print(f"  _id: {listing_id}")
+        print(f"  location: {doc.get('location')}")
+        print(f"  address (in DB): {doc.get('address')}")
+        print(f"  latitude (in DB): {doc.get('latitude')}")
+        print(f"  longitude (in DB): {doc.get('longitude')}")
+        
+        # Now convert to Listing model and back
+        if "_id" in doc:
+            doc["_id"] = str(doc["_id"])
+        
+        try:
+            listing = Listing(**doc)
+            result = listing.model_dump(by_alias=True)
+            
+            print(f"  --- After Pydantic ---")
+            print(f"  address (serialized): {result.get('address')}")
+            print(f"  latitude (serialized): {result.get('latitude')}")
+            print(f"  longitude (serialized): {result.get('longitude')}")
+        except Exception as e:
+            print(f"  ERROR: {e}")
+        
+        print()
+
+if __name__ == "__main__":
+    asyncio.run(check_listings())

check_qdrant_info.py

@@ -0,0 +1,23 @@
+
+import asyncio
+import os
+from qdrant_client import AsyncQdrantClient
+from dotenv import load_dotenv
+
+load_dotenv()
+
+QDRANT_URL = os.getenv("QDRANT_URL")
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
+
+async def check():
+    client = AsyncQdrantClient(url=QDRANT_URL, api_key=QDRANT_API_KEY)
+    try:
+        info = await client.get_collection("listings")
+        print(f"Collection: listings")
+        print(f"Vector size: {info.config.params.vectors.size}")
+        print(f"Points count: {info.points_count}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(check())

fix_failed_listing.py

@@ -0,0 +1,34 @@
+"""Fix the one failed listing by geocoding just the city"""
+import asyncio
+from app.database import connect_db, get_db
+from app.ai.tools.listing_tool import geocode_address
+from bson import ObjectId
+
+async def fix_failed_listing():
+    await connect_db()
+    db = await get_db()
+    
+    # Find the specific listing
+    listing_id = "694402f3947fa344b4462fce"
+    
+    print("🔍 Geocoding Cotonou (city only)...")
+    geo_result = await geocode_address("Cotonou", None)
+    
+    if geo_result.get("success"):
+        lat = geo_result.get("latitude")
+        lon = geo_result.get("longitude")
+        
+        result = await db.listings.update_one(
+            {"_id": ObjectId(listing_id)},
+            {"$set": {"latitude": lat, "longitude": lon}}
+        )
+        
+        if result.modified_count > 0:
+            print(f"✅ Updated: lat={lat}, lon={lon}")
+        else:
+            print("⚠️ No change made")
+    else:
+        print(f"❌ Failed: {geo_result.get('error')}")
+
+if __name__ == "__main__":
+    asyncio.run(fix_failed_listing())

migrate_to_4096.py

@@ -56,6 +56,12 @@ async def embed(text: str) -> List[float]:
 # ------------------------------------------------------------------
 # Main migration function
 # ------------------------------------------------------------------
+def get_deterministic_uuid(mongo_id: str) -> str:
+    """Generate a deterministic UUID from a MongoDB ObjectId string."""
+    from uuid import UUID
+    padded_hex = mongo_id.zfill(32)
+    return str(UUID(hex=padded_hex))
+
 async def rebuild():
     """Delete old collection, create new 4096-D collection with indexed fields, and migrate all documents."""
     try:
@@ -158,7 +164,8 @@ async def rebuild():
             "currency": doc.get("currency", "XOF"),
         }
 
-        batch.append(models.PointStruct(id=str(uuid4()), vector=vector, payload=payload))
+        point_id = get_deterministic_uuid(str(doc["_id"]))
+        batch.append(models.PointStruct(id=point_id, vector=vector, payload=payload))
 
         # Upload batch when it reaches BATCH_SIZE
         if len(batch) >= BATCH_SIZE:

sync_all_listings_to_qdrant.py

@@ -0,0 +1,193 @@
+"""
+Full Sync Script: MongoDB → Qdrant
+===================================
+Syncs ALL active listings from MongoDB to Qdrant with complete data including images.
+This creates new points in Qdrant for listings that don't exist yet.
+
+Usage:
+    python sync_all_listings_to_qdrant.py
+"""
+
+import asyncio
+from motor.motor_asyncio import AsyncIOMotorClient
+from qdrant_client import QdrantClient
+from qdrant_client.models import PointStruct
+from structlog import get_logger
+import os
+from dotenv import load_dotenv
+from uuid import UUID
+import httpx
+
+# Load environment variables
+load_dotenv()
+
+logger = get_logger(__name__)
+
+# Configuration
+MONGO_URI = os.getenv("MONGODB_URL")
+if not MONGO_URI:
+    raise ValueError("MONGODB_URL environment variable not set in .env file")
+
+MONGO_DB = os.getenv("MONGODB_DATABASE", "lojiz")
+QDRANT_URL = os.getenv("QDRANT_URL")
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+
+if not QDRANT_URL or not QDRANT_API_KEY:
+    raise ValueError("QDRANT_URL and QDRANT_API_KEY must be set in .env")
+
+if not OPENROUTER_API_KEY:
+    raise ValueError("OPENROUTER_API_KEY must be set in .env for embeddings")
+
+COLLECTION_NAME = "listings"
+EMBED_MODEL = "qwen/qwen3-embedding-8b"
+
+
+def get_deterministic_uuid(mongo_id: str) -> str:
+    """Convert MongoDB ObjectId to deterministic UUID for Qdrant."""
+    import hashlib
+    hash_bytes = hashlib.md5(mongo_id.encode()).digest()
+    return str(UUID(bytes=hash_bytes))
+
+
+async def embed_query(text: str) -> list:
+    """Create embedding using OpenRouter."""
+    async with httpx.AsyncClient(timeout=30) as client:
+        payload = {
+            "model": EMBED_MODEL,
+            "input": text,
+            "encoding_format": "float"
+        }
+        headers = {
+            "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+            "Content-Type": "application/json",
+        }
+        
+        response = await client.post(
+            "https://openrouter.ai/api/v1/embeddings",
+            json=payload,
+            headers=headers
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        return data["data"][0]["embedding"]
+
+
+async def sync_all_listings():
+    """Sync all active listings from MongoDB to Qdrant."""
+    
+    # Connect to MongoDB
+    mongo_client = AsyncIOMotorClient(MONGO_URI)
+    db = mongo_client[MONGO_DB]
+    
+    # Connect to Qdrant
+    qdrant_client = QdrantClient(
+        url=QDRANT_URL,
+        api_key=QDRANT_API_KEY,
+        timeout=60
+    )
+    
+    try:
+        # Fetch all active listings from MongoDB
+        cursor = db.listings.find({"status": "active"})
+        listings = await cursor.to_list(length=None)
+        
+        total = len(listings)
+        logger.info(f"Found {total} active listings to sync")
+        
+        synced = 0
+        skipped = 0
+        errors = 0
+        
+        for idx, listing in enumerate(listings, 1):
+            mongo_id = str(listing["_id"])
+            point_id = get_deterministic_uuid(mongo_id)
+            
+            try:
+                # Build text for embedding
+                bedrooms = listing.get("bedrooms") or 0
+                location = listing.get("location") or ""
+                address = listing.get("address") or ""
+                title = listing.get("title") or ""
+                description = listing.get("description") or ""
+                
+                text = f"{title}. {bedrooms}-bed in {location} ({address}). {description}".strip()
+                
+                # Generate embedding
+                print(f"[{idx}/{total}] Generating embedding for: {title[:50]}...")
+                vector = await embed_query(text)
+                
+                # Prepare payload
+                price_type = listing.get("price_type") or ""
+                listing_type = listing.get("listing_type") or listing.get("type") or ""
+                
+                payload = {
+                    "mongo_id": mongo_id,
+                    "title": title,
+                    "description": description,
+                    "location": location,
+                    "location_lower": location.lower() if location else "",
+                    "address": address,
+                    "price": float(listing.get("price") or 0),
+                    "price_type": price_type,
+                    "price_type_lower": price_type.lower() if price_type else "",
+                    "listing_type": listing_type,
+                    "listing_type_lower": listing_type.lower() if listing_type else "",
+                    "bedrooms": int(bedrooms),
+                    "bathrooms": int(listing.get("bathrooms") or 0),
+                    "amenities": [a.lower() for a in (listing.get("amenities") or [])],
+                    "currency": listing.get("currency", "XOF"),
+                    "status": listing.get("status", "active"),
+                    "latitude": listing.get("latitude"),
+                    "longitude": listing.get("longitude"),
+                    "images": listing.get("images", []),  # ✅ Include images
+                }
+                
+                # Upsert point to Qdrant
+                qdrant_client.upsert(
+                    collection_name=COLLECTION_NAME,
+                    points=[
+                        PointStruct(
+                            id=point_id,
+                            vector=vector,
+                            payload=payload
+                        )
+                    ]
+                )
+                
+                synced += 1
+                logger.info(
+                    f"[{idx}/{total}] ✅ Synced",
+                    mongo_id=mongo_id,
+                    title=title[:30],
+                    images_count=len(listing.get("images", []))
+                )
+                
+            except Exception as e:
+                errors += 1
+                logger.error(
+                    f"[{idx}/{total}] ❌ Failed",
+                    mongo_id=mongo_id,
+                    error=str(e)
+                )
+        
+        # Summary
+        print("\n" + "="*60)
+        print("SYNC COMPLETE")
+        print("="*60)
+        print(f"Total listings:  {total}")
+        print(f"✅ Synced:       {synced}")
+        print(f"⚠️  Skipped:      {skipped}")
+        print(f"❌ Errors:       {errors}")
+        print("="*60)
+        
+    finally:
+        mongo_client.close()
+        qdrant_client.close()
+
+
+if __name__ == "__main__":
+    print("Starting full sync from MongoDB to Qdrant...")
+    print("This will create embeddings for all listings (may take a few minutes)...\n")
+    asyncio.run(sync_all_listings())

test_chat_ui.html

@@ -274,7 +274,17 @@
             width: 100%;
             height: 200px;
             object-fit: cover;
-            display: block;
+            transition: opacity 0.3s ease;
+        }
+
+        .listing-draft img.hero.hidden {
+            display: none;
+        }
+
+        .listing-draft .draft-image-container {
+            position: relative;
+            height: 200px;
+            overflow: hidden;
         }
 
         .listing-draft .content {
@@ -382,11 +392,15 @@
             width: 100%;
             height: 100%;
             object-fit: cover;
-            transition: transform 0.3s ease;
+            transition: opacity 0.3s ease;
+        }
+
+        .search-card-hero.hidden {
+            display: none;
         }
 
         .search-result-card:hover .search-card-hero {
-            transform: scale(1.05);
+            opacity: 0.95;
         }
 
         .search-card-type {
@@ -528,6 +542,11 @@
             width: 100%;
             height: 100%;
             object-fit: cover;
+            transition: opacity 0.3s ease;
+        }
+
+        .my-listing-card-image img.hidden {
+            display: none;
         }
 
         .my-listing-card-content {
@@ -596,6 +615,45 @@
             opacity: 0.5;
             cursor: not-allowed;
         }
+
+        /* ============================================================
+           IMAGE CAROUSEL - DOT INDICATORS
+           ============================================================ */
+        .carousel-dots {
+            position: absolute;
+            bottom: 10px;
+            left: 50%;
+            transform: translateX(-50%);
+            display: flex;
+            gap: 6px;
+            z-index: 10;
+            background: rgba(0, 0, 0, 0.3);
+            padding: 6px 10px;
+            border-radius: 20px;
+            backdrop-filter: blur(4px);
+        }
+
+        .carousel-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            background: rgba(255, 255, 255, 0.5);
+            cursor: pointer;
+            transition: all 0.3s ease;
+            border: 1px solid rgba(255, 255, 255, 0.3);
+        }
+
+        .carousel-dot:hover {
+            background: rgba(255, 255, 255, 0.8);
+            transform: scale(1.2);
+        }
+
+        .carousel-dot.active {
+            background: white;
+            width: 24px;
+            border-radius: 10px;
+            border: 1px solid rgba(255, 255, 255, 0.8);
+        }
     </style>
 </head>
 
@@ -681,12 +739,29 @@
                 </div>
             </div>
 
+            <!-- Image Preview Area -->
+            <div id="image-preview-container"
+                style="display:none; padding: 10px 20px; background: #f0f9ff; border-top: 1px solid #e0f2fe;">
+                <div style="position: relative; display: inline-block;">
+                    <img id="image-preview" src=""
+                        style="height: 80px; width: auto; border-radius: 8px; border: 2px solid #3b82f6; object-fit: cover;">
+                    <button onclick="clearImage()"
+                        style="position: absolute; top: -10px; right: -10px; background: #ef4444; color: white; border: 2px solid white; border-radius: 50%; width: 24px; height: 24px; cursor: pointer; display: flex; align-items: center; justify-content: center; font-size: 12px; font-weight: bold; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">✕</button>
+                </div>
+                <div
+                    style="display: inline-block; vertical-align: top; margin-left: 10px; margin-top: 25px; color: #3b82f6; font-size: 0.9rem; font-weight: 500;">
+                    Image ready to send
+                </div>
+            </div>
+
             <div class="input-area">
+                <input type="file" id="file-input" accept="image/*" style="display: none;"
+                    onchange="handleFileSelect(this)">
                 <input type="text" id="message-input" placeholder="Type your message..."
                     onkeypress="if(event.key === 'Enter') sendMessage()">
                 <button onclick="sendMessage()" style="width: auto;">Send</button>
-                <button onclick="uploadImage()" class="secondary" style="width: auto; background-color: #f59e0b;">📷
-                    Upload Image</button>
+                <button onclick="triggerFileSelect()" class="secondary" style="width: auto; background-color: #f59e0b;"
+                    title="Upload Image">📷</button>
             </div>
 
             <!-- Typing Indicator (Hidden by default) -->
@@ -705,6 +780,11 @@
         let currentSessionId = '';
         // Use 127.0.0.1 to avoid localhost DNS/Av issues
         const API_BASE = 'http://127.0.0.1:8000';
+        // CLOUDFLARE WORKER URL (Replace with your actual deployed Worker URL)
+        const CF_WORKER_URL = "https://lojiz-worker.lojiz-uploadapi.workers.dev"; // UPDATE THIS!
+
+        // Image Upload State
+        let pendingUploadFile = null;
 
         // Init
         window.onload = function () {
@@ -725,6 +805,34 @@
             });
         }
 
+        // Image Handling Functions
+        function triggerFileSelect() {
+            document.getElementById('file-input').click();
+        }
+
+        function handleFileSelect(input) {
+            if (input.files && input.files[0]) {
+                const file = input.files[0];
+                pendingUploadFile = file;
+
+                // Show preview
+                const reader = new FileReader();
+                reader.onload = function (e) {
+                    document.getElementById('image-preview').src = e.target.result;
+                    document.getElementById('image-preview-container').style.display = 'block';
+                    // Focus input so user can type message immediately
+                    document.getElementById('message-input').focus();
+                }
+                reader.readAsDataURL(file);
+            }
+        }
+
+        function clearImage() {
+            pendingUploadFile = null;
+            document.getElementById('file-input').value = '';
+            document.getElementById('image-preview-container').style.display = 'none';
+        }
+
         // Image URL Regex
         const IMG_URL_REGEX = /(https?:\/\/.*\.(?:png|jpg|jpeg|gif|webp|svg))/i;
 
@@ -766,30 +874,34 @@
             el.textContent = JSON.stringify(data, null, 2);
         }
 
-        function addMessage(role, text, debugInfo = null) {
+        function addMessage(role, text, debugInfo = null, isHtml = false) {
             const history = document.getElementById('chat-history');
             const div = document.createElement('div');
             div.className = `message ${role}`;
 
             let html = `<div class="meta">${role === 'user' ? 'You' : 'AIDA'}</div>`;
 
-            // Check for image URL to render it
-            const imgMatch = text.match(IMG_URL_REGEX);
-            if (imgMatch) {
-                // If text contains an image URL, render the image + the text (if it's not JUST the url)
-                const url = imgMatch[0];
-                const textWithoutUrl = text.replace(url, '').trim();
-
-                html += `<div style="margin-bottom:8px;">
-                            <img src="${url}" style="max-width:100%; border-radius:8px; display:block;" alt="Uploaded Image" onerror="this.style.display='none'">
-                         </div>`;
-
-                if (textWithoutUrl) {
-                    html += `<div>${formatMarkdown(textWithoutUrl)}</div>`;
-                }
+            if (isHtml) {
+                html += `<div>${text}</div>`;
             } else {
-                // Always show the actual text from the response (personalized by LLM)
-                html += `<div>${formatMarkdown(text)}</div>`;
+                // Check for image URL to render it
+                const imgMatch = text.match(IMG_URL_REGEX);
+                if (imgMatch) {
+                    // If text contains an image URL, render the image + the text (if it's not JUST the url)
+                    const url = imgMatch[0];
+                    const textWithoutUrl = text.replace(url, '').trim();
+
+                    html += `<div style="margin-bottom:8px;">
+                                <img src="${url}" style="max-width:100%; border-radius:8px; display:block;" alt="Uploaded Image" onerror="this.style.display='none'">
+                             </div>`;
+
+                    if (textWithoutUrl) {
+                        html += `<div>${formatMarkdown(textWithoutUrl)}</div>`;
+                    }
+                } else {
+                    // Always show the actual text from the response (personalized by LLM)
+                    html += `<div>${formatMarkdown(text)}</div>`;
+                }
             }
 
             // Handle draft_ui: Message + Card appear as ONE UNIT
@@ -842,18 +954,36 @@
 
         // NEW: Render card WITH message as ONE unit
         function renderDraftWithMessage(draft, message) {
-            const heroImage = (draft.images && draft.images.length > 0) ? draft.images[0] : 'https://via.placeholder.com/400x200?text=No+Image';
+            const images = (draft.images && draft.images.length > 0) ? draft.images : ['https://via.placeholder.com/400x200?text=No+Image'];
+            const cardId = 'draft-' + Date.now();
 
             let amenitiesHtml = '';
             if (draft.amenities && draft.amenities.length > 0) {
                 amenitiesHtml = '<div class="amenities">' + draft.amenities.map(a => `<span class="pill">${a}</span>`).join('') + '</div>';
             }
 
+            // Build image carousel HTML
+            const imagesHtml = images.map((img, idx) =>
+                `<img src="${img}" class="hero ${idx === 0 ? '' : 'hidden'}" alt="Listing Image ${idx + 1}" data-index="${idx}">`
+            ).join('');
+
+            // Build dots HTML (only if more than 1 image)
+            let dotsHtml = '';
+            if (images.length > 1) {
+                const dots = images.map((_, idx) =>
+                    `<span class="carousel-dot ${idx === 0 ? 'active' : ''}" onclick="switchImage('${cardId}', ${idx})" data-index="${idx}"></span>`
+                ).join('');
+                dotsHtml = `<div class="carousel-dots">${dots}</div>`;
+            }
+
             return `
             <div class="listing-card-unit">
                 <div class="card-message">${formatMarkdown(message)}</div>
-                <div class="listing-draft" id="listing-draft-preview">
-                    <img src="${heroImage}" class="hero" alt="Listing Image">
+                <div class="listing-draft" id="${cardId}">
+                    <div class="draft-image-container">
+                        ${imagesHtml}
+                        ${dotsHtml}
+                    </div>
                     <div class="content">
                         <h3>${draft.title}</h3>
                         <p>${draft.description}</p>
@@ -943,7 +1073,7 @@
         function renderSearchResults(results) {
             if (!results || results.length === 0) return '';
 
-            const cards = results.map(listing => {
+            const cards = results.map((listing, cardIdx) => {
                 const title = listing.title || 'Untitled Property';
                 const description = listing.description || 'A beautiful property waiting to be explored.';
                 const location = listing.location || 'Unknown';
@@ -956,11 +1086,12 @@
                 const relevance = listing._relevance_score;
                 const amenities = listing.amenities || [];
 
-                // Get hero image (first image or placeholder)
-                const images = listing.images || [];
-                const heroImage = images.length > 0
-                    ? images[0]
-                    : 'https://images.unsplash.com/photo-1560518883-ce09059eeffa?w=400&h=200&fit=crop';
+                // Get all images or use placeholder
+                const images = (listing.images && listing.images.length > 0)
+                    ? listing.images
+                    : ['https://images.unsplash.com/photo-1560518883-ce09059eeffa?w=400&h=200&fit=crop'];
+
+                const cardId = 'search-card-' + Date.now() + '-' + cardIdx;
 
                 // Truncate description to 2 lines
                 const shortDesc = description.length > 100
@@ -984,12 +1115,27 @@
                     relevanceBadge = `<span class="search-relevance-badge">⭐ ${percent}% match</span>`;
                 }
 
+                // Build image carousel HTML
+                const imagesHtml = images.map((img, idx) =>
+                    `<img src="${img}" class="search-card-hero ${idx === 0 ? '' : 'hidden'}" alt="${title}" data-index="${idx}" onerror="this.src='https://via.placeholder.com/400x180?text=Property'">`
+                ).join('');
+
+                // Build dots HTML (only if more than 1 image)
+                let dotsHtml = '';
+                if (images.length > 1) {
+                    const dots = images.map((_, idx) =>
+                        `<span class="carousel-dot ${idx === 0 ? 'active' : ''}" onclick="switchImage('${cardId}', ${idx})" data-index="${idx}"></span>`
+                    ).join('');
+                    dotsHtml = `<div class="carousel-dots">${dots}</div>`;
+                }
+
                 return `
-                <div class="search-result-card">
+                <div class="search-result-card" id="${cardId}">
                     <div class="search-card-image-container">
-                        <img src="${heroImage}" class="search-card-hero" alt="${title}" onerror="this.src='https://via.placeholder.com/400x180?text=Property'">
+                        ${imagesHtml}
                         <span class="search-card-type">${listingType}</span>
                         ${relevanceBadge}
+                        ${dotsHtml}
                     </div>
                     <div class="search-card-content">
                         <h3 class="search-card-title">${title}</h3>
@@ -1025,20 +1171,38 @@
                 return '';
             }
 
-            const cards = listings.map(listing => {
+            const cards = listings.map((listing, cardIdx) => {
                 const id = listing._id || listing.id || '';
                 const title = listing.title || 'Untitled';
                 const location = listing.location || 'Unknown Location';
                 const price = (listing.price || 0).toLocaleString();
                 const currency = listing.currency || 'XOF';
                 const priceType = listing.price_type || 'monthly';
-                const images = listing.images || [];
-                const heroImage = images.length > 0 ? images[0] : 'https://via.placeholder.com/400x140?text=Property';
+                const images = (listing.images && listing.images.length > 0)
+                    ? listing.images
+                    : ['https://via.placeholder.com/400x140?text=Property'];
+
+                const cardId = 'my-listing-' + Date.now() + '-' + cardIdx;
+
+                // Build image carousel HTML
+                const imagesHtml = images.map((img, idx) =>
+                    `<img src="${img}" alt="${title}" class="${idx === 0 ? '' : 'hidden'}" data-index="${idx}" onerror="this.src='https://via.placeholder.com/400x140?text=Property'">`
+                ).join('');
+
+                // Build dots HTML (only if more than 1 image)
+                let dotsHtml = '';
+                if (images.length > 1) {
+                    const dots = images.map((_, idx) =>
+                        `<span class="carousel-dot ${idx === 0 ? 'active' : ''}" onclick="switchImage('${cardId}', ${idx})" data-index="${idx}"></span>`
+                    ).join('');
+                    dotsHtml = `<div class="carousel-dots">${dots}</div>`;
+                }
 
                 return `
-                <div class="my-listing-card" data-listing-id="${id}">
+                <div class="my-listing-card" id="${cardId}" data-listing-id="${id}">
                     <div class="my-listing-card-image">
-                        <img src="${heroImage}" alt="${title}" onerror="this.src='https://via.placeholder.com/400x140?text=Property'">
+                        ${imagesHtml}
+                        ${dotsHtml}
                     </div>
                     <div class="my-listing-card-content">
                         <h4 class="my-listing-card-title">${title}</h4>
@@ -1118,6 +1282,8 @@
             // Get user details from DOM inputs (set during login)
             const currentUserId = document.getElementById('user-id').value;
             const currentUserRole = document.getElementById('user-role').value;
+            // Use the same session-id source as sendMessage for consistency
+            const sessionId = document.getElementById('session-id').value || currentSessionId;
 
             // Show user message
             addMessage('user', `✏️ Edit listing`);
@@ -1131,7 +1297,7 @@
                     },
                     body: JSON.stringify({
                         message: editMessage,
-                        session_id: currentSessionId,
+                        session_id: sessionId,
                         user_id: currentUserId,
                         user_role: currentUserRole,
                         user_name: userName,
@@ -1141,6 +1307,13 @@
 
                 const data = await res.json();
 
+                // Sync session_id from response to keep edit context
+                if (data.session_id) {
+                    currentSessionId = data.session_id;
+                    document.getElementById('session-id').value = data.session_id;
+                    console.log('Session ID synced from response:', data.session_id);
+                }
+
                 if (data.text) {
                     addMessage('assistant', data.text, data);
                 } else {
@@ -1248,22 +1421,96 @@
         async function sendMessage() {
             const input = document.getElementById('message-input');
             const text = input.value.trim();
-            if (!text) return;
+            const hasImage = pendingUploadFile !== null;
+
+            if (!text && !hasImage) return;
 
             // Use manual token if provided
             const manualToken = document.getElementById('manual-token').value.trim();
             const effectiveToken = manualToken || authToken;
 
             input.value = '';
-            addMessage('user', text);
+
+            // Show user message immediately
+            if (hasImage) {
+                // Show text + "Uploading image..." status or similar
+                let displayMsg = text;
+                const previewSrc = document.getElementById('image-preview').src;
+                displayMsg += `<br><img src="${previewSrc}" style="max-height:150px; border-radius:8px; margin-top:5px; opacity: 0.7;">`;
+                displayMsg += `<div style="font-size:0.8em; color:#666;">Uploading image to Cloudflare...</div>`;
+                addMessage('user', displayMsg, null, true);
+            } else {
+                addMessage('user', text);
+            }
+
+            // Get session info
+            const sessionId = document.getElementById('session-id').value;
+            const userId = document.getElementById('user-id').value || undefined;
+            const userRole = document.getElementById('user-role').value;
+            const userNameVal = userName || undefined;
+            const userLocVal = userLocation || undefined;
+
+            // Show typing indicator
+            const typingEl = document.getElementById('typing-indicator');
+            // ... (rest of typing indicator logic handled in UI usually, but we'll adapt)
+
+            // ===================================
+            // PATH A: Image Upload Flow
+            // ===================================
+            if (hasImage) {
+                try {
+                    // Prepare FormData for Cloudflare Worker
+                    const formData = new FormData();
+                    formData.append('file', pendingUploadFile);
+                    formData.append('message', text); // Attach user command
+                    formData.append('user_id', userId || 'anon');
+                    formData.append('session_id', sessionId);
+                    formData.append('operation', 'add'); // Default to add, can be improved later
+
+                    // Clear pending image
+                    const fileToUpload = pendingUploadFile; // Keep ref
+                    clearImage();
+
+                    // Upload to Cloudflare Worker
+                    const cfRes = await fetch(CF_WORKER_URL, {
+                        method: 'POST',
+                        body: formData // No headers needed for FormData
+                    });
+
+                    const cfData = await cfRes.json();
+
+                    // Whether success or error, send result to AIDA to handle
+                    // The Worker returns {success: true/false, ...} which matches AIDA's expectation
+                    const aidaRes = await fetch(`${API_BASE}/ai/image-upload-result`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            ...(effectiveToken ? { 'Authorization': `Bearer ${effectiveToken}` } : {})
+                        },
+                        body: JSON.stringify(cfData)
+                    });
+
+                    const aidaData = await aidaRes.json();
+                    handleAidaResponse(aidaData);
+
+                } catch (e) {
+                    console.error("Upload Error:", e);
+                    addMessage('assistant', `❌ Upload Error: ${e.message}. Is the Cloudflare Worker URL correct?`);
+                }
+                return;
+            }
+
+            // ===================================
+            // PATH B: Standard Text Message Flow
+            // ===================================
 
             const payload = {
                 message: text,
-                session_id: document.getElementById('session-id').value,
-                user_id: document.getElementById('user-id').value || undefined,
-                user_role: document.getElementById('user-role').value,
-                user_name: userName || undefined,
-                user_location: userLocation || undefined
+                session_id: sessionId,
+                user_id: userId,
+                user_role: userRole,
+                user_name: userNameVal,
+                user_location: userLocVal
             };
 
             const headers = {
@@ -1275,9 +1522,6 @@
             }
 
             updateDebug({ status: 'Sending...', payload });
-
-            // Show typing indicator
-            const typingEl = document.getElementById('typing-indicator');
             const chatHistory = document.getElementById('chat-history');
 
             // Move typing indicator to inside chat history temporarily or just toggle it
@@ -1317,40 +1561,22 @@
                 if (data.metadata && data.metadata.replace_last_message) {
                     console.log('[UI] Replace last message signal received');
 
-                    // For edit flow: Remove the old card-message unit entirely
-                    // Then use addMessage to create a new one at the bottom
-                    // This ensures both message AND card update correctly
-
                     if (data.draft_ui) {
-                        // Find and remove the entire old card-message unit
                         const existingCardUnit = document.querySelector('.listing-card-unit');
                         if (existingCardUnit) {
                             const parentMessageDiv = existingCardUnit.closest('.message');
                             if (parentMessageDiv) {
                                 parentMessageDiv.remove();
-                                console.log('[UI] Old card-message unit removed');
                             } else {
                                 existingCardUnit.remove();
                             }
                         }
                     }
-
-                    // Now use addMessage to create the proper response (with card if present)
-                    const text = data.text || data.message || '';
-                    addMessage('ai', text, data);
-                    console.log('[UI] New message (with card if present) added at bottom');
-
-                } else {
-                    // Standard append
-                    if (data.text) {
-                        addMessage('ai', data.text, data);
-                    } else if (data.message) {
-                        addMessage('ai', data.message, data);
-                    } else {
-                        addMessage('ai', JSON.stringify(data), data);
-                    }
                 }
 
+                // Use the shared handler
+                handleAidaResponse(data);
+
             } catch (e) {
                 // Remove typing indicator on error
                 const typingNode = document.getElementById(tempTypingId);
@@ -1361,184 +1587,37 @@
             }
         }
 
-        async function uploadImage() {
-            // Trigger hidden file input
-            let fileInput = document.getElementById('hidden-file-input');
-            if (!fileInput) {
-                fileInput = document.createElement('input');
-                fileInput.type = 'file';
-                fileInput.id = 'hidden-file-input';
-                fileInput.accept = 'image/*';
-                fileInput.style.display = 'none';
-                document.body.appendChild(fileInput);
+        // Shared Response Handler
+        function handleAidaResponse(data) {
+            // Remove any temp typing indicators
+            const indicators = document.querySelectorAll('[id^="temp-typing-"]');
+            indicators.forEach(el => el.remove());
 
-                fileInput.addEventListener('change', handleFileSelect);
+            // Sync session_id from response to keep context (especially for edit mode)
+            if (data.session_id) {
+                currentSessionId = data.session_id;
+                document.getElementById('session-id').value = data.session_id;
             }
-            fileInput.click();
-        }
 
-        async function handleFileSelect(event) {
-            const file = event.target.files[0];
-            if (!file) return;
-
-            const history = document.getElementById('chat-history');
-
-            // Create local preview URL immediately
-            const localPreviewUrl = URL.createObjectURL(file);
-
-            // Create a unique ID for this upload message
-            const uploadMsgId = 'upload-' + Date.now();
-
-            // Show user message with image preview + loading overlay
-            const previewHtml = `
-                <div id="${uploadMsgId}" class="message user">
-                    <div class="meta">You</div>
-                    <div style="position: relative; display: inline-block; max-width: 300px;">
-                        <img id="${uploadMsgId}-img" src="${localPreviewUrl}" 
-                             style="max-width: 100%; border-radius: 8px; display: block; opacity: 0.7;" 
-                             alt="Uploading...">
-                        <div id="${uploadMsgId}-overlay" style="
-                            position: absolute; 
-                            top: 0; left: 0; right: 0; bottom: 0;
-                            background: rgba(0,0,0,0.4);
-                            display: flex; align-items: center; justify-content: center;
-                            border-radius: 8px;
-                            color: white; font-weight: 500;
-                        ">
-                            <span>⏳ Uploading...</span>
-                        </div>
-                    </div>
-                    <div style="font-size: 0.85rem; color: #64748b; margin-top: 4px;">
-                        📷 Property image
-                    </div>
-                </div>`;
-
-            history.insertAdjacentHTML('beforeend', previewHtml);
-            history.scrollTop = history.scrollHeight;
-
-            const formData = new FormData();
-            formData.append('file', file);
-
-            try {
-                const response = await fetch('https://lojiz-worker.lojiz-uploadapi.workers.dev/', {
-                    method: 'POST',
-                    body: formData
-                });
-
-                if (!response.ok) {
-                    throw new Error(`Upload failed: ${response.status}`);
-                }
-
-                const result = await response.json();
-                console.log("Upload result:", result);
-
-                let imageUrl = result.url || result.secure_url || result.data?.url || result.imageUrl;
-
-                if (!imageUrl && typeof result === 'string' && result.startsWith('http')) {
-                    imageUrl = result;
-                }
-
-                if (imageUrl) {
-                    // Update the preview: remove overlay, set final image, full opacity
-                    const imgEl = document.getElementById(`${uploadMsgId}-img`);
-                    const overlayEl = document.getElementById(`${uploadMsgId}-overlay`);
-
-                    if (imgEl) {
-                        imgEl.src = imageUrl;
-                        imgEl.style.opacity = '1';
-                    }
-                    if (overlayEl) {
-                        overlayEl.innerHTML = '✅';
-                        setTimeout(() => overlayEl.remove(), 1000);
-                    }
-
-                    // Revoke the local URL to free memory
-                    URL.revokeObjectURL(localPreviewUrl);
-
-                    // Send the image URL to AIDA (hidden from user display since image is already shown)
-                    const message = `Here is the image of the property: ${imageUrl}`;
-
-                    // Don't show another user message, just send to backend
-                    await sendImageToAi(message);
-                } else {
-                    throw new Error("Could not extract image URL from response");
-                }
-
-            } catch (e) {
-                console.error("Upload failed:", e);
-
-                // Update overlay to show error
-                const overlayEl = document.getElementById(`${uploadMsgId}-overlay`);
-                if (overlayEl) {
-                    overlayEl.innerHTML = '❌ Failed';
-                    overlayEl.style.background = 'rgba(220, 38, 38, 0.7)';
-                }
-
-                URL.revokeObjectURL(localPreviewUrl);
-            }
-
-            // Clear file input
-            event.target.value = '';
-        }
-
-        // Send image URL to AI without showing duplicate user message
-        async function sendImageToAi(message) {
-            const manualToken = document.getElementById('manual-token').value.trim();
-            const effectiveToken = manualToken || authToken;
-
-            const payload = {
-                message: message,
-                session_id: document.getElementById('session-id').value,
-                user_id: document.getElementById('user-id').value || undefined,
-                user_role: document.getElementById('user-role').value
-            };
-
-            const headers = { 'Content-Type': 'application/json' };
-            if (effectiveToken) {
-                headers['Authorization'] = `Bearer ${effectiveToken}`;
-            }
-
-            // Show typing indicator
-            const history = document.getElementById('chat-history');
-            const tempTypingId = 'temp-typing-' + Date.now();
-            const typingHtml = `
-                <div id="${tempTypingId}" class="message ai" style="display:flex; align-items:center; gap:8px;">
-                    <div class="meta">AIDA</div>
-                    <div style="display:flex; gap:4px; align-items:center;">
-                        <span>Processing image</span>
-                        <div class="typing-dot"></div>
-                        <div class="typing-dot"></div>
-                        <div class="typing-dot"></div>
-                    </div>
-                </div>`;
-            history.insertAdjacentHTML('beforeend', typingHtml);
-            history.scrollTop = history.scrollHeight;
-
-            try {
-                const res = await fetch(`${API_BASE}/ai/ask`, {
-                    method: 'POST',
-                    headers: headers,
-                    body: JSON.stringify(payload)
-                });
-
-                const data = await res.json();
-
-                // Remove typing indicator
-                const typingNode = document.getElementById(tempTypingId);
-                if (typingNode) typingNode.remove();
+            if (data.metadata && data.metadata.replace_last_message) {
+                // Logic already handled in sendMessage mostly for removing, but let's ensure addMessage works
+                // Just use addMessage
+                const text = data.text || data.message || '';
+                addMessage('ai', text, data);
 
+            } else {
+                // Standard append
                 if (data.text) {
                     addMessage('ai', data.text, data);
                 } else if (data.message) {
                     addMessage('ai', data.message, data);
+                } else {
+                    addMessage('ai', JSON.stringify(data), data);
                 }
-            } catch (e) {
-                const typingNode = document.getElementById(tempTypingId);
-                if (typingNode) typingNode.remove();
-                addMessage('ai', 'Error processing image: ' + e.message);
             }
         }
 
+
         function newConversation() {
             currentSessionId = generateUUID();
             document.getElementById('session-id').value = currentSessionId;
@@ -1553,6 +1632,34 @@
 
             updateDebug({ status: 'New conversation started', session_id: currentSessionId });
         }
+
+        // Image Carousel Navigation
+        function switchImage(cardId, targetIndex) {
+            const card = document.getElementById(cardId);
+            if (!card) return;
+
+            // Find all images in this card
+            const images = card.querySelectorAll('img[data-index]');
+            const dots = card.querySelectorAll('.carousel-dot');
+
+            // Hide all images and show the target one
+            images.forEach((img, idx) => {
+                if (idx === targetIndex) {
+                    img.classList.remove('hidden');
+                } else {
+                    img.classList.add('hidden');
+                }
+            });
+
+            // Update dot states
+            dots.forEach((dot, idx) => {
+                if (idx === targetIndex) {
+                    dot.classList.add('active');
+                } else {
+                    dot.classList.remove('active');
+                }
+            });
+        }
     </script>
 
 </body>

test_listing_fields.py

@@ -0,0 +1,40 @@
+"""Quick test to verify listing serialization"""
+import asyncio
+from app.models.listing import Listing
+
+def test_serialization():
+    # Test with address and coordinates
+    doc = {
+        'user_id': '123',
+        'listing_type': 'rent',
+        'title': 'Test Property',
+        'description': 'Test description for property',
+        'price': 100000,
+        'price_type': 'monthly',
+        'location': 'Lagos',
+        'address': 'Victoria Island, Lagos',
+        'latitude': 6.4281,
+        'longitude': 3.4219,
+        'status': 'active'
+    }
+    
+    listing = Listing(**doc)
+    
+    print("=== Listing Object Fields ===")
+    print(f"address: {listing.address}")
+    print(f"latitude: {listing.latitude}")
+    print(f"longitude: {listing.longitude}")
+    
+    print("\n=== listing.dict(by_alias=True) ===")
+    result = listing.dict(by_alias=True)
+    print(f"address in result: {'address' in result}")
+    print(f"address value: {result.get('address')}")
+    print(f"latitude value: {result.get('latitude')}")
+    print(f"longitude value: {result.get('longitude')}")
+    
+    print("\n=== Full Result ===")
+    for key in ['address', 'latitude', 'longitude', 'location']:
+        print(f"  {key}: {result.get(key)}")
+
+if __name__ == "__main__":
+    test_serialization()