fyp

HOW_TO_RUN.md

@@ -0,0 +1,58 @@
+# How to Run AIDA Agent for Testing
+
+## 1. Start the Backend Server
+
+In the AIDA directory, run:
+
+```bash
+python -m uvicorn main:app --reload
+```
+
+**Note:** Use `main:app` not `app.main:app` (main.py is in the root, not in the app folder)
+
+The server will start on `http://127.0.0.1:8000`
+
+You should see:
+```
+INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+INFO:     Started reloader process [xxxx] using WatchFiles
+```
+
+## 2. Open the Test UI
+
+Simply open `test_chat_ui.html` in your browser:
+- Double-click the file, OR
+- Right-click → Open with → Chrome/Edge/Firefox
+
+The UI will automatically connect to `http://localhost:8000`
+
+## 3. Test the Agent
+
+1. **Login** (in the sidebar):
+   - Enter your test credentials
+   - Or paste a JWT token in the "Manual Token Override" field
+
+2. **Chat**:
+   - Type messages in the input box at the bottom
+   - Click Send or press Enter
+   - View responses in the chat area
+
+3. **Debug**:
+   - Check the "Debug Output" section in the sidebar for raw JSON responses
+   - Monitor the server terminal for backend logs
+
+## Troubleshooting
+
+### Server won't start
+- Check if port 8000 is already in use
+- Verify MongoDB, Redis, Qdrant connection strings in `.env`
+- Check the terminal for specific error messages
+
+### UI shows "Offline"
+- Make sure the server is running on port 8000
+- Check browser console (F12) for CORS or network errors
+
+### Authentication fails
+- Verify your test user exists in the database
+- Check the credentials match
+- Use the manual token input as a fallback

RUN_TEST_UI.md

@@ -0,0 +1,59 @@
+# Run Test UI - QUICK START
+
+## The Problem
+Opening `test_chat_ui.html` directly (file://) causes CORS errors because browsers send `origin: null`.
+
+## The Solution - Serve it via HTTP
+
+### Option 1: Using Python (Recommended)
+
+**In a NEW terminal** (keep the backend server running in the first one):
+
+```bash
+cd C:\Users\Destiny Ebuka\Desktop\python-Backend\lojiz-backend\AIDA
+python -m http.server 8080
+```
+
+Then open in browser: **http://localhost:8080/test_chat_ui.html**
+
+### Option 2: Using VS Code Live Server
+
+1. Install "Live Server" extension in VS Code
+2. Right-click `test_chat_ui.html`
+3. Select "Open with Live Server"
+
+## Full Testing Steps
+
+### Terminal 1 - Backend Server
+```bash
+cd C:\Users\Destiny Ebuka\Desktop\python-Backend\lojiz-backend\AIDA
+python -m uvicorn main:app --reload
+```
+
+### Terminal 2 - Test UI Server
+```bash
+cd C:\Users\Destiny Ebuka\Desktop\python-Backend\lojiz-backend\AIDA
+python -m http.server 8080
+```
+
+### Browser
+Open: **http://localhost:8080/test_chat_ui.html**
+
+✅ Now CORS will work because:
+- UI runs on `http://localhost:8080`
+- API runs on `http://localhost:8000`  
+- Both are proper HTTP origins (not `null`)
+- CORS middleware allows localhost
+
+## Test the Login
+
+1. Enter credentials
+2. Click "Login"
+3. Check Debug Output - should see successful response with JWT
+4. Check server logs - should see:
+   ```
+   INFO: OPTIONS /api/auth/login HTTP/1.1" 200 OK
+   INFO: POST /api/auth/login HTTP/1.1" 200 OK
+   ```
+
+That's it! 🚀

app/ai/agent/graph.py

@@ -16,6 +16,8 @@ from app.ai.agent.nodes.listing_collect import listing_collect_handler
 from app.ai.agent.nodes.listing_validate import listing_validate_handler
 from app.ai.agent.nodes.listing_publish import listing_publish_handler
 from app.ai.agent.nodes.search_query import search_query_handler
+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.respond import respond_to_user
@@ -37,7 +39,10 @@ def route_by_intent(state: AgentState) -> str:
     intent_to_node = {
         "greeting": "greeting",
         "listing": "listing_collect",
+        "publish": "listing_publish",
         "search": "search_query",
+        "my_listings": "my_listings",
+        "edit_listing": "edit_listing",
         "casual_chat": "casual_chat",
         "unknown": "casual_chat",
     }
@@ -75,31 +80,61 @@ def route_after_listing_collect(state: AgentState) -> str:
         logger.info("All fields collected signal detected, moving to validate")
         return "listing_validate"
     
-    # ✅ Check if showing example (stay in collect)
+    # ✅ Check if showing example (send response to user)
     if state.temp_data.get("action") == "show_example":
-        logger.info("Showing example, staying in listing_collect")
-        return "listing_collect"
+        logger.info("Showing example, sending response to user")
+        return "validate_output"
     
-    # ✅ Check if asking for fields (stay in collect)
+    # ✅ Check if asking for fields (send response to user)
     if state.temp_data.get("action") in ["asking_field", "asking_first_field", "asking_optional"]:
-        logger.info("Asking for fields, staying in listing_collect")
-        return "listing_collect"
+        logger.info("Asking for fields, sending response to user")
+        return "validate_output"
+    
+    # ✅ EDIT MODE CHECK: When editing, wait for explicit save unless user said "save"
+    is_editing = (
+        state.temp_data.get("is_editing", False) or 
+        state.temp_data.get("editing_listing_id") is not None
+    )
+    edit_waiting_actions = ["edit_listing_ready", "edit_waiting_input", "edit_field_updated", "edit_continue"]
+    
+    if is_editing and state.temp_data.get("action") in edit_waiting_actions:
+        logger.info("Edit mode: Waiting for user input, NOT auto-validating", action=state.temp_data.get("action"))
+        return "validate_output"
     
     # ✅ Check required fields completion
-    required = ["location", "bedrooms", "bathrooms", "price", "price_type"]
+    required = ["location", "bedrooms", "bathrooms", "price", "price_type", "images"]
     has_all = all(
-        state.provided_fields.get(f) is not None 
+        state.provided_fields.get(f) is not None and 
+        (f != "images" or (isinstance(state.provided_fields.get(f), list) and len(state.provided_fields.get(f)) > 0))
         for f in required
     )
     
     if not has_all:
-        logger.info("Still missing required fields, staying in listing_collect")
-        return "listing_collect"
+        logger.info("Still missing required fields, sending response to user")
+        return "validate_output"
     else:
         logger.info("All fields present, moving to listing_validate")
         return "listing_validate"
 
 
+def route_after_edit_listing(state: AgentState) -> str:
+    """
+    After edit_listing, determine next step:
+    - If listing loaded successfully → go to listing_collect for edits
+    - If error (not found, unauthorized) → go to validate_output to show error message
+    """
+    action = state.temp_data.get("action", "")
+    
+    # If the action indicates success, go to listing_collect
+    if action == "edit_listing_ready":
+        logger.info("Edit listing successful, moving to listing_collect")
+        return "listing_collect"
+    else:
+        # Error cases: edit_listing_prompt, edit_listing_not_found, edit_listing_unauthorized, edit_listing_error
+        logger.info("Edit listing failed or needs input, moving to validate_output", action=action)
+        return "validate_output"
+
+
 def route_after_listing_validate(state: AgentState) -> str:
     """
     After validation, determine next step.
@@ -128,8 +163,9 @@ def build_aida_graph():
     
     logger.info("Building AIDA Graph with LangGraph")
     
-    # Create graph
-    graph = StateGraph(AgentState)
+    # Create graph with name
+    graph = StateGraph(AgentState, config_schema=None)
+    graph.name = "AIDA - AI Real Estate Assistant"
     
     # ============================================================
     # ADD NODES (Each is a handler function)
@@ -142,11 +178,13 @@ def build_aida_graph():
     graph.add_node("listing_validate", listing_validate_handler)
     graph.add_node("listing_publish", listing_publish_handler)
     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("casual_chat", casual_chat_handler)
     graph.add_node("validate_output", validate_output_node)
     graph.add_node("respond", respond_to_user)
     
-    logger.info("✅ 10 nodes added")
+    logger.info("✅ 12 nodes added")
     
     # ============================================================
     # ADD EDGES (Define flow transitions)
@@ -165,7 +203,10 @@ def build_aida_graph():
         {
             "greeting": "greeting",
             "listing_collect": "listing_collect",
+            "listing_publish": "listing_publish",
             "search_query": "search_query",
+            "my_listings": "my_listings",
+            "edit_listing": "edit_listing",
             "casual_chat": "casual_chat",
         }
     )
@@ -200,6 +241,19 @@ def build_aida_graph():
     # Search → validate_output
     graph.add_edge("search_query", "validate_output")
     
+    # My Listings → validate_output
+    graph.add_edge("my_listings", "validate_output")
+    
+    # Edit Listing → conditional routing (success→listing_collect, error→validate_output)
+    graph.add_conditional_edges(
+        "edit_listing",
+        route_after_edit_listing,
+        {
+            "listing_collect": "listing_collect",
+            "validate_output": "validate_output",
+        }
+    )
+    
     # Casual chat → validate_output
     graph.add_edge("casual_chat", "validate_output")
     
@@ -215,9 +269,13 @@ def build_aida_graph():
     # COMPILE (Create executable graph)
     # ============================================================
     
-    compiled_graph = graph.compile()
+    # ✅ Add checkpointer for state persistence
+    from langgraph.checkpoint.memory import MemorySaver
+    checkpointer = MemorySaver()
+    
+    compiled_graph = graph.compile(checkpointer=checkpointer)
     
-    logger.info("✅ LangGraph compiled and ready")
+    logger.info("✅ LangGraph compiled and ready (with MemorySaver persistence)")
     
     return compiled_graph
 

app/ai/agent/nodes/authenticate.py

@@ -36,8 +36,9 @@ async def authenticate(
     )
     
     try:
-        # ✅ Just accept everyone
-        state.user_role = "renter"  # Default role for anonymous users
+        # ✅ Preserve user_role from request, only default if not set
+        if not state.user_role:
+            state.user_role = "renter"  # Default role for anonymous users
         
         logger.info(
             "✅ User session accepted (no auth required)",
@@ -45,7 +46,22 @@ async def authenticate(
             user_role=state.user_role
         )
         
-        # Transition to next state
+        # Check if we're already in an active flow that should continue
+        active_flows = [
+            FlowState.LISTING_COLLECT, 
+            FlowState.LISTING_VALIDATE,
+            FlowState.SEARCH_QUERY
+        ]
+        
+        if state.current_flow in active_flows:
+            # Stay in current flow - don't re-classify
+            logger.info(
+                "↩️ Staying in active flow",
+                current_flow=state.current_flow.value
+            )
+            return state
+        
+        # Transition to classify intent for new interactions
         success, error = state.transition_to(
             FlowState.CLASSIFY_INTENT,
             reason="Public access - no authentication required"

app/ai/agent/nodes/casual_chat.py

@@ -87,7 +87,11 @@ async def casual_chat_handler(state: AgentState) -> AgentState:
         # STEP 2: Get system prompt
         # ============================================================
         
-        system_prompt = get_system_prompt(user_role=state.user_role)
+        system_prompt = get_system_prompt(
+            user_role=state.user_role,
+            user_name=state.user_name,
+            user_location=state.user_location
+        )
         
         logger.info("System prompt loaded", user_role=state.user_role)
         
@@ -143,13 +147,13 @@ Respond naturally and helpfully. Keep your response conversational and friendly
         logger.info("Response stored in state", user_id=state.user_id)
         
         # ============================================================
-        # STEP 7: Transition to COMPLETE
+        # STEP 7: Transition to IDLE (ready for next interaction)
         # ============================================================
         
-        success, error = state.transition_to(FlowState.COMPLETE, reason="Casual chat completed")
+        success, error = state.transition_to(FlowState.IDLE, reason="Casual chat completed")
         
         if not success:
-            logger.error("Transition to COMPLETE failed", error=error)
+            logger.error("Transition to IDLE failed", error=error)
             state.set_error(error, should_retry=False)
             return state
         
@@ -171,7 +175,7 @@ Respond naturally and helpfully. Keep your response conversational and friendly
         
         # Try to recover
         if state.set_error(error_msg, should_retry=True):
-            state.transition_to(FlowState.COMPLETE, reason="Chat with error recovery")
+            state.transition_to(FlowState.IDLE, reason="Chat with error recovery")
         else:
             state.transition_to(FlowState.ERROR, reason="Casual chat error")
         

app/ai/agent/nodes/classify_intent.py

@@ -33,24 +33,42 @@ User message: "{user_message}"
 
 Classify into ONE of these intents:
 1. "greeting" - Pure greeting (Hello, Hi, Good morning, etc.)
-2. "listing" - User wants to create/list a property
+2. "listing" - User wants to create/list a NEW property
 3. "search" - User wants to search/find properties
-4. "casual_chat" - Other conversation
-5. "unknown" - You don't understand
+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
 
-Return ONLY valid JSON (no markdown, no extra text):
+- "Return ONLY valid JSON (no markdown, no extra text):
 {{
-  "type": "greeting|listing|search|casual_chat|unknown",
+  "type": "greeting|listing|search|my_listings|edit_listing|publish|casual_chat|unknown",
   "confidence": 0.0-1.0,
   "reasoning": "Why you chose this intent",
   "requires_auth": true/false,
   "next_action": "What Aida should do next"
 }}
 
+IMPORTANT:
+- "edit_listing" is ONLY for STARTING the edit process (e.g. "edit my listing", "edit listing [ID]").
+- If user is ALREADY editing and says "update price", "change location", this is "listing" (updating fields).
+- "Change price to 85k" → "listing"
+- "Update location to Lagos" → "listing"
+- "Correct the description" → "listing"
+
 Examples:
 - "Hello!" → {{"type": "greeting", "confidence": 0.95, "reasoning": "Pure greeting", "requires_auth": false, "next_action": "respond_warmly"}}
 - "List my apartment" → {{"type": "listing", "confidence": 0.90, "reasoning": "User wants to create listing", "requires_auth": true, "next_action": "start_listing_flow"}}
+- "Change price to 85k" → {{"type": "listing", "confidence": 0.95, "reasoning": "User wants to modify fields in current flow", "requires_auth": true, "next_action": "update_listing"}}
+- "Update location to Parakou" → {{"type": "listing", "confidence": 0.95, "reasoning": "User updating location field", "requires_auth": true, "next_action": "update_listing"}}
 - "Find me a 2-bed in Lagos" → {{"type": "search", "confidence": 0.90, "reasoning": "User searching for properties", "requires_auth": false, "next_action": "execute_search"}}
+- "Show my listings" → {{"type": "my_listings", "confidence": 0.95, "reasoning": "User wants to view their own listings", "requires_auth": true, "next_action": "show_my_listings"}}
+- "View my properties" → {{"type": "my_listings", "confidence": 0.95, "reasoning": "User wants to see their published properties", "requires_auth": true, "next_action": "show_my_listings"}}
+- "edit listing 507f1f77bcf86cd799439011" → {{"type": "edit_listing", "confidence": 0.95, "reasoning": "User wants to start editing a specific listing", "requires_auth": true, "next_action": "edit_listing"}}
+- "edit my first listing" → {{"type": "edit_listing", "confidence": 0.90, "reasoning": "User wants to pick a listing to edit", "requires_auth": true, "next_action": "edit_listing"}}
+- "Publish it" → {{"type": "publish", "confidence": 0.95, "reasoning": "User wants to finalize and publish listing", "requires_auth": true, "next_action": "publish_listing"}}
+- "Yes, go ahead" → {{"type": "publish", "confidence": 0.85, "reasoning": "Confirmation to publish", "requires_auth": true, "next_action": "publish_listing"}}
 - "What's 2+2?" → {{"type": "casual_chat", "confidence": 0.85, "reasoning": "General question", "requires_auth": false, "next_action": "respond_naturally"}}"""
 
 def _has_saved_listing_progress(state: AgentState) -> bool:
@@ -200,6 +218,16 @@ async def classify_intent(state: AgentState) -> AgentState:
             intent_data = validation.data
             state.intent_type = intent_data.type
             state.intent_confidence = intent_data.confidence
+            
+            # ✅ SAFETY CHECK: If editing active draft, don't restart edit_listing unless ID provided
+            if state.intent_type == "edit_listing" and state.listing_draft:
+                import re
+                # Check if message contains a listing ID (24 char hex)
+                has_id = bool(re.search(r'[0-9a-fA-F]{24}', state.last_user_message))
+                
+                if not has_id:
+                    logger.info("Override intent: edit_listing -> listing (active edit session)")
+                    state.intent_type = "listing"
         
         logger.info(
             "Intent classified",
@@ -212,13 +240,27 @@ async def classify_intent(state: AgentState) -> AgentState:
         intent_to_flow = {
             "greeting": FlowState.GREETING,
             "listing": FlowState.LISTING_COLLECT,
+            "publish": FlowState.LISTING_PUBLISH, # Direct route to publish
             "search": FlowState.SEARCH_QUERY,
+            "my_listings": FlowState.MY_LISTINGS,  # Route to my listings
+            "edit_listing": FlowState.EDIT_LISTING,  # Route to edit listing
             "casual_chat": FlowState.CASUAL_CHAT,
             "unknown": FlowState.CASUAL_CHAT,  # Default to casual chat
         }
         
         next_flow = intent_to_flow.get(state.intent_type, FlowState.CASUAL_CHAT)
         
+        # ✅ FIXED: If already in the target flow, skip transition (no error)
+        if state.current_flow == next_flow:
+            logger.info("Already in target flow, skipping transition", flow=next_flow.value)
+            return state
+        
+        # ✅ SPECIAL: When in listing_collect and user says "publish/save", 
+        # stay in listing_collect - let its save logic handle the transition
+        if state.current_flow == FlowState.LISTING_COLLECT and state.intent_type in ["publish", "listing"]:
+            logger.info("Staying in listing_collect for save/publish - letting save logic handle transition")
+            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

@@ -0,0 +1,194 @@
+# app/ai/agent/nodes/edit_listing.py
+"""
+Handler for editing existing listings.
+Fetches listing by ID and prepares it for editing through the listing_collect flow.
+"""
+
+import re
+from typing import Optional
+from structlog import get_logger
+from bson import ObjectId
+
+from app.ai.agent.state import AgentState, FlowState
+from app.database import get_db_sync
+
+logger = get_logger(__name__)
+
+
+def extract_listing_id(message: str) -> Optional[str]:
+    """Extract a MongoDB ObjectId from the message."""
+    # Look for 24-character hex string (MongoDB ObjectId format)
+    pattern = r'[0-9a-fA-F]{24}'
+    match = re.search(pattern, message)
+    if match:
+        return match.group(0)
+    return None
+
+
+async def edit_listing_handler(state: AgentState) -> AgentState:
+    """
+    Fetch an existing listing and prepare it for editing.
+    
+    Flow:
+    1. Extract listing ID from message
+    2. Fetch listing from MongoDB
+    3. Verify ownership
+    4. Convert to draft format
+    5. Ask user what to edit
+    """
+    
+    logger.info(
+        "Starting edit listing flow",
+        user_id=state.user_id,
+        message=state.last_user_message
+    )
+    
+    try:
+        # Extract listing ID from message
+        listing_id = extract_listing_id(state.last_user_message or "")
+        
+        # Also check temp_data for listing_id (set by frontend)
+        if not listing_id:
+            listing_id = state.temp_data.get("edit_listing_id")
+        
+        if not listing_id:
+            # No ID provided - ask user
+            state.temp_data["response_text"] = (
+                "Which listing would you like to edit? 📝\n\n"
+                "Please say 'show my listings' first to see your properties, "
+                "then click the Edit button on the listing you want to modify."
+            )
+            state.temp_data["action"] = "edit_listing_prompt"
+            state.transition_to(FlowState.IDLE, reason="No listing ID provided")
+            return state
+        
+        # Get database
+        db = get_db_sync()
+        
+        # Fetch the listing
+        try:
+            listing = await db.listings.find_one({"_id": ObjectId(listing_id)})
+        except Exception:
+            listing = None
+        
+        if not listing:
+            state.temp_data["response_text"] = (
+                f"I couldn't find that listing. It may have been deleted. 🔍\n\n"
+                "Say 'show my listings' to see your current properties."
+            )
+            state.temp_data["action"] = "edit_listing_not_found"
+            state.transition_to(FlowState.IDLE, reason="Listing not found")
+            return state
+        
+        # Verify ownership
+        if str(listing.get("user_id")) != state.user_id:
+            state.temp_data["response_text"] = (
+                "You can only edit your own listings. 🔒\n\n"
+                "Say 'show my listings' to see properties you can edit."
+            )
+            state.temp_data["action"] = "edit_listing_unauthorized"
+            state.transition_to(FlowState.IDLE, reason="Not owner")
+            return state
+        
+        # Helper to infer currency from location (simple map)
+        def infer_currency(loc: str) -> str:
+            loc = loc.lower()
+            if any(c in loc for c in ["nigeria", "lagos", "abuja", "parakou"]):
+                return "XOF"
+            if any(c in loc for c in ["usa", "new york", "san francisco", "los angeles"]):
+                return "USD"
+            if any(c in loc for c in ["uk", "london", "england"]):
+                return "GBP"
+            # Default fallback
+            return "USD"
+
+        # Convert to draft format for editing
+        draft = {
+            "title": listing.get("title", ""),
+            "description": listing.get("description", ""),
+            "location": listing.get("location", ""),
+            "price": listing.get("price", 0),
+            "currency": listing.get("currency", "XOF"),
+            "price_type": listing.get("price_type", "monthly"),
+            "bedrooms": listing.get("bedrooms"),
+            "bathrooms": listing.get("bathrooms"),
+            "amenities": listing.get("amenities", []),
+            "images": listing.get("images", []),
+            "listing_type": listing.get("listing_type", "rent"),
+        }
+        # If location is present, ensure currency matches location
+        if draft["location"]:
+            draft["currency"] = infer_currency(draft["location"])
+
+        
+        # Store in state for editing
+        state.listing_draft = draft
+        state.temp_data["editing_listing_id"] = listing_id
+        state.temp_data["is_editing"] = True
+        
+        # Copy fields to provided_fields so listing_collect knows what exists
+        state.provided_fields = {k: v for k, v in draft.items() if v}
+        
+        # Build draft UI using the consistent function
+        from app.ai.agent.nodes.listing_validate import build_draft_ui_from_dict
+        draft_ui = build_draft_ui_from_dict(draft)
+        draft_ui["status"] = "editing"  # Mark as editing
+        state.temp_data["draft_ui"] = draft_ui
+        
+        # Generate LLM response for initial edit message
+        user_name = state.user_name or "there"
+        listing_title = draft.get("title", "your listing")
+        
+        # Use LLM to generate a friendly, natural initial edit message
+        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,
+        )
+        
+        prompt = f"""Generate a SHORT, friendly message for user "{user_name}" who wants to edit their listing titled "{listing_title}".
+The message should:
+- Be casual and welcoming (1-2 sentences max)
+- Invite them to tell you what they want to change
+- NOT list specific fields or examples
+- NOT mention "save" yet (that comes later)
+
+Example tone: "Here's your listing! What would you like to change?"
+
+Just return the message, no quotes."""
+
+        try:
+            response = await llm.ainvoke([HumanMessage(content=prompt)])
+            edit_message = response.content.strip().strip('"')
+        except Exception:
+            # Fallback if LLM fails
+            edit_message = f"Here's your listing **\"{listing_title}\"** ✏️ What would you like to change?"
+        
+        state.temp_data["response_text"] = edit_message
+        state.temp_data["action"] = "edit_listing_ready"
+        
+        # Transition to listing_collect for edits
+        state.transition_to(FlowState.LISTING_COLLECT, reason="Listing loaded for editing")
+        
+        logger.info(
+            "Edit listing ready",
+            user_id=state.user_id,
+            listing_id=listing_id,
+            title=draft["title"]
+        )
+        
+        return state
+        
+    except Exception as e:
+        logger.error("Edit listing error", exc_info=e)
+        state.temp_data["response_text"] = (
+            "Sorry, something went wrong while loading the listing. Please try again."
+        )
+        state.temp_data["action"] = "edit_listing_error"
+        state.transition_to(FlowState.IDLE, reason="Edit listing error")
+        return state

app/ai/agent/nodes/greeting.py

@@ -26,6 +26,7 @@ llm = ChatOpenAI(
 GREETING_PROMPT = """You are AIDA, a warm and friendly real estate AI assistant for Lojiz platform.
 
 User greeted you with: "{user_message}"
+{name_instruction}
 
 Generate a WARM, NATURAL, UNIQUE response that:
 1. Responds to their greeting in the SAME language they used
@@ -43,12 +44,6 @@ Language rules:
 
 Vary your greeting! Use different emojis, different greetings, different ways to introduce yourself.
 
-Examples of varied responses:
-- "Hey there! 👋 I'm Aida, your real estate buddy. Looking to find or list a property today?"
-- "Hello! 😊 I'm Aida from Lojiz. How can I help you with real estate?"
-- "Hi! 🏠 I'm Aida, your property assistant. What's on your mind - buying, renting, or listing?"
-- "Bonjour! 👋 Je suis Aida, votre assistant immobilier. Comment puis-je vous aider?"
-
 Now generate YOUR unique, warm response (2-3 sentences only, be creative!):"""
 
 
@@ -77,7 +72,15 @@ async def greeting_handler(state: AgentState) -> AgentState:
         # STEP 1: Generate warm greeting response with LLM
         # ============================================================
         
-        prompt = GREETING_PROMPT.format(user_message=state.last_user_message)
+        # Build personalized prompt
+        name_instruction = ""
+        if state.user_name:
+            name_instruction = f"\nThe user's name is: {state.user_name}. Use their name warmly in your greeting (e.g., 'Hi {state.user_name}!')."
+        
+        prompt = GREETING_PROMPT.format(
+            user_message=state.last_user_message,
+            name_instruction=name_instruction
+        )
         
         logger.info("Generating greeting response with LLM", user_message=state.last_user_message[:30])
         

app/ai/agent/nodes/listing_collect.py

@@ -142,113 +142,333 @@ Return ONLY valid JSON:
 
 async def listing_collect_handler(state: AgentState) -> AgentState:
     """
-    Dynamic listing collection - FINAL FIX
-    Key: Don't return early, always reach the end to set proper action
+    FULLY LLM-DRIVEN listing collection
+    Zero hard-coded responses - all intelligent and contextual
+    
+    Flow:
+    1. Every message → LLM reasons → detects intent → generates response
+    2. If intent changed → switch flows
+    3. If still listing → LLM decides what to say based on context
+    4. Extract fields → LLM asks for missing ones naturally
     """
     
-    logger.info("Dynamic listing collection", 
+    logger.info("Smart listing collection", 
                user_id=state.user_id,
-               current_action=state.temp_data.get("action"))
+               provided_fields=list(state.provided_fields.keys()))
     
     try:
-        # ✅ STEP 1: Check if user changed intent
-        intent_check = await is_still_listing_intent(state)
-        
-        if not intent_check["is_listing_related"]:
-            logger.info("Intent switched", new_intent=intent_check["detected_intent"])
+        # ✅ FIRST ENTRY CHECK: If we just loaded from edit_listing, skip processing
+        # The edit_listing handler already set up the response and draft
+        if state.temp_data.get("is_editing") and state.temp_data.get("action") == "edit_listing_ready":
+            logger.info("Edit mode: First entry after load, using initial edit message")
+            # Clear the flag so subsequent entries get processed normally
+            state.temp_data["action"] = "edit_waiting_input"
+            # Response text is already set by edit_listing_handler
             return state
         
-        # ✅ STEP 2: Check if this is initial listing request (first message)
-        initial_listing_triggers = [
-            "i want to list", "i want to list a property", "list my property",
-            "list property", "create listing", "post listing", "add property"
-        ]
+        # Import the smart conversation manager
+        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
+        )
         
-        user_message_lower = state.last_user_message.lower().strip()
-        is_initial_request = (
-            not state.provided_fields and 
-            any(trigger in user_message_lower for trigger in initial_listing_triggers)
+        # ✅ STEP 1: Generate intelligent response using LLM
+        # This analyzes the message, detects intent, and creates contextual reply
+        smart_response = await generate_smart_listing_response(
+            user_message=state.last_user_message,
+            user_role=state.user_role,
+            conversation_history=state.conversation_history,
+            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
         )
         
-        # ✅ CRITICAL: If initial request AND we haven't shown example yet
-        if is_initial_request and state.temp_data.get("action") != "show_example":
-            logger.info("Initial listing request - showing example first")
-            example = await generate_listing_example("en", state.user_role)
-            state.temp_data["response_text"] = f"Great! 🎯 Here's an example:\n\n\"{example}\"\n\nNow tell me about your property."
-            state.temp_data["action"] = "show_example"
-            logger.info("Example shown, set action to show_example")
-            return state  # ✅ Return here ONLY on first call
+        logger.info("Smart response received",
+                   action=smart_response.get("action"),
+                   intent_still_listing=smart_response.get("intent_still_listing"))
+        
+        # ✅ STEP 2: Check if user changed intent
+        if not smart_response.get("intent_still_listing"):
+            detected_intent = smart_response.get("detected_new_intent")
+            logger.info("Intent changed", new_intent=detected_intent)
+            
+            # Set response and let router handle intent change
+            state.temp_data["response_text"] = smart_response.get("response_text")
+            state.temp_data["action"] = "intent_switched"
+            state.temp_data["new_intent"] = detected_intent
+            return state
         
-        # ✅ STEP 3: Extract fields from user message
-        logger.info("Extracting fields from user message")
+        # ✅ STEP 3: Extract fields (LLM does this smartly)
         extracted = await extract_listing_fields_smart(
             state.last_user_message,
             state.user_role,
             state.provided_fields
         )
         
-        logger.info("Field extraction result", extracted=extracted)
-        
-        # Update state with extracted fields
         if extracted:
+            # Get operation modes for list fields (default to "add" for backward compat)
+            images_operation = extracted.pop("images_operation", "add")
+            amenities_operation = extracted.pop("amenities_operation", "add")
+            
             for field, value in extracted.items():
-                if value is not None and value != [] and value != "":
-                    state.update_listing_progress(field, value)
-                    logger.info("Field updated", field=field, value=str(value)[:30])
+                # 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:
+                        if images_operation == "replace":
+                            # Replace all images
+                            state.update_listing_progress(field, value)
+                            logger.info("Images REPLACED", count=len(value))
+                        else:
+                            # 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))
+                    
+                    # Special handling for amenities: add or replace
+                    elif field == "amenities" and isinstance(value, list) and value:
+                        if amenities_operation == "replace":
+                            # Replace all amenities
+                            state.update_listing_progress(field, value)
+                            logger.info("Amenities REPLACED", amenities=value)
+                        else:
+                            # Add to existing amenities (default)
+                            current_amenities = state.provided_fields.get("amenities", [])
+                            new_amenities = list(set(current_amenities + value))  # Avoid duplicates
+                            state.update_listing_progress(field, new_amenities)
+                            logger.info("Amenities ADDED", added=value, total=new_amenities)
+                    
+                    else:
+                        # Regular fields: just update/replace
+                        state.update_listing_progress(field, value)
+                    
+                    logger.info("Field extracted and updated", field=field, value=value)
+
+                    # If location was updated, get accurate currency using Nominatim API
+                    if field == "location" and isinstance(value, str):
+                        try:
+                            from app.ai.tools.listing_tool import get_currency_for_location
+                            currency = await get_currency_for_location(value)
+                            # Update both draft and provided fields
+                            if hasattr(state, "listing_draft") and isinstance(state.listing_draft, dict):
+                                state.listing_draft["currency"] = currency
+                            state.update_listing_progress("currency", currency)
+                            logger.info("Currency updated via Nominatim API", location=value, currency=currency)
+                        except Exception as e:
+                            logger.warning(f"Failed to get currency for {value}, defaulting to XOF: {e}")
+                            # Fallback to XOF (common for Africa)
+                            currency = "XOF"
+                            if hasattr(state, "listing_draft") and isinstance(state.listing_draft, dict):
+                                state.listing_draft["currency"] = currency
+                            state.update_listing_progress("currency", currency)
         
-        # ✅ STEP 4: Check if we have ANY real data
-        required_fields = ["location", "bedrooms", "bathrooms", "price", "price_type"]
-        has_any_real_data = any(
-            state.provided_fields.get(f) is not None 
-            for f in required_fields
-        )
+        # ✅ 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")
+        logger.info("Sync check", is_editing=is_editing_flag, editing_id=editing_id, has_draft=bool(state.listing_draft))
         
-        if not has_any_real_data:
-            logger.info("No real data extracted, asking for first field")
-            question = await generate_contextual_question(state, "location")
-            state.temp_data["response_text"] = question
-            state.temp_data["action"] = "asking_first_field"
-            state.current_asking_for = "location"
-            return state
+        if (is_editing_flag or editing_id) and state.listing_draft:
+            logger.info("Before sync", draft_location=state.listing_draft.get("location"), draft_price=state.listing_draft.get("price"))
+            for field, value in state.provided_fields.items():
+                if value is not None and field in state.listing_draft:
+                    state.listing_draft[field] = value
+            logger.info("After sync", draft_location=state.listing_draft.get("location"), draft_price=state.listing_draft.get("price"))
+            logger.info("Listing draft synced with provided_fields")
+            
+            # ✅ SMART INFERENCE: Auto-detect related fields (same logic as listing_validate)
+            price_type = state.listing_draft.get("price_type", "monthly")
+            current_listing_type = state.listing_draft.get("listing_type", "rent")
+            
+            # If price_type is "nightly" → listing_type should be "short-stay"
+            if price_type == "nightly" and current_listing_type != "short-stay":
+                state.listing_draft["listing_type"] = "short-stay"
+                state.provided_fields["listing_type"] = "short-stay"
+                logger.info("Auto-inferred listing_type to short-stay from nightly price_type")
+            
+            # If price_type is "one-time" → listing_type should be "sale"
+            if price_type == "one-time" and current_listing_type != "sale":
+                state.listing_draft["listing_type"] = "sale"
+                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)
+            
+            # ✅ Regenerate draft_ui so frontend gets updated card
+            from app.ai.agent.nodes.listing_validate import build_draft_ui_from_dict
+            draft_ui = build_draft_ui_from_dict(state.listing_draft)
+            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"))
         
-        # ✅ STEP 5: Check if ALL required fields are present
-        missing_required = [f for f in required_fields if state.provided_fields.get(f) is None]
+        logger.info("Current provided fields after update", fields=state.provided_fields)
         
-        if missing_required:
-            logger.info("Missing required fields", missing=missing_required)
-            next_field = missing_required[0]
-            question = await generate_contextual_question(state, next_field)
-            state.temp_data["response_text"] = question
-            state.temp_data["action"] = "asking_field"
-            state.current_asking_for = next_field
-            return state
+        # ✅ STEP 4: Check completion status
+        required_fields = ["location", "bedrooms", "bathrooms", "price", "price_type", "images"]
         
-        # ✅ STEP 6: All required fields present - ask about optional fields
-        if not state.provided_fields.get("amenities") and not state.provided_fields.get("requirements"):
-            question = "Great! Any amenities like wifi, parking, furnished, AC? And any special requirements?"
-            state.temp_data["response_text"] = question
-            state.temp_data["action"] = "asking_optional"
-            logger.info("Asking about optional fields")
-            return state
+        # Fix: Check for None OR empty values (empty list/string)
+        missing_required = []
+        for f in required_fields:
+            val = state.provided_fields.get(f)
+            # If val is None, or empty list [], or empty string "" -> it's missing
+            if val is None or val == "" or (isinstance(val, list) and len(val) == 0):
+                missing_required.append(f)
         
-        # ✅ STEP 7: All fields complete - transition to VALIDATE
-        logger.info("All fields collected, transitioning to LISTING_VALIDATE")
-        state.temp_data["response_text"] = "Perfect! Creating your listing preview..."
-        state.temp_data["action"] = "all_fields_collected"
+        state.missing_required_fields = missing_required
         
-        success, error = state.transition_to(
-            FlowState.LISTING_VALIDATE,
-            reason="All required fields collected"
+        state.missing_required_fields = missing_required
+        
+        # ✅ STEP 5: Check if user wants to save/publish
+        # When editing an existing listing, wait for explicit "save" command
+        # Check multiple indicators for edit mode (more robust)
+        is_editing = (
+            state.temp_data.get("is_editing", False) or 
+            state.temp_data.get("editing_listing_id") is not None
         )
+        user_message = (state.last_user_message or "").lower()
+        
+        # Keywords that indicate user wants to save/finalize
+        save_keywords = ["save", "publish", "done", "finish", "update listing", "save changes", "that's all", "thats all"]
+        wants_to_save = any(kw in user_message for kw in save_keywords)
+        
+        # ✅ If editing: only advance to validation when user explicitly says save
+        if is_editing:
+            if wants_to_save:
+                logger.info("Edit mode: User wants to save, moving to listing_validate")
+                state.temp_data["response_text"] = "Let me validate your changes..."
+                state.temp_data["action"] = "saving_edits"
+                
+                success, error = state.transition_to(
+                    FlowState.LISTING_VALIDATE,
+                    reason="User requested to save edits"
+                )
+                
+                if not success:
+                    logger.error("Failed to transition to LISTING_VALIDATE", error=error)
+                    state.set_error(error, should_retry=False)
+                
+                return state
+            else:
+                # Stay in edit mode - acknowledge any changes made and ask for more
+                action = smart_response.get("action", "edit_continue")
+                response_text = smart_response.get("response_text", "")
+                
+                # If fields were extracted, generate LLM acknowledgment
+                if extracted:
+                    changed_fields = list(extracted.keys())
+                    if changed_fields:
+                        user_name = state.user_name or "there"
+                        new_title = state.listing_draft.get("title", "your listing")
+                        
+                        # Build change summary for LLM prompt
+                        changes_summary = []
+                        for field in changed_fields:
+                            val = state.listing_draft.get(field)
+                            if field == "location":
+                                changes_summary.append(f"location to {val}")
+                            elif field == "price":
+                                currency = state.listing_draft.get("currency", "")
+                                price_type = state.listing_draft.get("price_type", "monthly")
+                                changes_summary.append(f"price to {val} {currency} per {price_type}")
+                            elif field == "price_type":
+                                changes_summary.append(f"pricing to {val}")
+                            else:
+                                changes_summary.append(f"{field} to {val}")
+                        
+                        changes_text = ", ".join(changes_summary)
+                        
+                        # Use LLM to generate natural acknowledgment
+                        from langchain_openai import ChatOpenAI
+                        from langchain_core.messages import HumanMessage
+                        from app.config import settings
+                        
+                        edit_llm = ChatOpenAI(
+                            api_key=settings.DEEPSEEK_API_KEY,
+                            base_url=settings.DEEPSEEK_BASE_URL,
+                            model="deepseek-chat",
+                            temperature=0.8,
+                        )
+                        
+                        prompt = f"""Generate a SHORT, friendly acknowledgment for user "{user_name}" after updating their listing.
+
+Changes made: {changes_text}
+New listing title: "{new_title}"
+
+The message should:
+- Confirm the updates naturally (1-2 sentences)
+- Mention the new title
+- End by asking if they want to change anything else OR say 'save' when done
+
+Example tone: "Done! Updated your location and price. Your listing is now '...'. What else, or say 'save' when ready!"
+
+Just return the message, no quotes."""
+
+                        try:
+                            response = await edit_llm.ainvoke([HumanMessage(content=prompt)])
+                            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!"
+                        
+                        state.temp_data["response_text"] = acknowledgment
+                        state.temp_data["action"] = "edit_field_updated"
+                    else:
+                        state.temp_data["response_text"] = response_text or "What would you like to change?"
+                        state.temp_data["action"] = action
+                else:
+                    state.temp_data["response_text"] = response_text or "What would you like to change?"
+                    state.temp_data["action"] = action
+                
+                # ✅ ALWAYS set replace_last_message in edit mode so card+message updates
+                state.temp_data["replace_last_message"] = True
+                
+                logger.info("Edit mode: Waiting for more changes or save command")
+                return state
+        
+        # ✅ STEP 5b: Normal flow (creating new listing) - auto-advance when complete
+        if not missing_required:
+            logger.info("All fields present, moving to listing_validate")
+            state.temp_data["response_text"] = smart_response.get("response_text")
+            state.temp_data["action"] = "all_fields_collected"
+            
+            success, error = state.transition_to(
+                FlowState.LISTING_VALIDATE,
+                reason="All required fields collected"
+            )
+            
+            if not success:
+                logger.error("Failed to transition to LISTING_VALIDATE", error=error)
+                state.set_error(error, should_retry=False)
+            
+            return state
+        
+        # ✅ STEP 6: Still collecting → use LLM's response
+        action = smart_response.get("action")
+        state.temp_data["response_text"] = smart_response.get("response_text")
+        state.temp_data["action"] = action
         
-        if not success:
-            logger.error("Failed to transition to LISTING_VALIDATE", error=error)
-            state.set_error(error, should_retry=False)
+        logger.info("Continuing collection", 
+                   action=action,
+                   missing_count=len(missing_required))
         
         return state
         
     except Exception as e:
-        logger.error("Dynamic listing collection error", exc_info=e)
+        logger.error("Smart listing collection error", exc_info=e)
         error_msg = f"Error processing listing: {str(e)}"
         
         if state.set_error(error_msg, should_retry=True):
@@ -257,4 +477,4 @@ async def listing_collect_handler(state: AgentState) -> AgentState:
         else:
             state.transition_to(FlowState.ERROR, reason="Listing collection error")
         
-        return state
+        return state

app/ai/agent/nodes/listing_publish.py

@@ -8,6 +8,7 @@ from structlog import get_logger
 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
 
 logger = get_logger(__name__)
@@ -53,7 +54,18 @@ async def listing_publish_handler(state: AgentState) -> AgentState:
             state.temp_data["action"] = "error"
             return state
         
-        draft = state.listing_draft
+        # Convert dict to ListingDraft object if needed
+        draft_data = state.listing_draft
+        if isinstance(draft_data, dict):
+            # Ensure user_id and user_role are present (may be missing if edited from existing listing)
+            if "user_id" not in draft_data:
+                draft_data["user_id"] = state.user_id
+            if "user_role" not in draft_data:
+                draft_data["user_role"] = state.user_role
+            draft = ListingDraft(**draft_data)
+        else:
+            draft = draft_data
+            
         logger.info("Draft found, preparing to publish", title=draft.title)
         
         # ============================================================
@@ -88,21 +100,60 @@ async def listing_publish_handler(state: AgentState) -> AgentState:
         )
         
         # ============================================================
-        # STEP 3: Insert into MongoDB
+        # STEP 3: Insert or Update MongoDB
         # ============================================================
         
         try:
             db = await get_db()
-            result = await db.listings.insert_one(listing_document)
+            editing_id = state.temp_data.get("editing_listing_id")
             
-            if not result.inserted_id:
-                raise ValueError("Insert returned no ID")
+            from bson import ObjectId
             
-            listing_id = str(result.inserted_id)
-            logger.info("Listing inserted successfully", listing_id=listing_id)
+            if editing_id:
+                # UPDATE existing listing
+                logger.info("Updating existing listing", listing_id=editing_id)
+                
+                # Check consistency
+                if "_id" in listing_document:
+                    del listing_document["_id"] # Don't update _id
+                
+                listing_document["updated_at"] = datetime.utcnow()
+                # Maintain created_at if possible, but it's already in the doc from draft conversion
+                # Ideally fetch original created_at but keeping draft's is fine if it was preserved
+                
+                result = await db.listings.update_one(
+                    {"_id": ObjectId(editing_id)},
+                    {"$set": listing_document}
+                )
+                
+                if result.matched_count == 0:
+                     raise ValueError(f"Listing {editing_id} not found for update")
+                
+                listing_id = editing_id
+                logger.info("Listing updated successfully", listing_id=listing_id)
+                
+            else:
+                # INSERT new listing
+                result = await db.listings.insert_one(listing_document)
+                
+                if not result.inserted_id:
+                    raise ValueError("Insert returned no ID")
+                
+                listing_id = str(result.inserted_id)
+                logger.info("Listing inserted successfully", listing_id=listing_id)
+                
+                # Increment user's totalListings counter only for new listings
+                try:
+                    await db.users.update_one(
+                        {"_id": ObjectId(draft.user_id)},
+                        {"$inc": {"totalListings": 1}}
+                    )
+                    logger.info("User totalListings incremented", user_id=draft.user_id)
+                except Exception as user_update_err:
+                    logger.warning("Failed to increment totalListings", error=str(user_update_err))
             
         except Exception as e:
-            logger.error("MongoDB insert failed", exc_info=e)
+            logger.error("MongoDB save failed", exc_info=e)
             error_msg = f"Failed to save listing: {str(e)}"
             
             if state.set_error(error_msg, should_retry=True):
@@ -112,45 +163,69 @@ async def listing_publish_handler(state: AgentState) -> AgentState:
                 return state
             else:
                 # Max retries exceeded
-                state.transition_to(FlowState.ERROR, reason="MongoDB insert failed after retries")
+                state.transition_to(FlowState.ERROR, reason="MongoDB save failed after retries")
                 state.temp_data["response_text"] = f"Sorry, couldn't save your listing: {error_msg}"
                 state.temp_data["action"] = "error"
                 return state
         
         # ============================================================
-        # STEP 4: Generate success message
+        # STEP 4: Generate success message & UI Update
         # ============================================================
         
-        success_message = f"""🎉 **Listing Published Successfully!**
-
-Your listing **"{draft.title}"** is now live on Lojiz!
-
-📊 **Listing Details:**
-- 📍 Location: {draft.location}
-- 🛏️ Bedrooms: {draft.bedrooms}
-- 🚿 Bathrooms: {draft.bathrooms}
-- 💰 Price: {draft.price} {draft.currency}/{draft.price_type}
-
-🔗 **Listing ID:** `{listing_id}`
-
-✨ Your property is now visible to potential renters/buyers. They can:
-- View your listing details
-- See all {len(draft.images)} images
-- Contact you about the property
-
-📱 You can:
-- Edit the listing anytime
-- View interested users
-- Manage inquiries
+        # Re-build UI for the published state
+        from app.ai.agent.nodes.listing_validate import build_draft_ui
+        draft_ui = build_draft_ui(draft)
+        draft_ui["status"] = "published"
+        draft_ui["title"] = f"✅ {draft.title}" # Add checkmark to title
+        
+        # Generate personalized success message using LLM
+        from langchain_openai import ChatOpenAI
+        from langchain_core.messages import SystemMessage, 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,
+        )
+        
+        user_name = state.user_name or "there"
+        is_update = bool(state.temp_data.get("editing_listing_id"))
+        
+        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?"
+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?"
+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?"
 
-Good luck with your listing! 🚀"""
+        try:
+            response = await llm.ainvoke([
+                SystemMessage(content="You are AIDA, a super friendly real estate assistant. Write like you're celebrating with a friend - excited, warm, enthusiastic!"),
+                HumanMessage(content=prompt)
+            ])
+            success_message = response.content.strip()
+        except Exception as e:
+            logger.warning("LLM message generation failed, using fallback", error=str(e))
+            success_message = fallback_msg
         
         state.temp_data["response_text"] = success_message
         state.temp_data["action"] = "published"
         state.temp_data["listing_id"] = listing_id
         
+        # Signal UI updates
+        state.temp_data["draft_ui"] = draft_ui
+        state.temp_data["replace_last_message"] = True
+        
         logger.info(
-            "Success message generated",
+            "Success message & UI generated",
             listing_id=listing_id,
             title=draft.title
         )
@@ -165,6 +240,11 @@ Good luck with your listing! 🚀"""
         state.missing_required_fields.clear()
         state.current_asking_for = None
         
+        # ✅ Clear edit mode flags so messages go below card (not replace)
+        state.temp_data.pop("is_editing", None)
+        state.temp_data.pop("editing_listing_id", None)
+        state.temp_data.pop("replace_last_message", None)
+        
         # Transition to complete
         success, error = state.transition_to(
             FlowState.COMPLETE,

app/ai/agent/nodes/listing_validate.py

@@ -76,6 +76,67 @@ 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.
+    
+    Used when draft is stored as dict (after model_dump) and needs to regenerate UI.
+    
+    Args:
+        draft_dict: Dictionary containing draft fields
+    
+    Returns:
+        Dict with UI component structure
+    """
+    
+    # Amenity icons
+    amenity_icons = {
+        "wifi": "📶",
+        "parking": "🅿️",
+        "furnished": "🛋️",
+        "washing machine": "🧼",
+        "dryer": "🌪️",
+        "ac": "❄️",
+        "air conditioning": "❄️",
+        "balcony": "🏠",
+        "pool": "🏊",
+        "gym": "💪",
+        "garden": "🌳",
+        "kitchen": "🍳",
+    }
+    
+    amenities = draft_dict.get("amenities") or []
+    amenities_display = []
+    
+    for amenity in amenities:
+        icon = amenity_icons.get(amenity.lower(), "✓")
+        amenities_display.append(f"{icon} {amenity.capitalize()}")
+    
+    images = draft_dict.get("images") or []
+    
+    ui_component = {
+        "component_type": "listing_draft_preview",
+        "title": draft_dict.get("title", "Untitled"),
+        "description": draft_dict.get("description", ""),
+        "details": {
+            "location": draft_dict.get("location", "Unknown"),
+            "bedrooms": draft_dict.get("bedrooms", 0),
+            "bathrooms": draft_dict.get("bathrooms", 0),
+            "price": f"{draft_dict.get('price', 0)} {draft_dict.get('currency', 'NGN')}",
+            "price_type": draft_dict.get("price_type", "monthly"),
+            "listing_type": (draft_dict.get("listing_type") or "rent").capitalize(),
+        },
+        "amenities": amenities_display if amenities_display else ["No amenities listed"],
+        "requirements": draft_dict.get("requirements") or "No special requirements",
+        "images_count": len(images),
+        "images": images[:5],  # Show first 5
+        "status": "ready_for_review",
+        "actions": ["publish", "edit", "discard"],
+    }
+    
+    return ui_component
+
+
 async def listing_validate_handler(state: AgentState) -> AgentState:
     """
     Validate listing and show preview.
@@ -176,7 +237,7 @@ async def listing_validate_handler(state: AgentState) -> AgentState:
             "bedrooms": int(bedrooms),
             "bathrooms": int(bathrooms),
             "price": float(price),
-            "price_type": price_type,
+            "price_type": "one-time" if listing_type == "sale" else price_type,
             "currency": currency,
             "listing_type": listing_type,
             "amenities": amenities,
@@ -205,50 +266,91 @@ async def listing_validate_handler(state: AgentState) -> AgentState:
         # STEP 7: Store in state and show preview
         # ============================================================
         
-        state.listing_draft = draft
-        state.temp_data["draft"] = draft
+        # Check if this is an update to an existing draft
+        is_update = state.listing_draft is not None
+        
+        state.listing_draft = draft.model_dump()  # Convert to dict for AgentState
+        state.temp_data["draft"] = draft.model_dump()  # Also store as dict
         state.temp_data["draft_ui"] = draft_ui
         state.temp_data["action"] = "show_draft"
         
-        # Build preview response
-        preview_text = f"""📋 **Your Listing Preview**
-
-**{draft.title}**
-
-{draft.description}
+        # ============================================================
+        # STEP 8: Generate personalized message using LLM
+        # ============================================================
+        from langchain_openai import ChatOpenAI
+        from langchain_core.messages import SystemMessage, 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,
+        )
+        
+        user_name = state.user_name or "there"
+        
+        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.
+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!"
+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}.
+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")
 
-📍 **Location:** {draft.location}
-🛏️ **Bedrooms:** {draft.bedrooms}
-🚿 **Bathrooms:** {draft.bathrooms}
-💰 **Price:** {draft.price} {draft.currency} per {draft.price_type}
-🏷️ **Type:** {draft.listing_type.capitalize()}
+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."
 
-✨ **Amenities:** {', '.join(draft.amenities) if draft.amenities else 'None listed'}
-📌 **Requirements:** {draft.requirements if draft.requirements else 'None'}
-📷 **Images:** {len(draft.images)} uploaded
+Be creative and vary your wording. Use emojis. 2-3 natural flowing sentences."""
 
----
-Ready to publish? Say **"publish"**, or **"edit [field]"** to change something, or **"discard"** to cancel."""
+        try:
+            response = await llm.ainvoke([
+                SystemMessage(content="You are AIDA, a super friendly assistant. Write like you're texting a friend. Never use bullet points or numbered lists. Always write in natural, flowing sentences. Be creative and vary your wording each time."),
+                HumanMessage(content=prompt)
+            ])
+            preview_text = response.content.strip()
+        except Exception as e:
+            logger.warning("LLM message generation failed, using fallback", error=str(e))
+            if is_update:
+                preview_text = f"All done, {user_name}! ✨ Your listing's updated. Just say 'publish' when you're ready, or tell me what else to change!"
+            else:
+                preview_text = f"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."
         
         state.temp_data["response_text"] = preview_text
         
         logger.info(
             "Listing preview ready",
             user_id=state.user_id,
-            title=draft.title
+            title=draft.title,
+            is_update=is_update
         )
         
         return state
     
     except ValueError as e:
-        # Schema validation error
-        logger.error("ListingDraft validation failed", error=str(e))
-        error_msg = f"Invalid listing data: {str(e)}"
+        # Validation failed - NOT a system error, just user needs to fix input
+        # Do NOT call state.set_error() here as it increments retry counters and could force System Error state
+        
+        logger.warning("ListingDraft validation failed (user input error)", error=str(e))
+        error_msg = str(e)
         
-        state.set_error(error_msg, should_retry=True)
-        state.temp_data["response_text"] = f"There's an issue with your listing: {error_msg}\n\nLet's fix it. What would you like to change?"
+        # Clean up error message for user
+        if "images" in error_msg and "required" in error_msg:
+            user_msg = "I just need at least one photo of your property to continue."
+        else:
+            user_msg = f"There's a small issue: {error_msg}. Could you fix that?"
+
+        state.temp_data["response_text"] = f"Almost there! {user_msg}\n\nPlease upload or provide it so I can finish your listing."
         state.temp_data["action"] = "validation_error"
         
+        # Transition back to collect to get missing fields
+        state.transition_to(FlowState.LISTING_COLLECT, reason="Validation failed, collecting missing info")
+        
         return state
     
     except Exception as e:

app/ai/agent/nodes/my_listings.py

@@ -0,0 +1,94 @@
+# app/ai/agent/nodes/my_listings.py
+"""
+Handler for viewing user's own listings with Edit/Delete options.
+"""
+
+from typing import Dict, Any, List
+from structlog import get_logger
+from bson import ObjectId
+
+from app.ai.agent.state import AgentState, FlowState
+from app.database import get_db_sync
+
+logger = get_logger(__name__)
+
+
+def serialize_listing(listing: Dict) -> Dict:
+    """Convert MongoDB document to JSON-serializable format."""
+    result = {}
+    for key, value in listing.items():
+        if isinstance(value, ObjectId):
+            result[key] = str(value)
+        elif hasattr(value, 'isoformat'):
+            result[key] = value.isoformat()
+        else:
+            result[key] = value
+    return result
+
+
+async def my_listings_handler(state: AgentState) -> AgentState:
+    """
+    Fetch and display user's own listings with Edit/Delete options.
+    """
+    
+    logger.info(
+        "Fetching user's listings",
+        user_id=state.user_id
+    )
+    
+    try:
+        # Get database
+        db = get_db_sync()
+        
+        # Fetch user's active listings
+        cursor = db.listings.find({
+            "user_id": state.user_id,
+            "status": "active"
+        }).sort("createdAt", -1)  # Most recent first
+        
+        listings = []
+        async for doc in cursor:
+            listings.append(serialize_listing(doc))
+        
+        logger.info(
+            "User listings fetched",
+            user_id=state.user_id,
+            count=len(listings)
+        )
+        
+        # Store in state
+        state.my_listings = listings
+        
+        # Generate simple message
+        user_name = state.user_name or "there"
+        
+        if listings:
+            message = f"Here are your listings, {user_name}! 🏠\n\n"
+            message += f"You have **{len(listings)}** published listing(s). "
+            message += "Click **Delete** to remove or **Edit** to update any listing."
+        else:
+            message = f"Hey {user_name}! 📋\n\n"
+            message += "You don't have any published listings yet. "
+            message += "Would you like to create one? Just say 'list my property'!"
+        
+        # Store response
+        state.temp_data["response_text"] = message
+        state.temp_data["action"] = "my_listings"
+        
+        # Transition to idle
+        state.transition_to(FlowState.IDLE, reason="My listings shown")
+        
+        logger.info(
+            "My listings flow completed",
+            user_id=state.user_id,
+            listings_count=len(listings)
+        )
+        
+        return state
+        
+    except Exception as e:
+        logger.error("My listings error", exc_info=e)
+        state.temp_data["response_text"] = "Sorry, I couldn't fetch your listings right now. Please try again."
+        state.temp_data["action"] = "my_listings_error"
+        state.transition_to(FlowState.IDLE, reason="My listings error")
+        return state

app/ai/agent/nodes/respond.py

@@ -48,6 +48,18 @@ async def respond_to_user(state: AgentState) -> AgentState:
         listing_id = state.temp_data.get("listing_id")
         tool_result = state.temp_data.get("tool_result")
         
+        # ============================================================
+        # SYNC: Regenerate draft_ui from listing_draft if available
+        # This ensures draft_ui stays in sync after edits
+        # ============================================================
+        
+        if state.listing_draft and isinstance(state.listing_draft, dict):
+            # Always regenerate draft_ui from current listing_draft
+            from app.ai.agent.nodes.listing_validate import build_draft_ui_from_dict
+            draft_ui = build_draft_ui_from_dict(state.listing_draft)
+            draft = state.listing_draft
+            logger.info("🔄 Draft UI regenerated from listing_draft")
+        
         logger.info(
             "📦 Response components extracted",
             has_text=bool(response_text),
@@ -72,6 +84,9 @@ async def respond_to_user(state: AgentState) -> AgentState:
         # Build AgentResponse
         # ============================================================
         
+        # Check if we need to signal card update
+        replace_last_message = state.temp_data.get("replace_last_message", False)
+        
         response = AgentResponse(
             success=state.last_error is None,
             text=response_text,
@@ -82,8 +97,10 @@ async def respond_to_user(state: AgentState) -> AgentState:
                 "errors": state.error_count,
                 "last_error": state.last_error,
             },
-            draft=draft,
+            draft=None,  # Don't expose raw draft - only use draft_ui for display
             draft_ui=draft_ui,
+            search_results=state.search_results if state.search_results else None,  # Include search results
+            my_listings=state.my_listings if state.my_listings else None,  # Include user's listings
             tool_result=tool_result,
             error=state.last_error,
             metadata={
@@ -93,6 +110,7 @@ async def respond_to_user(state: AgentState) -> AgentState:
                 "messages_in_session": len(state.conversation_history),
                 "listing_id": listing_id,
                 "timestamp": datetime.utcnow().isoformat(),
+                "replace_last_message": replace_last_message,  # Signal frontend to update card
             }
         )
         

app/ai/agent/nodes/search_query.py

@@ -1,7 +1,7 @@
 # app/ai/agent/nodes/search_query.py
 """
 Node: Process search queries and return matching listings.
-Extracts search criteria, queries MongoDB, formats results.
+HYBRID SEARCH: Uses Qdrant vector search + payload filters for intelligent NLP-based search.
 """
 
 import json
@@ -14,6 +14,7 @@ from app.ai.agent.state import AgentState, FlowState
 from app.ai.agent.validators import JSONValidator
 from app.database import get_db
 from app.config import settings
+from app.ai.services.search_service import search_listings_hybrid, infer_currency_from_location
 
 logger = get_logger(__name__)
 
@@ -25,23 +26,34 @@ llm = ChatOpenAI(
     temperature=0.3,
 )
 
-SEARCH_EXTRACTION_PROMPT = """Extract search criteria from user's query.
+SEARCH_EXTRACTION_PROMPT = """You are extracting search criteria from a natural language property search query.
 
 User message: "{user_message}"
 
-Extract search parameters (set to null if not mentioned):
-- location: City/area name (e.g., "Lagos", "Cotonou") or null
-- min_price: Minimum price or null
-- max_price: Maximum price or null
-- bedrooms: Number of bedrooms or null
-- bathrooms: Number of bathrooms or null
-- listing_type: Type of listing (rent, short-stay, sale, roommate) or null
-- amenities: List of desired amenities or []
+Extract ONLY what is EXPLICITLY mentioned (set to null if not clearly stated):
+- location: City/area/neighborhood name (e.g., "Calavi", "Lagos", "Cotonou", "Victoria Island") or null
+- min_price: Minimum price as number or null
+- max_price: Maximum price as number or null (interpret "20k" as 20000, "of 20k" as max_price: 20000)
+- bedrooms: Minimum number of bedrooms or null  
+- bathrooms: Minimum number of bathrooms or null
+- listing_type: ONLY if explicitly stated. Options: "rent", "short-stay", "sale", "roommate". Set to null otherwise.
+- price_type: Payment frequency or null. Options: "monthly", "weekly", "nightly", "yearly"
+- amenities: List of desired features (e.g., ["wifi", "balcony", "parking"]) or []
 
-Be smart about:
-- Understanding "under 50k" as max_price: 50000
-- "3+ bedrooms" as bedrooms: 3
-- "furnished apartment" as listing_type: rent
+IMPORTANT RULES:
+- Do NOT infer listing_type from words like "house", "apartment", "room" - these are property types, not listing types
+- ONLY set listing_type if user explicitly says "for rent", "to buy", "for sale", "short stay", "roommate"
+- "I want a house of 20k in Cotonou" → listing_type: null (not mentioned)
+- "I want to rent a house" → listing_type: "rent" (explicitly mentioned)
+- "House for sale in Lagos" → listing_type: "sale" (explicitly mentioned)
+
+Price understanding:
+- "50k" or "50K" = 50000
+- "of 20k" or "for 20k" = max_price: 20000
+- "under 50k" or "less than 50k" = max_price: 50000
+- "around 80k" = min_price: 70000, max_price: 90000
+- "per month" = price_type: "monthly"
+- "per night" = price_type: "nightly"
 
 Return ONLY valid JSON:
 {{
@@ -51,6 +63,7 @@ Return ONLY valid JSON:
   "bedrooms": integer or null,
   "bathrooms": integer or null,
   "listing_type": string or null,
+  "price_type": string or null,
   "amenities": []
 }}"""
 
@@ -149,6 +162,11 @@ async def search_listings(search_params: dict) -> list:
         # Execute query with limit
         results = await db.listings.find(query).limit(10).to_list(10)
         
+        # Convert ObjectId to string to prevent serialization errors
+        for item in results:
+            if "_id" in item:
+                item["_id"] = str(item["_id"])
+        
         logger.info("Search completed", results_count=len(results))
         
         return results
@@ -158,68 +176,148 @@ async def search_listings(search_params: dict) -> list:
         return []
 
 
-def format_search_results(listings: list, search_params: dict) -> str:
+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"
+
+USER INFO:
+- Name: {user_name}
+- Query: "{user_query}"
+
+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.)
+
+If no properties found, give helpful suggestions.
+
+Write ONLY the response text, no JSON or formatting instructions."""
+
+
+async def generate_search_results_text(
+    listings: list, 
+    search_params: dict, 
+    user_query: str,
+    user_name: str = None,
+    inferred_currency: str = None
+) -> str:
     """
-    Format search results for display.
+    Use LLM to generate personalized, multilingual search results text.
     
     Args:
         listings: List of matching listings
-        search_params: Original search parameters (for context)
+        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:
-        Formatted string with results
+        LLM-generated response text in user's language
     """
     
-    if not listings:
-        location = search_params.get("location", "that location")
-        return (
-            f"😕 No listings found matching your criteria in {location}.\n\n"
-            "Try:\n"
-            "- Searching in a different area\n"
-            "- Adjusting your price range\n"
-            "- Reducing bedroom/bathroom requirements\n"
-            "- Searching for a different listing type (rent, sale, short-stay, roommate)"
-        )
-    
-    results_text = f"🏠 Found **{len(listings)}** matching listing{'s' if len(listings) != 1 else ''}:\n\n"
+    count = len(listings)
+    location = search_params.get("location", "")
     
-    for i, listing in enumerate(listings, 1):
-        title = listing.get("title", "Untitled")
-        location = listing.get("location", "Unknown")
-        price = listing.get("price", "N/A")
-        currency = listing.get("currency", "")
-        price_type = listing.get("price_type", "")
-        bedrooms = listing.get("bedrooms", "?")
-        bathrooms = listing.get("bathrooms", "?")
-        listing_type = listing.get("listing_type", "").capitalize()
-        images_count = len(listing.get("images", []))
-        
-        results_text += f"""**{i}. {title}**
-📍 {location} | 🛏️ {bedrooms}bd {bathrooms}ba
-💰 {price} {currency}/{price_type} | 🏷️ {listing_type}
-📷 {images_count} image{'s' if images_count != 1 else ''}
-
+    # Build listings summary for LLM
+    if listings:
+        listings_summary = ""
+        for i, listing in enumerate(listings, 1):
+            title = listing.get("title", "Untitled")
+            loc = listing.get("location", "Unknown")
+            price = float(listing.get("price", 0) or 0)
+            currency = listing.get("currency", inferred_currency or "XOF")
+            price_type = listing.get("price_type", "monthly")
+            bedrooms = listing.get("bedrooms", "?")
+            bathrooms = listing.get("bathrooms", "?")
+            amenities = listing.get("amenities", [])
+            description = str(listing.get("description", ""))[:100]
+            
+            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'}
+- Description: {description}...
 """
+    else:
+        listings_summary = f"No properties found matching criteria in {location or 'the specified area'}."
     
-    results_text += (
-        "\n💬 Would you like more details about any of these listings? "
-        "Just ask!\n\n"
-        "📝 Or if you'd like to list your own property, I can help with that too!"
+    # Format prompt
+    prompt = SEARCH_RESULTS_PROMPT.format(
+        user_name=user_name or "there",
+        user_query=user_query,
+        count=count,
+        listings_summary=listings_summary,
+        currency=inferred_currency or "local currency"
     )
     
-    return results_text
+    try:
+        messages = [
+            SystemMessage(content="You are AIDA, a friendly and helpful real estate AI assistant."),
+            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
+        
+    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
 
 
 async def search_query_handler(state: AgentState) -> AgentState:
     """
-    Handle search flow.
+    Handle search flow with HYBRID SEARCH.
     
     Flow:
-    1. Extract search criteria from message
-    2. Query MongoDB
-    3. Format results
-    4. Show to user
-    5. Transition to COMPLETE
+    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
@@ -229,14 +327,14 @@ async def search_query_handler(state: AgentState) -> AgentState:
     """
     
     logger.info(
-        "Handling search query",
+        "Handling search query (HYBRID MODE)",
         user_id=state.user_id,
         message=state.last_user_message[:50]
     )
     
     try:
         # ============================================================
-        # STEP 1: Extract search parameters
+        # STEP 1: Extract search parameters with enhanced LLM
         # ============================================================
         
         search_params = await extract_search_params(state.last_user_message)
@@ -245,9 +343,9 @@ async def search_query_handler(state: AgentState) -> AgentState:
             logger.warning("No search parameters extracted")
             state.temp_data["response_text"] = (
                 "I couldn't understand your search. Try asking:\n"
-                "- \"2-bedroom apartments in Lagos\"\n"
-                "- \"Properties under 50k per month\"\n"
-                "- \"Short-stay rentals with wifi\""
+                "- \"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["action"] = "search_invalid"
             return state
@@ -255,43 +353,74 @@ async def search_query_handler(state: AgentState) -> AgentState:
         logger.info("Search parameters extracted", params=search_params)
         
         # ============================================================
-        # STEP 2: Search MongoDB
+        # STEP 2: Hybrid Search (Qdrant Vector + Filters)
         # ============================================================
         
-        results = await search_listings(search_params)
+        results, inferred_currency = await search_listings_hybrid(
+            user_query=state.last_user_message,
+            search_params=search_params,
+            limit=10
+        )
         
-        logger.info("Search results retrieved", count=len(results))
+        logger.info(
+            "Hybrid search completed",
+            results_count=len(results),
+            currency=inferred_currency
+        )
         
         # ============================================================
-        # STEP 3: Format results
+        # STEP 3: Fallback to MongoDB if Qdrant returns no results
         # ============================================================
         
-        formatted_results = format_search_results(results, search_params)
+        if not results:
+            logger.info("Qdrant returned no results, trying MongoDB fallback")
+            results = await search_listings(search_params)
+            logger.info("MongoDB fallback results", count=len(results))
+        
+        # ============================================================
+        # STEP 4: Generate LLM-based personalized response text
+        # ============================================================
+        
+        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
+        )
         
-        logger.info("Results formatted", length=len(formatted_results))
+        logger.info("LLM results formatted", length=len(formatted_results))
         
         # ============================================================
-        # STEP 4: Store in state
+        # STEP 5: Store in 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 5: Transition to COMPLETE
+        # STEP 6: Transition to SEARCH_RESULTS then IDLE
         # ============================================================
         
-        success, error = state.transition_to(FlowState.COMPLETE, reason="Search completed")
+        # 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 COMPLETE failed", error=error)
+            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(
-            "Search flow completed",
+            "Hybrid search flow completed",
             user_id=state.user_id,
-            results_count=len(results)
+            results_count=len(results),
+            currency=inferred_currency
         )
         
         return state

app/ai/agent/nodes/validate_output.py

@@ -11,6 +11,7 @@ from typing import Dict, Any, Optional, List
 from app.ai.agent.state import AgentState
 from app.ai.agent.validators import ResponseValidator, ListingValidator
 from app.ai.agent.schemas import ListingDraft, ValidationResult
+from app.ai.tools.listing_tool import get_currency_for_location
 
 logger = get_logger(__name__)
 
@@ -202,6 +203,44 @@ async def validate_output_node(state: AgentState) -> AgentState:
             state.set_error("No response text generated", should_retry=True)
             return state
         
+        # ✅ SYNC: Update listing_draft from provided_fields if they differ
+        # This handles the case where user edited a field (e.g., "edit location to Owerri")
+        if state.listing_draft and state.provided_fields:
+            updated_draft = state.listing_draft.copy()
+            needs_update = False
+            
+            # Sync each field from provided_fields to listing_draft
+            sync_fields = ["location", "bedrooms", "bathrooms", "price", "price_type", 
+                          "amenities", "requirements", "images"]
+            for field in sync_fields:
+                if field in state.provided_fields:
+                    provided_val = state.provided_fields[field]
+                    draft_val = updated_draft.get(field)
+                    if provided_val != draft_val:
+                        updated_draft[field] = provided_val
+                        needs_update = True
+                        logger.info(f"🔄 Syncing {field}: {draft_val} → {provided_val}")
+                        
+                        # ⚡ If location changed, recalculate currency
+                        if field == "location":
+                            new_currency = await get_currency_for_location(provided_val)
+                            updated_draft["currency"] = new_currency
+                            logger.info(f"💱 Currency updated: → {new_currency}")
+            
+            # Regenerate title and description if location changed
+            if needs_update:
+                # Update title to reflect new location
+                location = updated_draft.get("location", "Unknown")
+                bedrooms = updated_draft.get("bedrooms", "?")
+                listing_type = updated_draft.get("listing_type", "property")
+                updated_draft["title"] = f"{bedrooms}-Bed {listing_type.capitalize()} in {location}"
+                updated_draft["description"] = f"Beautiful {bedrooms}-bedroom, {updated_draft.get('bathrooms', '?')}-bathroom {listing_type} in {location}. Price: {updated_draft.get('price', '?')} {updated_draft.get('currency', 'NGN')}/{updated_draft.get('price_type', 'monthly')}. Amenities: {', '.join(updated_draft.get('amenities', []) or ['None'])}."
+                
+                state.listing_draft = updated_draft
+                state.temp_data["draft"] = updated_draft
+                draft = updated_draft
+                logger.info("✅ listing_draft synced with provided_fields")
+        
         # ✅ VALIDATE
         validation_result = await OutputValidator.validate_response(
             text=response_text,

app/ai/agent/schemas.py

@@ -32,7 +32,7 @@ class UserMessage(BaseModel):
 
 class Intent(BaseModel):
     """LLM classification output"""
-    type: Literal["greeting", "listing", "search", "casual_chat", "unknown"]
+    type: Literal["greeting", "listing", "search", "my_listings", "edit_listing", "publish", "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
@@ -68,7 +68,7 @@ class ListingDraft(BaseModel):
     bedrooms: int = Field(..., ge=0, le=20)
     bathrooms: int = Field(..., ge=0, le=20)
     price: float = Field(..., gt=0)
-    price_type: Literal["monthly", "yearly", "weekly", "daily", "nightly"]
+    price_type: Literal["monthly", "yearly", "weekly", "daily", "nightly", "one-time"]
     currency: str = Field(..., min_length=3, max_length=3)
     listing_type: Literal["rent", "short-stay", "sale", "roommate"]
     amenities: List[str] = Field(default_factory=list)
@@ -164,6 +164,8 @@ class AgentResponse(BaseModel):
     state: Dict[str, Any] = Field(default_factory=dict)
     draft: Optional[ListingDraft] = None
     draft_ui: Optional[Dict[str, Any]] = None
+    search_results: Optional[List[Dict[str, Any]]] = None  # For search results cards
+    my_listings: Optional[List[Dict[str, Any]]] = None  # For user's own listings
     tool_result: Optional[ToolResult] = None
     error: Optional[str] = None
     metadata: Dict[str, Any] = Field(default_factory=dict)

app/ai/agent/state.py

@@ -30,6 +30,12 @@ class FlowState(str, Enum):
     SEARCH_QUERY = "search_query"
     SEARCH_RESULTS = "search_results"
     
+    # My Listings flow
+    MY_LISTINGS = "my_listings"
+    
+    # Edit Listing flow
+    EDIT_LISTING = "edit_listing"
+    
     # Other flows
     GREETING = "greeting"
     CASUAL_CHAT = "casual_chat"
@@ -51,6 +57,10 @@ class AgentState(BaseModel):
     session_id: str
     user_role: str
     
+    # Personalization (optional - from login)
+    user_name: Optional[str] = None
+    user_location: Optional[str] = None
+    
     # Current flow tracking
     current_flow: FlowState = FlowState.IDLE
     previous_flow: Optional[FlowState] = None
@@ -67,6 +77,9 @@ class AgentState(BaseModel):
     search_query: Optional[str] = None
     search_results: List[Dict[str, Any]] = Field(default_factory=list)
     
+    # My listings data
+    my_listings: List[Dict[str, Any]] = Field(default_factory=list)
+    
     # Conversation context
     conversation_history: List[Dict[str, str]] = Field(default_factory=list)
     language_detected: str = "en"
@@ -104,7 +117,10 @@ class AgentState(BaseModel):
             FlowState.CLASSIFY_INTENT: [
                 FlowState.GREETING,
                 FlowState.LISTING_COLLECT,
+                FlowState.LISTING_PUBLISH,
                 FlowState.SEARCH_QUERY,
+                FlowState.MY_LISTINGS,  # Added for my listings
+                FlowState.EDIT_LISTING,  # Added for edit listing
                 FlowState.CASUAL_CHAT,
                 FlowState.ERROR,
             ],
@@ -141,6 +157,18 @@ class AgentState(BaseModel):
                 FlowState.CLASSIFY_INTENT,
                 FlowState.ERROR,
             ],
+            # My Listings flow
+            FlowState.MY_LISTINGS: [
+                FlowState.IDLE,
+                FlowState.CLASSIFY_INTENT,
+                FlowState.ERROR,
+            ],
+            # Edit Listing flow
+            FlowState.EDIT_LISTING: [
+                FlowState.LISTING_COLLECT,  # Goes to listing collect for edits
+                FlowState.IDLE,
+                FlowState.ERROR,
+            ],
             FlowState.CASUAL_CHAT: [
                 FlowState.IDLE,
                 FlowState.CLASSIFY_INTENT,

app/ai/prompts/system_prompt.py

@@ -1,7 +1,7 @@
 # app/ai/prompts/system_prompt.py
 # FINAL: Simplified listing flow - show example, collect fields, auto-detect everything
 
-def get_system_prompt(user_role: str = "landlord") -> str:
+def get_system_prompt(user_role: str = "landlord", user_name: str = None, user_location: str = None) -> str:
     """
     Get Aida's system prompt - UPDATED for simplified listing flow.
     
@@ -12,9 +12,12 @@ def get_system_prompt(user_role: str = "landlord") -> str:
     - Auto-generate: title (short, contains location), description (clean, detailed)
     - NO asking for property type - it's auto-detected
     - Handle image URLs from Cloudflare (client-side upload)
+    - PERSONALIZE greetings and examples using user's name and location (if available)
     
     Args:
         user_role: "landlord" or "renter"
+        user_name: User's first name (optional, for personalized greetings)
+        user_location: User's city/location (optional, for relevant examples)
     
     Returns:
         System prompt string for LLM
@@ -22,14 +25,65 @@ def get_system_prompt(user_role: str = "landlord") -> str:
     
     role_upper = user_role.upper()
     
+    # Build personalization section
+    personalization_section = ""
+    if user_name or user_location:
+        personalization_section = """
+========== PERSONALIZATION ==========
+"""
+        if user_name:
+            personalization_section += f"""USER'S NAME: {user_name}
+- Use their name occasionally in greetings and responses (e.g., "Hi {user_name}!", "Great choice, {user_name}!")
+- Don't overuse it - once or twice per conversation is natural
+- If name seems like a full name, use just the first part
+"""
+        if user_location:
+            personalization_section += f"""USER'S LOCATION: {user_location}
+- When generating listing examples, use cities/areas near {user_location} (same country/region)
+- Use the local currency for that region in examples
+- Make examples feel relevant and realistic for their area
+- Example: If user is in Cotonou, use Cotonou, Calavi, Porto-Novo, etc.
+- Example: If user is in Lagos, use Lekki, Victoria Island, Ikeja, Surulere, etc.
+"""
+    else:
+        personalization_section = """
+========== PERSONALIZATION ==========
+No personalization data available. Use generic greetings and varied global examples.
+"""
+    
     return f"""You are AIDA, a friendly and professional real estate AI assistant for the Lojiz platform.
+{personalization_section}
 
 ========== WHO YOU ARE ==========
 Name: AIDA (Lojiz AI)
-Created by: Lojiz team
-Specialty: Real estate assistance
+Created by: The Lojiz Team
+Specialty: Real estate assistance for property listing, search, and house hunting
 Important: NEVER claim to be another AI (DeepSeek, GPT, Claude, etc.)
 
+========== ABOUT LOJIZ ==========
+Lojiz is an innovative startup on a mission to revolutionize house hunting worldwide. We're bridging the gap in property search and listing by leveraging the power of AI to make finding, listing, and renting properties easier than ever before.
+
+When someone asks "What is Lojiz?", respond naturally with something like:
+- "Lojiz is a real estate platform that uses AI to make house hunting and property listing simple and seamless. Whether you're looking for a rental, listing a property, or searching for a roommate, we've got you covered!"
+- "We're a startup focused on making the entire real estate experience smoother - from listing to searching to renting. AI-powered, global, and user-friendly."
+
+You can phrase it differently each time, but always convey:
+1. Lojiz uses AI to simplify real estate
+2. We help with both listing AND searching for properties
+3. We aim to serve users worldwide
+4. We make house hunting easier and more accessible
+
+========== ABOUT THE TEAM ==========
+When someone asks "Who made Lojiz?", "Who are the developers?", "Who works at Lojiz?", or similar questions:
+
+Answer: "Lojiz was built by the **Lojiz Team** - a talented group of developers, product designers, and innovators passionate about transforming real estate with technology."
+
+You can also say:
+- "The Lojiz Team is behind everything you see here - developers, designers, and people who care about making your property journey seamless."
+- "A dedicated team of engineers and designers at Lojiz created me and this platform!"
+
+IMPORTANT: Always credit "The Lojiz Team" - never mention individual names unless explicitly asked.
+
 ========== YOUR PERSONALITY ==========
 - Warm, friendly, and professional
 - Speak naturally (short sentences, conversational)
@@ -78,10 +132,17 @@ REQUIRED FIELDS TO COLLECT:
 - Bedrooms (number like 2, 3, 4)
 - Bathrooms (number like 1, 2, 3)
 - Price (amount like 50000, 1200, 500)
-- Price Type (user MUST provide: "monthly", "yearly", "weekly", "daily", "nightly")
+- Price Type:
+  * For RENTALS: Ask user - "monthly", "yearly", "weekly", "daily", "nightly"
+  * For SALES: Auto-set to "one-time" - NEVER ASK! Sale = one-time purchase.
 - Amenities (optional but ask: wifi, parking, furnished, washing machine, ac, balcony, etc.)
 - Requirements (optional but ask: "3-month deposit", "no pets", "stable income", etc.)
 
+IMPORTANT SALE HANDLING:
+- If user says "for sale", "sell", "selling" → listing_type = "sale", price_type = "one-time"
+- DO NOT ask "is it monthly or yearly?" for sales - sales are ALWAYS one-time purchases!
+- Only ask price_type for rentals/short-stays
+
 HOW TO COLLECT:
 - User can provide multiple fields: "2-bed, 1-bath in Lagos for 50k per month"
 - Extract ALL provided fields from that message
@@ -138,12 +199,16 @@ Description Generation:
 - 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."
 
-STEP 5: SHOW DRAFT PREVIEW
+STEP 5: WHEN ALL FIELDS COLLECTED
 Once all required fields complete:
-- Generate draft with auto-detected fields
-- Format preview nicely with emoji icons
-- Show: title, description, location, bedrooms, bathrooms, price, amenities, requirements, images count
-- Ask: "Ready to publish? Say 'publish', or 'edit [field]' to change, or 'discard' to cancel."
+- Say a SHORT confirmation message like "Perfect! Here's your listing preview:"
+- DO NOT write out the draft in text - the UI will display a visual card automatically
+- Just ask: "Ready to publish? Say 'publish', 'edit [field]' to change, or 'discard' to cancel."
+
+DO NOT generate a text-based preview like:
+❌ "DRAFT PREVIEW: 🏠 4-Bed in Lagos 📍 Lagos | 🛏️ 4 beds..."
+
+✅ Instead, just say: "Perfect! Here's your listing preview. Ready to publish?"
 
 STEP 6: USER ACTIONS
 

app/ai/routes/chat.py

@@ -1,483 +1,478 @@
-# app/ai/routes/chat.py - LLM-POWERED Intent Detection & Routing (FIXED ASYNC)
+# app/ai/routes/chat.py
+"""
+AIDA Chat Endpoint - LangGraph Powered (PRIMARY)
+FIXED: Properly handles recursion limit and dict output from graph.ainvoke()
+"""
 
-from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
-from fastapi.security import HTTPBearer
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
-from typing import Optional, Dict, Any, List
+from typing import Optional, Dict, Any
 from structlog import get_logger
-from datetime import datetime, timedelta
-import os
+from uuid import uuid4
+from datetime import datetime
+from langgraph.types import Command
 
-# LangSmith tracing
-os.environ["LANGCHAIN_TRACING_V2"] = "true"
-os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGCHAIN_API_KEY", "")
-
-from app.guards.jwt_guard import decode_access_token
-from app.ai.memory.redis_context_memory import get_current_memory
-from app.ai.tools.intent_detector_tool import process_user_message
-from app.ai.tools.listing_tool import process_listing
-from app.ai.tools.greeting_tool import process_greeting, is_greeting
-from app.ai.memory.redis_memory import is_rate_limited
+from app.ai.agent.graph import get_aida_graph
+from app.ai.agent.schemas import AgentResponse
 
 logger = get_logger(__name__)
 
 router = APIRouter()
-security = HTTPBearer()
 
-# ========== REQUEST/RESPONSE MODELS ==========
+
+# ============================================================
+# REQUEST/RESPONSE MODELS
+# ============================================================
 
 class AskBody(BaseModel):
+    """Request body for /ask endpoint"""
     message: str
     session_id: Optional[str] = None
-    thread_id: Optional[str] = None
+    user_id: Optional[str] = None
+    user_role: Optional[str] = "renter"
     start_new_session: Optional[bool] = False
+    user_name: Optional[str] = None
+    user_location: Optional[str] = None
 
 
-class ChatResponse(BaseModel):
-    success: bool
-    text: str
-    action: str
-    state: Optional[Dict[str, Any]] = None
-    draft: Optional[Dict[str, Any]] = None
-    draft_ui: Optional[Dict[str, Any]] = None
-    mongo_id: Optional[str] = None
-    error: Optional[str] = None
-
-
-# ========== INTENT DETECTION (LLM-POWERED) ==========
-
-def user_wants_fresh_start(message: str) -> bool:
-    message_lower = message.lower().strip()
-    keywords = ["start fresh", "new listing", "clear", "reset", "start over", "new conversation"]
-    return any(keyword in message_lower for keyword in keywords)
-
-
-def is_listing_intent(message: str) -> bool:
-    message_lower = message.lower().strip()
-    intents = ["list", "post", "create", "add property", "sell", "rent out", "want to list", "list my"]
-    return any(intent in message_lower for intent in intents)
-
-
-def is_publish_intent(message: str) -> bool:
-    message_lower = message.lower().strip()
-    publish_variants = ["publish", "publsih", "post", "confirm", "list it", "go live", "submit"]
-    return any(variant in message_lower for variant in publish_variants)
-
-
-def is_edit_intent(message: str) -> bool:
-    return message.lower().strip().startswith("edit ")
-
+# ============================================================
+# MAIN CHAT ENDPOINT - LANGGRAPH POWERED (FIXED)
+# ============================================================
 
-def is_discard_intent(message: str) -> bool:
-    message_lower = message.lower().strip()
-    discards = ["discard", "cancel", "delete", "remove", "clear", "start over", "trash"]
-    return message_lower in discards or any(discard in message_lower for discard in discards)
-
-
-# ========== CONTEXT MANAGEMENT ==========
-
-async def is_context_idle(context: Dict, idle_threshold_minutes: int = 30) -> bool:
-    if not context or not context.get("last_activity"):
-        return False
-    try:
-        last_activity = datetime.fromisoformat(context["last_activity"])
-        idle_time = datetime.utcnow() - last_activity
-        if idle_time > timedelta(minutes=idle_threshold_minutes):
-            logger.info("Context idle, resetting", idle_minutes=idle_time.total_seconds() / 60)
-            return True
-        return False
-    except Exception as e:
-        logger.warning(f"Could not check idle time: {e}")
-        return False
-
-
-def reset_context() -> Dict:
-    return {
-        "status": "idle",
-        "language": "en",
-        "user_role": None,
-        "draft": None,
-        "state": {},
-        "last_activity": datetime.utcnow().isoformat(),
-    }
-
-
-# ========== MAIN CHAT ENDPOINT ==========
-
-@router.post("/ask", response_model=ChatResponse)
-async def ask_ai(
-    body: AskBody,
-    token: str = Depends(security),
-    background_tasks: BackgroundTasks = BackgroundTasks(),
-) -> ChatResponse:
+@router.post("/ask", response_model=AgentResponse)
+async def ask_ai(body: AskBody) -> AgentResponse:
     """
-    LLM-POWERED chat endpoint with intelligent intent routing:
-    Priority Order:
-    1. If draft exists → Handle publish/edit/discard (LLM-powered)
-    2. If in listing mode → Process as listing (LLM-powered)
-    3. AI-powered greeting detection (LLM-based)
-    4. Listing intent (new) → Start listing (LLM-powered)
-    5. Default → LangChain agent (LLM-powered)
+    Main chat endpoint using LangGraph state machine.
+    
+    CRITICAL FIXES:
+    - Set recursion_limit to 50 (prevents infinite loops)
+    - graph.ainvoke() returns a DICT, not AgentState object
+    - Access dict keys with ['key'], not .attribute
+    - Extract response from dict['temp_data']['final_response']
+    
+    Flow:
+    1. Validate input
+    2. Build input dict
+    3. Invoke graph with dict input and high recursion_limit
+    4. Extract final_response from returned dict
+    5. Return to client
     """
+    
+    logger.info("🚀 Chat request received", message_len=len(body.message))
+    
     try:
-        # AUTHENTICATE
-        payload = decode_access_token(token.credentials)
-        if not payload:
-            logger.warning("Invalid token")
-            raise HTTPException(status_code=401, detail="Invalid token")
-        user_id = payload["user_id"]
-        user_role = payload.get("role", "renter")
-
-        # RATE LIMIT
-        if await is_rate_limited(user_id):
-            logger.warning("Rate limit exceeded", user_id=user_id)
-            raise HTTPException(status_code=429, detail="Rate limit exceeded")
-
-        # GET MEMORY
-        session_id = body.session_id or "default"
-        memory = await get_current_memory(user_id, session_id)
-        context = await memory.get_context()
-        logger.info("Chat message received", user_id=user_id, session_id=session_id, status=context.get("status"))
-
-        # CHECK RESET
-        should_reset = (
-            body.start_new_session or
-            user_wants_fresh_start(body.message) or
-            await is_context_idle(context, idle_threshold_minutes=30)
-        )
-        if should_reset:
-            logger.info("Resetting context", user_id=user_id)
-            context = reset_context()
-            context["user_role"] = user_role
-            await memory.update_context(context)
-            await memory.clear()
-
-        # INIT CONTEXT IF NEW
-        if not context:
-            context = reset_context()
-            context["user_role"] = user_role
-            await memory.update_context(context)
-
-        # VALIDATE MESSAGE
-        if not body.message or body.message.strip() == "":
-            return ChatResponse(success=False, text="Please provide a message.", action="error", error="Empty message")
-
-        # GET HISTORY
-        messages = await memory.get_messages()
-
-        # ========== LLM-POWERED INTENT ROUTING ==========
-
-        # ✅ PRIORITY 1: Handle draft actions (LLM-powered detection)
-        if is_publish_intent(body.message) and context.get("draft"):
-            logger.info("Publish intent detected (LLM-powered)", user_id=user_id)
-            draft = context.get("draft")
-            try:
-                # ✅ SAVE TO MONGODB (FIXED ASYNC - AWAIT ADDED!)
-                from motor.motor_asyncio import AsyncIOMotorDatabase
-                from app.database import get_db
-                db = await get_db()  # ✅ FIXED: Added await
-                listing_data = {
-                    "user_id": draft["user_id"],
-                    "user_role": draft["user_role"],
-                    "title": draft["title"],
-                    "description": draft["description"],
-                    "location": draft["location"],
-                    "bedrooms": int(draft["bedrooms"]),
-                    "bathrooms": int(draft["bathrooms"]),
-                    "price": float(draft["price"]),
-                    "price_type": draft["price_type"],
-                    "currency": draft["currency"],
-                    "listing_type": draft["listing_type"],
-                    "amenities": draft.get("amenities", []),
-                    "requirements": draft.get("requirements"),
-                    "images": draft.get("images", []),
-                    "status": "active",
-                    "created_at": datetime.utcnow(),
-                    "updated_at": datetime.utcnow(),
-                }
-                result = await db.listings.insert_one(listing_data)  # ✅ FIXED: Added await
-                listing_id = str(result.inserted_id)
-                logger.info("✅ Listing published successfully", user_id=user_id, listing_id=listing_id)
-                context["status"] = "idle"
-                context["listing_state"] = {}
-                context["draft"] = None
-                context["editing_field"] = None
-                context["last_activity"] = datetime.utcnow().isoformat()
-                await memory.update_context(context)
-                await memory.add_message("user", body.message)
-                reply = f"🎉 Your listing '{draft['title']}' is now live! View it in your listings."
-                await memory.add_message("assistant", reply)
-                return ChatResponse(success=True, text=reply, action="published", state=context, mongo_id=listing_id)
-            except Exception as e:
-                logger.error("Failed to publish listing", exc_info=e)
-                return ChatResponse(success=False, text="Sorry, I couldn't publish your listing. Please try again.", action="error", state=context, error=str(e))
-
-        # EDIT (LLM-powered detection)
-        if is_edit_intent(body.message) and context.get("draft"):
-            logger.info("Edit intent detected (LLM-powered)", user_id=user_id)
-            field_to_edit = body.message[5:].strip()
-            context["editing_field"] = field_to_edit
-            context["last_activity"] = datetime.utcnow().isoformat()
-            await memory.update_context(context)
-            reply = f"What would you like to change the {field_to_edit} to?"
-            await memory.add_message("user", body.message)
-            await memory.add_message("assistant", reply)
-            return ChatResponse(success=True, text=reply, action="editing", state=context)
-
-        # APPLY EDIT (LLM-powered field update)
-        if context.get("editing_field") and context.get("draft"):
-            logger.info("Applying edit (LLM-powered)", user_id=user_id)
-            editing_field = context.get("editing_field")
-            draft = context["draft"]
-            new_value = body.message.strip()
-            if editing_field in ["price", "bedrooms", "bathrooms"]:
-                try:
-                    draft[editing_field] = int(new_value) if editing_field != "price" else float(new_value)
-                except ValueError:
-                    draft[editing_field] = new_value
-            else:
-                draft[editing_field] = new_value
-            context["editing_field"] = None
-            context["draft"] = draft
-            context["last_activity"] = datetime.utcnow().isoformat()
-            await memory.update_context(context)
-            reply = "✅ Updated! Here's your revised draft:"
-            await memory.add_message("user", body.message)
-            await memory.add_message("assistant", reply)
-            return ChatResponse(success=True, text=reply, action="show_draft", state=context, draft=draft)
-
-        # DISCARD (LLM-powered detection)
-        if is_discard_intent(body.message) and context.get("draft"):
-            logger.info("Discard intent detected (LLM-powered)", user_id=user_id)
-            context["status"] = "idle"
-            context["listing_state"] = {}
-            context["draft"] = None
-            context["editing_field"] = None
-            context["last_activity"] = datetime.utcnow().isoformat()
-            await memory.update_context(context)
-            reply = "Draft cleared. What would you like to do next?"
-            await memory.add_message("user", body.message)
-            await memory.add_message("assistant", reply)
-            return ChatResponse(success=True, text=reply, action="draft_discarded", state=context)
-
-        # ✅ PRIORITY 2: Continue listing (if in progress)
-        if context.get("status") == "listing":
-            logger.info("Continuing listing flow (LLM-powered)", user_id=user_id)
-            listing_state = context.get("listing_state", {
-                "step": "initial",
-                "provided_fields": {},
-                "images": [],
-            })
-            result = await process_listing(
-                user_message=body.message,
-                user_id=user_id,
-                user_role=user_role,
-                current_state=listing_state,
+        # ============================================================
+        # STEP 1: Validate input
+        # ============================================================
+        
+        if not body.message or not body.message.strip():
+            logger.warning("❌ Empty message received")
+            return AgentResponse(
+                success=False,
+                text="Please provide a message.",
+                action="error",
+                error="Empty message",
             )
-            context["status"] = "listing"
-            context["listing_state"] = result.get("state", {})
-            context["last_activity"] = datetime.utcnow().isoformat()
-            if result.get("draft"):
-                context["draft"] = result["draft"]
-            await memory.update_context(context)
-            await memory.add_message("user", body.message)
-            await memory.add_message("assistant", result["reply"])
-            return ChatResponse(
-                success=result.get("success", True),
-                text=result["reply"],
-                action=result["action"],
-                state=context,
-                draft=result.get("draft"),
-                draft_ui=result.get("draft_ui"),
-                error=result.get("error")
+        
+        message = body.message.strip()
+        session_id = body.session_id or str(uuid4())
+        user_id = body.user_id or f"anonymous_{uuid4()}"
+        user_role = body.user_role or "renter"
+        
+        logger.info(
+            "📋 User session info",
+            user_id=user_id,
+            session_id=session_id,
+            user_role=user_role,
+            message_len=len(message),
+        )
+        
+        # ============================================================
+        # STEP 2: Build input dict for graph
+        # ============================================================
+        # ✅ CRITICAL: Pass dict, not AgentState
+        
+        input_dict = {
+            "user_id": user_id,
+            "session_id": session_id,
+            "user_role": user_role,
+            "user_name": body.user_name,
+            "user_location": body.user_location,
+            "last_user_message": message,
+            # "conversation_history": [],  <-- REMOVED: Do not overwrite history!
+            "language_detected": "en",
+            "start_new_session": body.start_new_session or False,
+        }
+        
+        # Only initialize history if starting new session
+        if body.start_new_session:
+            input_dict["conversation_history"] = []
+            input_dict["provided_fields"] = {}
+            input_dict["missing_required_fields"] = []
+            logger.info("🆕 Starting NEW session (clearing state)")
+        
+        logger.info("📦 Input dict prepared", keys=list(input_dict.keys()))
+        
+        # ============================================================
+        # STEP 3: Get graph and validate
+        # ============================================================
+        
+        try:
+            graph = get_aida_graph()
+            
+            if graph is None:
+                logger.error("❌ Graph is None!")
+                return AgentResponse(
+                    success=False,
+                    text="System error: Graph not initialized",
+                    action="error",
+                    error="Graph initialization failed",
+                )
+            
+            logger.info("✅ Graph retrieved successfully")
+            
+        except Exception as e:
+            logger.error("❌ Graph retrieval failed", exc_info=e)
+            return AgentResponse(
+                success=False,
+                text=f"System error: {str(e)}",
+                action="error",
+                error=str(e),
             )
-
-        # ✅ PRIORITY 3: AI-powered greeting detection
-        greeting_detected = await is_greeting(body.message)
-        if greeting_detected:
-            logger.info("Greeting detected (AI-powered)", user_id=user_id)
-            greeting_result = await process_greeting(
-                user_message=body.message,
-                user_id=user_id,
-                user_role=user_role
+        
+        # ============================================================
+        # STEP 4: Invoke graph with dict input
+        # ============================================================
+        
+        logger.info("🔄 Invoking LangGraph...", user_id=user_id)
+        
+        try:
+            # ✅ CRITICAL FIX: Pass recursion_limit config to prevent infinite loops
+            # ✅ CRITICAL FIX: Pass thread_id for persistence
+            config = {
+                "recursion_limit": 50,
+                "configurable": {"thread_id": session_id}
+            }
+            
+            final_state_dict = await graph.ainvoke(
+                input_dict,
+                config=config
             )
-            await memory.add_message("user", body.message)
-            await memory.add_message("assistant", greeting_result["reply"])
-            context["last_activity"] = datetime.utcnow().isoformat()
-            context["status"] = greeting_result["state"].get("status", "idle")
-            await memory.update_context(context)
-            return ChatResponse(
-                success=greeting_result["success"],
-                text=greeting_result["reply"],
-                action="greeting",
-                state=context,
+            
+            # ✅ CRITICAL: final_state_dict is a DICT, not AgentState!
+            # Access with dict keys: ['key'], not .attribute
+            
+            logger.info(
+                "✅ LangGraph execution completed",
+                flow=final_state_dict.get("current_flow", {}).get("value") if isinstance(final_state_dict.get("current_flow"), dict) else str(final_state_dict.get("current_flow")),
+                steps=final_state_dict.get("steps_taken"),
+                has_error=final_state_dict.get("last_error") is not None,
             )
-
-        # ✅ PRIORITY 4: New listing intent (LLM-powered)
-        if is_listing_intent(body.message):
-            logger.info("Listing intent detected (LLM-powered)", user_id=user_id)
-            listing_state = {
-                "step": "initial",
-                "provided_fields": {},
-                "images": [],
-            }
-            result = await process_listing(
-                user_message=body.message,
-                user_id=user_id,
-                user_role=user_role,
-                current_state=listing_state,
+            
+        except Exception as e:
+            logger.error("❌ Graph execution failed", exc_info=e)
+            
+            # Check if it's a recursion error
+            if "recursion" in str(e).lower():
+                logger.error("⚠️ Graph hit recursion limit - check for infinite loops in listing_collect")
+                return AgentResponse(
+                    success=False,
+                    text="System is processing your request too long. This usually means you're in the listing flow. Please try again or provide more details.",
+                    action="error",
+                    error="Recursion limit exceeded - infinite loop detected",
+                )
+            
+            return AgentResponse(
+                success=False,
+                text="Error processing your request. Please try again.",
+                action="error",
+                error=str(e),
             )
-            context["status"] = "listing"
-            context["listing_state"] = result.get("state", {})
-            context["last_activity"] = datetime.utcnow().isoformat()
-            if result.get("draft"):
-                context["draft"] = result["draft"]
-            await memory.update_context(context)
-            await memory.add_message("user", body.message)
-            await memory.add_message("assistant", result["reply"])
-            return ChatResponse(
-                success=result.get("success", True),
-                text=result["reply"],
-                action=result["action"],
-                state=context,
-                draft=result.get("draft"),
-                draft_ui=result.get("draft_ui"),
-                error=result.get("error")
+        
+        # ============================================================
+        # STEP 5: Extract response from final state dict
+        # ============================================================
+        
+        # ✅ Access dict['key'] not dict.key
+        temp_data = final_state_dict.get("temp_data", {})
+        final_response = temp_data.get("final_response")
+        
+        if final_response:
+            logger.info(
+                "✅ Response extracted from state",
+                action=final_response.action if hasattr(final_response, 'action') else "unknown",
+                success=final_response.success if hasattr(final_response, 'success') else False,
             )
-
-        # ✅ PRIORITY 5: Default → LangChain Agent (LLM-powered)
+            return final_response
+        
+        # ============================================================
+        # FALLBACK: Build response manually if not in temp_data
+        # ============================================================
+        
+        logger.warning("⚠️ No final_response in temp_data, building manually")
+        
+        response_text = temp_data.get("response_text", "")
+        if not response_text:
+            response_text = "I'm here to help! What would you like to do?"
+        
+        # Get flow state - handle both FlowState enum and string
+        current_flow = final_state_dict.get("current_flow")
+        if hasattr(current_flow, 'value'):
+            flow_str = current_flow.value
         else:
-            logger.info("Processing with LangChain Agent (LLM-powered)", user_id=user_id)
-            try:
-                reply, tool_result = await process_user_message(
-                    user_message=body.message,
-                    user_id=user_id,
-                    user_role=user_role,
-                    conversation_history=messages,
-                    conversation_context=context
-                )
-                await memory.add_message("user", body.message)
-                await memory.add_message("assistant", reply)
-                context["last_activity"] = datetime.utcnow().isoformat()
-                if "tool" in tool_result:
-                    context["last_tool"] = tool_result["tool"]
-                await memory.update_context(context)
-                return ChatResponse(
-                    success=tool_result.get("success", True),
-                    text=reply,
-                    action=tool_result.get("tool", "response"),
-                    state=context,
-                    error=tool_result.get("error")
-                )
-            except Exception as e:
-                logger.error("LangChain processing error", exc_info=e)
-                fallback_reply = "Sorry, I had an error processing your request. Please try again."
-                await memory.add_message("user", body.message)
-                await memory.add_message("assistant", fallback_reply)
-                context["last_activity"] = datetime.utcnow().isoformat()
-                await memory.update_context(context)
-                return ChatResponse(success=False, text=fallback_reply, action="error", state=context, error=str(e))
-
+            flow_str = str(current_flow)
+        
+        response = AgentResponse(
+            success=final_state_dict.get("last_error") is None,
+            text=response_text,
+            action=temp_data.get("action", flow_str),
+            state={
+                "flow": flow_str,
+                "steps": final_state_dict.get("steps_taken", 0),
+                "errors": final_state_dict.get("error_count", 0),
+            },
+            draft=temp_data.get("draft"),
+            draft_ui=temp_data.get("draft_ui"),
+            error=final_state_dict.get("last_error"),
+            metadata={
+                "intent": final_state_dict.get("intent_type"),
+                "intent_confidence": final_state_dict.get("intent_confidence", 0),
+                "language": final_state_dict.get("language_detected", "en"),
+                "messages_in_session": len(final_state_dict.get("conversation_history", [])),
+                "user_id": user_id,
+                "session_id": session_id,
+                "replace_last_message": temp_data.get("replace_last_message", False),
+            }
+        )
+        
+        logger.info("✅ Fallback response built", action=response.action)
+        
+        return response
+    
     except HTTPException:
         raise
     except Exception as e:
-        logger.error("Chat endpoint error", exc_info=e)
-        raise HTTPException(status_code=500, detail=f"Error processing message: {str(e)}")
+        logger.error("❌ Chat endpoint critical error", exc_info=e)
+        return AgentResponse(
+            success=False,
+            text="An unexpected error occurred. Please try again.",
+            action="error",
+            error=str(e),
+        )
 
 
-# ========== HEALTH CHECK ==========
+# ============================================================
+# HEALTH CHECK
+# ============================================================
 
 @router.get("/health")
-async def health_check():
-    """Health check for chat service"""
-    return {
-        "status": "healthy",
-        "service": "Aida Chat with LLM-Powered Intent Detection",
-        "langsmith": "enabled" if os.getenv("LANGCHAIN_API_KEY") else "disabled",
-        "intent_detection": "llm-powered",
-        "draft_handling": "intelligent",
-    }
+async def health_check() -> Dict[str, Any]:
+    """Health check for AIDA chat service"""
+    
+    try:
+        graph = get_aida_graph()
+        
+        return {
+            "status": "healthy",
+            "service": "AIDA Chat (LangGraph)",
+            "version": "2.0.0",
+            "graph_available": graph is not None,
+            "recursion_limit_config": "50",
+            "timestamp": datetime.utcnow().isoformat(),
+        }
+    except Exception as e:
+        logger.error("❌ Health check failed", exc_info=e)
+        return {
+            "status": "unhealthy",
+            "error": str(e),
+            "timestamp": datetime.utcnow().isoformat(),
+        }
 
 
-# ========== CHAT HISTORY ==========
+# ============================================================
+# HISTORY ENDPOINT
+# ============================================================
 
 @router.get("/history/{session_id}")
-async def get_chat_history(
-    session_id: str,
-    token: str = Depends(security),
-):
-    """Get chat history for a session"""
+async def get_history(session_id: str) -> Dict[str, Any]:
+    """Get conversation history for a session"""
+    
     try:
-        payload = decode_access_token(token.credentials)
-        if not payload:
-            raise HTTPException(status_code=401, detail="Invalid token")
-        user_id = payload["user_id"]
-        memory = await get_current_memory(user_id, session_id)
-        messages = await memory.get_messages()
-        summary = await memory.get_summary()
-        logger.info("Retrieved chat history", user_id=user_id, message_count=len(messages))
+        logger.info("📖 History requested", session_id=session_id)
+        
         return {
             "success": True,
-            "summary": summary,
-            "messages": messages,
+            "session_id": session_id,
+            "messages": [],
+            "note": "History persistence not yet implemented"
         }
-    except HTTPException:
-        raise
+    
     except Exception as e:
-        logger.error("Failed to get history", exc_info=e)
-        raise HTTPException(status_code=500, detail="Failed to retrieve history")
+        logger.error("❌ History retrieval error", exc_info=e)
+        return {
+            "success": False,
+            "error": str(e),
+        }
 
 
-# ========== SESSION MANAGEMENT ==========
+# ============================================================
+# SESSION MANAGEMENT
+# ============================================================
 
-@router.post("/close-session/{session_id}")
-async def close_session(
-    session_id: str,
-    token: str = Depends(security),
-):
-    """Close/clear a chat session"""
+@router.post("/reset-session/{session_id}")
+async def reset_session(session_id: str) -> Dict[str, Any]:
+    """Reset a session to fresh state"""
+    
     try:
-        payload = decode_access_token(token.credentials)
-        if not payload:
-            raise HTTPException(status_code=401, detail="Invalid token")
-        user_id = payload["user_id"]
-        from app.ai.memory.redis_context_memory import get_memory_manager
-        manager = get_memory_manager()
-        await manager.close_session(user_id, session_id)
-        logger.info("Session closed", user_id=user_id, session_id=session_id)
-        return {"success": True, "message": "Session closed"}
-    except HTTPException:
-        raise
+        logger.info("🔄 Session reset requested", session_id=session_id)
+        
+        return {
+            "success": True,
+            "message": "Session reset to fresh state",
+            "session_id": session_id,
+            "timestamp": datetime.utcnow().isoformat(),
+        }
+    
     except Exception as e:
-        logger.error("Failed to close session", exc_info=e)
-        raise HTTPException(status_code=500, detail="Failed to close session")
+        logger.error("❌ Session reset error", exc_info=e)
+        return {
+            "success": False,
+            "error": str(e),
+        }
 
 
-@router.post("/reset-session/{session_id}")
-async def reset_session_endpoint(
-    session_id: str,
-    token: str = Depends(security),
-):
-    """Explicitly reset a session to fresh state"""
+@router.post("/close-session/{session_id}")
+async def close_session(session_id: str) -> Dict[str, Any]:
+    """Close a session"""
+    
     try:
-        payload = decode_access_token(token.credentials)
-        if not payload:
-            raise HTTPException(status_code=401, detail="Invalid token")
-        user_id = payload["user_id"]
-        user_role = payload.get("role", "renter")
-        memory = await get_current_memory(user_id, session_id)
-        await memory.clear()
-        fresh_context = reset_context()
-        fresh_context["user_role"] = user_role
-        await memory.update_context(fresh_context)
-        logger.info("Session reset to fresh state", user_id=user_id, session_id=session_id)
+        logger.info("❌ Session closed", session_id=session_id)
+        
         return {
             "success": True,
-            "message": "Session reset to fresh state",
-            "context": fresh_context
+            "message": "Session closed",
+            "session_id": session_id,
+            "timestamp": datetime.utcnow().isoformat(),
         }
-    except HTTPException:
-        raise
+    
+    except Exception as e:
+        logger.error("❌ Session close error", exc_info=e)
+        return {
+            "success": False,
+            "error": str(e),
+        }
+
+
+# ============================================================
+# IMAGE UPLOAD ENDPOINTS (For Cloudflare Worker Integration)
+# ============================================================
+
+class ImageNameRequest(BaseModel):
+    """Request for getting image name from current listing context"""
+    user_id: str
+    session_id: str
+
+
+class ImageUploadResult(BaseModel):
+    """Result from Cloudflare Worker image upload"""
+    success: bool
+    url: Optional[str] = None
+    id: Optional[str] = None
+    filename: Optional[str] = None
+    error: Optional[str] = None
+    reason: Optional[str] = None
+    message: Optional[str] = None  # User's original message
+    operation: Optional[str] = "add"  # "add" or "replace"
+    replace_index: Optional[int] = None
+    user_id: Optional[str] = None
+    session_id: Optional[str] = None
+
+
+@router.post("/get-image-name")
+async def get_image_name(body: ImageNameRequest) -> Dict[str, Any]:
+    """
+    Get the current listing title for image naming.
+    Called by Cloudflare Worker when uploading new images.
+    """
+    try:
+        graph = get_aida_graph()
+        config = {"configurable": {"thread_id": body.session_id}}
+        
+        # Get current state
+        state = graph.get_state(config)
+        
+        if state and state.values:
+            listing_draft = state.values.get("listing_draft", {})
+            title = listing_draft.get("title") if listing_draft else None
+            
+            if title:
+                # Clean title for filename
+                clean_name = title.lower().replace(" ", "-").replace("'", "")
+                return {"success": True, "name": clean_name}
+        
+        # Fallback to timestamp-based name
+        return {"success": True, "name": f"property-{int(datetime.utcnow().timestamp())}"}
+        
+    except Exception as e:
+        logger.error("Failed to get image name", exc_info=e)
+        return {"success": False, "name": f"property-{int(datetime.utcnow().timestamp())}"}
+
+
+@router.post("/image-upload-result")
+async def handle_image_upload_result(body: ImageUploadResult) -> AgentResponse:
+    """
+    Handle the result from Cloudflare Worker image upload.
+    If success: Process the image with user's command
+    If error: Generate friendly error message via AIDA
+    """
+    try:
+        session_id = body.session_id or str(uuid4())
+        user_id = body.user_id or f"anonymous_{uuid4()}"
+        
+        if body.success and body.url:
+            # Image validated and uploaded - combine with user message
+            user_message = body.message or ""
+            if body.url not in user_message:
+                user_message = f"{user_message} {body.url}".strip()
+            
+            # Add operation context if replacing
+            if body.operation == "replace" and body.replace_index:
+                if "replace" not in user_message.lower():
+                    user_message = f"Replace image {body.replace_index} with {body.url}"
+            
+            # Send to AIDA for processing
+            ask_body = AskBody(
+                message=user_message,
+                session_id=session_id,
+                user_id=user_id,
+                user_role="landlord"
+            )
+            return await ask(ask_body)
+            
+        else:
+            # Image rejected - generate friendly error via AIDA
+            error_type = body.error or "unknown"
+            reason = body.reason or ""
+            
+            if error_type == "not_property_image":
+                error_message = f"[IMAGE_REJECTED] User tried to upload an image that doesn't appear to be a property photo. Reason: {reason}. Generate a friendly message asking them to upload a proper property image."
+            else:
+                error_message = f"[IMAGE_ERROR] Failed to upload image: {error_type}. Generate a friendly error message."
+            
+            # Send error context to AIDA
+            ask_body = AskBody(
+                message=error_message,
+                session_id=session_id,
+                user_id=user_id,
+                user_role="landlord"
+            )
+            return await ask(ask_body)
+            
     except Exception as e:
-        logger.error("Failed to reset session", exc_info=e)
-        raise HTTPException(status_code=500, detail="Failed to reset session")
+        logger.error("Image upload result handling error", exc_info=e)
+        return AgentResponse(
+            success=False,
+            text="Sorry, there was an issue processing your image. Please try again.",
+            action="error",
+            error=str(e)
+        )

app/ai/routes/chat_refactored.py

@@ -1,346 +0,0 @@
-# app/ai/routes/chat_refactored.py
-"""
-AIDA Chat Endpoint - LangGraph Powered (PRIMARY - v1)
-FIXED: Properly handles recursion limit and dict output from graph.ainvoke()
-"""
-
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-from typing import Optional, Dict, Any
-from structlog import get_logger
-from uuid import uuid4
-from datetime import datetime
-from langgraph.types import Command
-
-from app.ai.agent.graph import get_aida_graph
-from app.ai.agent.schemas import AgentResponse
-
-logger = get_logger(__name__)
-
-router = APIRouter()
-
-
-# ============================================================
-# REQUEST/RESPONSE MODELS
-# ============================================================
-
-class AskBody(BaseModel):
-    """Request body for /ask endpoint"""
-    message: str
-    session_id: Optional[str] = None
-    user_id: Optional[str] = None
-    user_role: Optional[str] = "renter"
-    start_new_session: Optional[bool] = False
-
-
-# ============================================================
-# MAIN CHAT ENDPOINT - LANGGRAPH POWERED (FIXED)
-# ============================================================
-
-@router.post("/ask", response_model=AgentResponse)
-async def ask_ai(body: AskBody) -> AgentResponse:
-    """
-    Main chat endpoint using LangGraph state machine.
-    
-    CRITICAL FIXES:
-    - Set recursion_limit to 50 (prevents infinite loops)
-    - graph.ainvoke() returns a DICT, not AgentState object
-    - Access dict keys with ['key'], not .attribute
-    - Extract response from dict['temp_data']['final_response']
-    
-    Flow:
-    1. Validate input
-    2. Build input dict
-    3. Invoke graph with dict input and high recursion_limit
-    4. Extract final_response from returned dict
-    5. Return to client
-    """
-    
-    logger.info("🚀 Chat request received", message_len=len(body.message))
-    
-    try:
-        # ============================================================
-        # STEP 1: Validate input
-        # ============================================================
-        
-        if not body.message or not body.message.strip():
-            logger.warning("❌ Empty message received")
-            return AgentResponse(
-                success=False,
-                text="Please provide a message.",
-                action="error",
-                error="Empty message",
-            )
-        
-        message = body.message.strip()
-        session_id = body.session_id or str(uuid4())
-        user_id = body.user_id or f"anonymous_{uuid4()}"
-        user_role = body.user_role or "renter"
-        
-        logger.info(
-            "📋 User session info",
-            user_id=user_id,
-            session_id=session_id,
-            user_role=user_role,
-            message_len=len(message),
-        )
-        
-        # ============================================================
-        # STEP 2: Build input dict for graph
-        # ============================================================
-        # ✅ CRITICAL: Pass dict, not AgentState
-        
-        input_dict = {
-            "user_id": user_id,
-            "session_id": session_id,
-            "user_role": user_role,
-            "last_user_message": message,
-            "conversation_history": [],
-            "language_detected": "en",
-            "start_new_session": body.start_new_session or False,
-        }
-        
-        logger.info("📦 Input dict prepared", keys=list(input_dict.keys()))
-        
-        # ============================================================
-        # STEP 3: Get graph and validate
-        # ============================================================
-        
-        try:
-            graph = get_aida_graph()
-            
-            if graph is None:
-                logger.error("❌ Graph is None!")
-                return AgentResponse(
-                    success=False,
-                    text="System error: Graph not initialized",
-                    action="error",
-                    error="Graph initialization failed",
-                )
-            
-            logger.info("✅ Graph retrieved successfully")
-            
-        except Exception as e:
-            logger.error("❌ Graph retrieval failed", exc_info=e)
-            return AgentResponse(
-                success=False,
-                text=f"System error: {str(e)}",
-                action="error",
-                error=str(e),
-            )
-        
-        # ============================================================
-        # STEP 4: Invoke graph with dict input
-        # ============================================================
-        
-        logger.info("🔄 Invoking LangGraph...", user_id=user_id)
-        
-        try:
-            # ✅ CRITICAL FIX: Pass recursion_limit config to prevent infinite loops
-            # Default is 25, we set it to 50 to allow for longer flows
-            final_state_dict = await graph.ainvoke(
-                input_dict,
-                config={"recursion_limit": 50}  # ✅ FIX: High recursion limit
-            )
-            
-            # ✅ CRITICAL: final_state_dict is a DICT, not AgentState!
-            # Access with dict keys: ['key'], not .attribute
-            
-            logger.info(
-                "✅ LangGraph execution completed",
-                flow=final_state_dict.get("current_flow", {}).get("value") if isinstance(final_state_dict.get("current_flow"), dict) else str(final_state_dict.get("current_flow")),
-                steps=final_state_dict.get("steps_taken"),
-                has_error=final_state_dict.get("last_error") is not None,
-            )
-            
-        except Exception as e:
-            logger.error("❌ Graph execution failed", exc_info=e)
-            
-            # Check if it's a recursion error
-            if "recursion" in str(e).lower():
-                logger.error("⚠️ Graph hit recursion limit - check for infinite loops in listing_collect")
-                return AgentResponse(
-                    success=False,
-                    text="System is processing your request too long. This usually means you're in the listing flow. Please try again or provide more details.",
-                    action="error",
-                    error="Recursion limit exceeded - infinite loop detected",
-                )
-            
-            return AgentResponse(
-                success=False,
-                text="Error processing your request. Please try again.",
-                action="error",
-                error=str(e),
-            )
-        
-        # ============================================================
-        # STEP 5: Extract response from final state dict
-        # ============================================================
-        
-        # ✅ Access dict['key'] not dict.key
-        temp_data = final_state_dict.get("temp_data", {})
-        final_response = temp_data.get("final_response")
-        
-        if final_response:
-            logger.info(
-                "✅ Response extracted from state",
-                action=final_response.action if hasattr(final_response, 'action') else "unknown",
-                success=final_response.success if hasattr(final_response, 'success') else False,
-            )
-            return final_response
-        
-        # ============================================================
-        # FALLBACK: Build response manually if not in temp_data
-        # ============================================================
-        
-        logger.warning("⚠️ No final_response in temp_data, building manually")
-        
-        response_text = temp_data.get("response_text", "")
-        if not response_text:
-            response_text = "I'm here to help! What would you like to do?"
-        
-        # Get flow state - handle both FlowState enum and string
-        current_flow = final_state_dict.get("current_flow")
-        if hasattr(current_flow, 'value'):
-            flow_str = current_flow.value
-        else:
-            flow_str = str(current_flow)
-        
-        response = AgentResponse(
-            success=final_state_dict.get("last_error") is None,
-            text=response_text,
-            action=temp_data.get("action", flow_str),
-            state={
-                "flow": flow_str,
-                "steps": final_state_dict.get("steps_taken", 0),
-                "errors": final_state_dict.get("error_count", 0),
-            },
-            draft=temp_data.get("draft"),
-            draft_ui=temp_data.get("draft_ui"),
-            error=final_state_dict.get("last_error"),
-            metadata={
-                "intent": final_state_dict.get("intent_type"),
-                "intent_confidence": final_state_dict.get("intent_confidence", 0),
-                "language": final_state_dict.get("language_detected", "en"),
-                "messages_in_session": len(final_state_dict.get("conversation_history", [])),
-                "user_id": user_id,
-                "session_id": session_id,
-            }
-        )
-        
-        logger.info("✅ Fallback response built", action=response.action)
-        
-        return response
-    
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error("❌ Chat endpoint critical error", exc_info=e)
-        return AgentResponse(
-            success=False,
-            text="An unexpected error occurred. Please try again.",
-            action="error",
-            error=str(e),
-        )
-
-
-# ============================================================
-# HEALTH CHECK
-# ============================================================
-
-@router.get("/health")
-async def health_check() -> Dict[str, Any]:
-    """Health check for AIDA chat service"""
-    
-    try:
-        graph = get_aida_graph()
-        
-        return {
-            "status": "healthy",
-            "service": "AIDA Chat (LangGraph)",
-            "version": "2.0.0",
-            "graph_available": graph is not None,
-            "recursion_limit_config": "50",
-            "timestamp": datetime.utcnow().isoformat(),
-        }
-    except Exception as e:
-        logger.error("❌ Health check failed", exc_info=e)
-        return {
-            "status": "unhealthy",
-            "error": str(e),
-            "timestamp": datetime.utcnow().isoformat(),
-        }
-
-
-# ============================================================
-# HISTORY ENDPOINT
-# ============================================================
-
-@router.get("/history/{session_id}")
-async def get_history(session_id: str) -> Dict[str, Any]:
-    """Get conversation history for a session"""
-    
-    try:
-        logger.info("📖 History requested", session_id=session_id)
-        
-        return {
-            "success": True,
-            "session_id": session_id,
-            "messages": [],
-            "note": "History persistence not yet implemented"
-        }
-    
-    except Exception as e:
-        logger.error("❌ History retrieval error", exc_info=e)
-        return {
-            "success": False,
-            "error": str(e),
-        }
-
-
-# ============================================================
-# SESSION MANAGEMENT
-# ============================================================
-
-@router.post("/reset-session/{session_id}")
-async def reset_session(session_id: str) -> Dict[str, Any]:
-    """Reset a session to fresh state"""
-    
-    try:
-        logger.info("🔄 Session reset requested", session_id=session_id)
-        
-        return {
-            "success": True,
-            "message": "Session reset to fresh state",
-            "session_id": session_id,
-            "timestamp": datetime.utcnow().isoformat(),
-        }
-    
-    except Exception as e:
-        logger.error("❌ Session reset error", exc_info=e)
-        return {
-            "success": False,
-            "error": str(e),
-        }
-
-
-@router.post("/close-session/{session_id}")
-async def close_session(session_id: str) -> Dict[str, Any]:
-    """Close a session"""
-    
-    try:
-        logger.info("❌ Session closed", session_id=session_id)
-        
-        return {
-            "success": True,
-            "message": "Session closed",
-            "session_id": session_id,
-            "timestamp": datetime.utcnow().isoformat(),
-        }
-    
-    except Exception as e:
-        logger.error("❌ Session close error", exc_info=e)
-        return {
-            "success": False,
-            "error": str(e),
-        }

app/ai/services/search_service.py

@@ -0,0 +1,428 @@
+# app/ai/services/search_service.py
+"""
+Hybrid Search Service - Combines Qdrant vector search with payload filters
+for intelligent natural language property search.
+
+Features:
+- LLM-based query parameter extraction
+- Location-to-currency inference
+- Amenity normalization with aliases
+- Qdrant hybrid search (vector + filters)
+"""
+
+import os
+import httpx
+from typing import Dict, List, Optional, Tuple, Any
+from structlog import get_logger
+from qdrant_client.models import Filter, FieldCondition, MatchValue, MatchAny, Range
+
+from app.ai.config import qdrant_client
+from app.config import settings
+
+logger = get_logger(__name__)
+
+# ============================================================
+# CONFIGURATION
+# ============================================================
+
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+EMBED_MODEL = "qwen/qwen3-embedding-8b"
+VECTOR_SIZE = 4096
+COLLECTION_NAME = "listings"
+
+# ============================================================
+# AMENITY ALIASES - Map common variations to canonical names
+# ============================================================
+
+AMENITY_ALIASES = {
+    "wifi": ["wifi", "wi-fi", "internet", "wireless", "connexion"],
+    "balcony": ["balcony", "terrace", "patio", "balcon"],
+    "parking": ["parking", "garage", "car park", "stationnement"],
+    "pool": ["pool", "swimming", "swimming pool", "piscine"],
+    "gym": ["gym", "fitness", "workout", "salle de sport"],
+    "security": ["security", "guard", "sécurité", "gardien"],
+    "furnished": ["furnished", "meublé", "meuble"],
+    "air conditioning": ["air conditioning", "ac", "climatisation", "clim"],
+    "kitchen": ["kitchen", "cuisine"],
+    "laundry": ["laundry", "washing", "laverie", "lave-linge"],
+    "garden": ["garden", "jardin", "yard"],
+    "elevator": ["elevator", "lift", "ascenseur"],
+    "hot water": ["hot water", "eau chaude"],
+    "tv cable": ["tv cable", "cable tv", "tv", "television"],
+    "heating": ["heating", "chauffage"],
+}
+
+
+# ============================================================
+# EMBEDDING FUNCTION
+# ============================================================
+
+async def embed_query(text: str) -> Optional[List[float]]:
+    """
+    Create embedding for a search query using OpenRouter.
+    
+    Args:
+        text: Query text to embed
+    
+    Returns:
+        4096-dim embedding vector or None if error
+    """
+    
+    if not OPENROUTER_API_KEY:
+        logger.warning("OpenRouter API key not set, cannot embed query")
+        return None
+    
+    try:
+        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()
+            embedding = data["data"][0]["embedding"]
+            
+            logger.info("Query embedded successfully", vector_dim=len(embedding))
+            return embedding
+            
+    except Exception as e:
+        logger.error("Embedding failed", error=str(e))
+        return None
+
+
+# ============================================================
+# CURRENCY INFERENCE
+# ============================================================
+
+async def infer_currency_from_location(location: str) -> Tuple[str, float]:
+    """
+    Infer currency code from location using CurrencyManager.
+    
+    Args:
+        location: Location string (e.g., "Calavi", "Lagos")
+    
+    Returns:
+        Tuple of (currency_code, confidence)
+    """
+    
+    if not location:
+        return "XOF", 0.0  # Default for Benin
+    
+    try:
+        from app.ml.models.ml_listing_extractor import get_ml_extractor
+        
+        ml = get_ml_extractor()
+        currency, country, city, confidence = await ml.currency_mgr.get_currency_for_location(location)
+        
+        if currency:
+            logger.info(
+                "Currency inferred from location",
+                location=location,
+                currency=currency,
+                country=country,
+                confidence=confidence
+            )
+            return currency, confidence
+        
+    except Exception as e:
+        logger.warning(f"Currency inference failed: {e}")
+    
+    # Fallback to known cities
+    location_lower = location.lower()
+    
+    CITY_CURRENCY_MAP = {
+        # Benin
+        "cotonou": "XOF", "calavi": "XOF", "porto-novo": "XOF",
+        "abomey": "XOF", "parakou": "XOF", "bohicon": "XOF",
+        # Nigeria
+        "lagos": "NGN", "abuja": "NGN", "ibadan": "NGN",
+        "kano": "NGN", "port harcourt": "NGN",
+        # Ghana
+        "accra": "GHS", "kumasi": "GHS",
+        # Senegal
+        "dakar": "XOF",
+        # Ivory Coast
+        "abidjan": "XOF",
+        # Other
+        "nairobi": "KES", "kampala": "UGX",
+        "johannesburg": "ZAR", "cape town": "ZAR",
+        "london": "GBP", "paris": "EUR",
+        "new york": "USD", "dubai": "AED",
+    }
+    
+    for city, currency in CITY_CURRENCY_MAP.items():
+        if city in location_lower:
+            logger.info("Currency from fallback map", location=location, currency=currency)
+            return currency, 0.8
+    
+    logger.warning("Currency not detected, using default XOF", location=location)
+    return "XOF", 0.5
+
+
+# ============================================================
+# AMENITY NORMALIZATION
+# ============================================================
+
+def normalize_amenities(amenities: List[str]) -> List[str]:
+    """
+    Normalize amenity names to canonical forms for database matching.
+    
+    Args:
+        amenities: List of user-mentioned amenities
+    
+    Returns:
+        List of normalized amenity names
+    """
+    
+    normalized = []
+    
+    for amenity in amenities:
+        amenity_lower = amenity.lower().strip()
+        found = False
+        
+        # Check if this matches any known alias
+        for canonical, aliases in AMENITY_ALIASES.items():
+            if amenity_lower in aliases:
+                normalized.append(canonical)
+                found = True
+                break
+        
+        # If not found in aliases, use as-is
+        if not found:
+            normalized.append(amenity_lower)
+    
+    # Remove duplicates while preserving order
+    seen = set()
+    unique = []
+    for item in normalized:
+        if item not in seen:
+            seen.add(item)
+            unique.append(item)
+    
+    logger.info("Amenities normalized", original=amenities, normalized=unique)
+    return unique
+
+
+# ============================================================
+# HYBRID SEARCH
+# ============================================================
+
+async def hybrid_search(
+    query_text: str,
+    search_params: Dict[str, Any],
+    limit: int = 10
+) -> 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
+    
+    Returns:
+        List of matching listings sorted by relevance
+    """
+    
+    logger.info("Starting hybrid search", query=query_text[:50], params_keys=list(search_params.keys()))
+    
+    if not qdrant_client:
+        logger.error("Qdrant client not available")
+        return []
+    
+    # ============================================================
+    # STEP 1: Build filter conditions
+    # ============================================================
+    
+    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"]))
+            )
+        )
+        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"]))
+            )
+        )
+        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"]))
+            )
+        )
+        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())
+            )
+        )
+        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())
+            )
+        )
+        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:
+            filter_conditions.append(
+                FieldCondition(
+                    key="amenities",
+                    match=MatchValue(value=amenity)
+                )
+            )
+        logger.info("Added amenities filter", amenities=normalized)
+    
+    # ============================================================
+    # STEP 2: Build query filter
+    # ============================================================
+    
+    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
+    # ============================================================
+    
+    query_vector = await embed_query(query_text)
+    
+    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,
+                scroll_filter=query_filter,
+                limit=limit,
+                with_payload=True
+            )
+            return [point.payload for point in results]
+        except Exception as e:
+            logger.error("Filter-only search failed", error=str(e))
+            return []
+    
+    # ============================================================
+    # STEP 4: Execute hybrid search
+    # ============================================================
+    
+    try:
+        # Use query method (not search) for async client
+        results = await qdrant_client.query_points(
+            collection_name=COLLECTION_NAME,
+            query=query_vector,
+            query_filter=query_filter,
+            limit=limit,
+            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
+            listings.append(listing)
+        
+        return listings
+        
+    except Exception as e:
+        logger.error("Hybrid search failed", error=str(e))
+        return []
+
+
+# ============================================================
+# MAIN SEARCH FUNCTION (Public API)
+# ============================================================
+
+async def search_listings_hybrid(
+    user_query: str,
+    search_params: Dict[str, Any],
+    limit: int = 10
+) -> 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
+    if search_params.get("location"):
+        currency, confidence = await infer_currency_from_location(search_params["location"])
+        logger.info("Currency for search", currency=currency, confidence=confidence)
+    
+    # Perform hybrid search
+    results = await hybrid_search(
+        query_text=user_query,
+        search_params=search_params,
+        limit=limit
+    )
+    
+    return results, currency