backward chain

app/ai/graph.py

@@ -1,4 +1,4 @@
-# app/ai/graph.py – FINAL: Proper intent → node routing
+# app/ai/graph.py - FIXED NODE NAMING CONFLICT
 from langgraph.graph import StateGraph, START, END
 from app.ai.state import ChatState
 from app.ai.nodes.intent_node import intent_node
@@ -6,100 +6,82 @@ from app.ai.nodes.role_gate_node import role_gate_node
 from app.ai.nodes.search_node import search_node
 from app.ai.nodes.draft_node import draft_node
 from app.ai.nodes.publish_node import publish_node
+from app.ai.utils.intent_extractor import extract_intent_from_state
 from structlog import get_logger
 
 logger = get_logger(__name__)
 
 workflow = StateGraph(ChatState)
 
-# ---------- unique node names ----------
-workflow.add_node("parse_intent",      intent_node)     # Detect intent + commands
-workflow.add_node("check_permissions", role_gate_node)  # Role-based gate
-workflow.add_node("search_listings",   search_node)     # Search execution
-workflow.add_node("create_draft",      draft_node)      # Draft generation (only on draft_ready)
-workflow.add_node("handle_publish",    publish_node)    # Publish to MongoDB
+# Add all nodes with unique names that don't conflict with state keys
+# ✅ FIXED: Changed node names to avoid conflicts with state fields
+workflow.add_node("parse_intent", intent_node)  # was "intent"
+workflow.add_node("check_permissions", role_gate_node)  # was "role_gate"
+workflow.add_node("search_listings", search_node)  # was "search"
+workflow.add_node("create_draft", draft_node)  # was "draft"
+workflow.add_node("handle_publish", publish_node)  # was "publish"
 
-# ---------- ALWAYS start at parse_intent ----------
+# START → parse_intent (always start here)
 workflow.add_edge(START, "parse_intent")
 
-# ---------- Route after intent extraction ----------
-def route_after_intent(state):
-    """Route based on intent detected by intent_node"""
+# From parse_intent, route to permission check
+def route_from_intent(state):
+    """Route from intent parsing to permission check"""
     intent = state.get("intent")
     
-    logger.info(f"🔀 Routing after intent", intent=intent, status=state.get("status"))
-    
-    # PUBLISH command detected
-    if intent == "publish":
-        logger.info("➡️  Routing to: handle_publish")
-        return "handle_publish"
-    
-    # SEARCH intent
-    if intent == "search":
-        logger.info("➡️  Routing to: check_permissions (search path)")
-        return "check_permissions"
-    
-    # LIST intent
-    if intent == "list":
-        logger.info("➡️  Routing to: check_permissions (list path)")
+    # Only check role for listing and search intents
+    if intent in ["search", "list"]:
         return "check_permissions"
-    
-    # No special intent = stay at END (casual chat)
-    logger.info("➡️  Routing to: END (casual chat)")
-    return END
+    else:
+        return END
 
 workflow.add_conditional_edges(
     "parse_intent",
-    route_after_intent,
+    route_from_intent,
     {
         "check_permissions": "check_permissions",
-        "handle_publish":    "handle_publish",
-        END:                 END
+        END: END
     }
 )
 
-# ---------- Route after permission check ----------
+# From permission check, route to actual operation or END
 def route_from_permissions(state):
-    """Route after role-based permission check"""
-    allowed = state.get("allowed", False)
+    """Route after permission check"""
+    if not state.get("allowed", False):
+        logger.info("🚫 Request blocked by permission check")
+        return END
+    
     intent = state.get("intent")
-    status = state.get("status")
     
-    if not allowed:
-        logger.info("🚫 Request blocked by permission check")
-        return END
-
     if intent == "search":
-        logger.info("➡️  Routing to: search_listings")
+        logger.info("🔍 Routing to search")
         return "search_listings"
-    
-    if intent == "list":
-        # If status is draft_ready, generate draft
-        if status == "draft_ready":
-            logger.info("➡️  Routing to: create_draft (generate preview)")
-            return "create_draft"
-        # Otherwise end (collecting fields or already previewed)
-        logger.info("➡️  Routing to: END (collecting or preview active)")
+    elif intent == "list":
+        logger.info("📝 Routing to draft creation")
+        return "create_draft"
+    else:
         return END
-    
-    logger.info("➡️  Routing to: END (no matching intent)")
-    return END
 
 workflow.add_conditional_edges(
     "check_permissions",
     route_from_permissions,
     {
         "search_listings": "search_listings",
-        "create_draft":    "create_draft",
-        END:               END
+        "create_draft": "create_draft",
+        END: END
     }
 )
 
-# ---------- Terminal edges ----------
+# search_listings → END
 workflow.add_edge("search_listings", END)
-workflow.add_edge("create_draft",    END)
-workflow.add_edge("handle_publish",  END)
 
-# Compile
+# create_draft → handle_publish
+workflow.add_edge("create_draft", "handle_publish")
+
+# handle_publish → END
+workflow.add_edge("handle_publish", END)
+
+# Compile the graph
 agent = workflow.compile()
-logger.info("✅ LangGraph compiled with command detection")
+
+logger.info("✅ LangGraph compiled successfully with unique node names")

app/ai/nodes/draft_node.py

@@ -1,70 +1,56 @@
-# app/ai/nodes/draft_node.py – FINAL: Error handling + validation + observability
-import logging
+# app/ai/nodes/draft_node.py - Fix location persistence + add amenity icons
 import datetime
 from typing import Dict
-
+from bson import ObjectId
 from app.database import get_db
-from app.core.error_handling import trace_operation, handle_errors
+from app.ai.state import ListingDraft
+from structlog import get_logger
+from openai import AsyncOpenAI
+from app.config import settings
 from app.ml.models.ml_listing_extractor import get_ml_extractor
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
+client = AsyncOpenAI(api_key=settings.OPENAI_API_KEY)
 ml_extractor = get_ml_extractor()
 
-# ============================================================
-# Amenity Icons Mapping
-# ============================================================
-
+# ========== AMENITY ICONS MAPPING ==========
 AMENITY_ICONS = {
-    "wifi": "📶",
-    "parking": "🅿️",
-    "furnished": "🛋️",
-    "washing machine": "🧼",
-    "washing": "🧼",
-    "dryer": "🔥",
-    "balcony": "🎋️",
-    "pool": "🏊",
-    "gym": "💪",
-    "garden": "🌿",
-    "air conditioning": "❄️",
-    "ac": "❄️",
-    "kitchen": "🍳",
-    "tv": "📺",
-    "television": "📺",
+    "wifi": "📶",
+    "parking": "🅿️",
+    "furnished": "🛋️",
+    "washing machine": "🧼",
+    "washing": "🧼",
+    "dryer": "🔥",
+    "balcony": "🏞️",
+    "pool": "🏊",
+    "gym": "💪",
+    "garden": "🌿",
+    "air conditioning": "❄️",
+    "ac": "❄️",
+    "kitchen": "🍳",
 }
 
-# ============================================================
-# Custom Exceptions
-# ============================================================
-
-class ValidationError(Exception):
-    """Raised when field validation fails."""
-    pass
-
-class DraftGenerationError(Exception):
-    """Raised when draft generation fails."""
-    pass
-
-# ============================================================
-# Helpers
-# ============================================================
-
 def _add_amenity_icons(amenities: list) -> str:
     """Convert amenities list to string with icons."""
     if not amenities:
         return ""
+    
     icons_text = []
     for amenity in amenities:
         amenity_lower = amenity.lower().strip()
-        icon = AMENITY_ICONS.get(amenity_lower, "✔")
+        icon = AMENITY_ICONS.get(amenity_lower, "✓")
         icons_text.append(f"{icon} {amenity.title()}")
+    
     return " | ".join(icons_text)
 
 def _generate_title(state: Dict) -> str:
     """Generate professional title from listing data."""
     bedrooms = state.get("bedrooms", "")
+    # ✅ CRITICAL: Use current location from state, not regenerated
     location = state.get("location", "").title()
     listing_type = state.get("listing_type", "").title()
+    
     if bedrooms and location:
         return f"{bedrooms}-Bedroom {listing_type} in {location}"
     return f"Property in {location}"
@@ -73,211 +59,181 @@ def _generate_description(state: Dict) -> str:
     """Generate professional description from listing data."""
     bedrooms = state.get("bedrooms", "")
     bathrooms = state.get("bathrooms", "")
+    # ✅ CRITICAL: Use current location from state, not regenerated
     location = state.get("location", "").title()
     amenities = state.get("amenities", [])
     price = state.get("price", "")
     price_type = state.get("price_type", "").title()
     listing_type = state.get("listing_type", "").title()
     requirements = state.get("requirements", "")
-
+    
     desc = f"Spacious {bedrooms}-bedroom, {bathrooms}-bathroom {listing_type} "
     desc += f"located in {location}. "
+    
     if price:
         desc += f"Priced at {price:,} {price_type}. "
+    
     if amenities:
         amenities_str = ", ".join(amenities)
         desc += f"Fully furnished with modern amenities including {amenities_str}. "
+    
     if requirements:
         desc += f"Requirements: {requirements}. "
+    
     desc += "Perfect for large families or shared accommodation."
     return desc
 
-def _get_current_message(state: Dict) -> str:
-    """Extract ONLY the current user message."""
-    full = state["messages"][-1]["content"]
-    if "Now the user says:" in full:
-        return full.split("Now the user says:")[-1].strip()
-    return full.strip()
-
-# ============================================================
-# Draft Node
-# ============================================================
-
-@handle_errors(default_return=None)
+# ---------- node ----------
 async def draft_node(state: Dict) -> Dict:
     """
-    LangGraph node: Generate draft listing preview
-    
-    Features:
-    - Prevents regeneration when preview active
-    - ML validation of all fields
-    - Professional title/description generation
-    - Amenity icon formatting
-    - Error handling with graceful fallback
-    - Full observability and logging
+    LangGraph node:
+    - Check if status == "checking_optional" (amenities/requirements missing)
+    - Ask for amenities and requirements
+    - Move to "draft_ready"
+    - Or status == "draft_ready" → show preview
     """
     
-    status = state.get("status")
-    
-    with trace_operation(
-        "draft_node",
-        {
-            "status": status,
-            "intent": state.get("intent"),
-            "has_draft": state.get("draft_preview") is not None,
-        }
-    ):
-        # ===== CRITICAL: Exit immediately if preview already active =====
-        if status in {"preview_shown", "waiting_for_images"}:
-            logger.info("🛑 DRAFT NODE SKIPPED: Preview already active")
-            return state
+    # ✅ NEW: Check if amenities/requirements are missing
+    if state.get("status") == "checking_optional":
+        amenities = state.get("amenities", [])
+        requirements = state.get("requirements")
         
-        # ===== Only proceed if status is EXACTLY "draft_ready" =====
-        if status != "draft_ready":
-            logger.info(f"🛑 DRAFT NODE SKIPPED: status={status}, not draft_ready")
-            return state
+        # Ask about missing optional fields
+        missing_optional = []
+        if not amenities:
+            missing_optional.append("amenities")
+        if not requirements:
+            missing_optional.append("requirements")
         
-        # ===== Only proceed if intent is "list" =====
-        if state.get("intent") != "list":
-            logger.info("🛑 DRAFT NODE SKIPPED: intent is not 'list'")
+        if missing_optional:
+            state["status"] = "collecting_optional"
+            state["missing_fields"] = missing_optional
+            
+            questions = []
+            if "amenities" in missing_optional:
+                questions.append("Any amenities? (e.g., wifi, parking, balcony, pool, furnished, kitchen, dryer, garden, etc.)")
+            if "requirements" in missing_optional:
+                questions.append("Any special requirements for renters?")
+            
+            state["ai_reply"] = "Just a couple more things...\n\n" + "\n".join([f"• {q}" for q in questions])
+            logger.info("ℹ️ Asking for optional fields", missing=missing_optional)
             return state
+        else:
+            # All optional fields provided, move to draft
+            state["status"] = "draft_ready"
+    
+    # Only process if listing creation with all fields ready
+    if state.get("intent") != "list" or state.get("status") != "draft_ready":
+        return state
+    
+    user_id = state.get("user_id")
+    
+    # ✅ ML VALIDATION before drafting
+    try:
+        validation = ml_extractor.validate_all_fields(state, user_id)
         
-        # ===== If we get here, generate the draft =====
-        logger.info("✅ DRAFT NODE RUNNING: Generating draft preview")
-        
-        user_id = state.get("user_id")
-        
-        # ===== ML VALIDATION =====
-        with trace_operation("ml_validation"):
-            try:
-                validation = ml_extractor.validate_all_fields(state, user_id)
-                
-                if not validation["all_valid"]:
-                    issues_text = "\n".join([f"❌ {issue}" for issue in validation["issues"]])
-                    state["ai_reply"] = f"""I found some issues with your listing:
+        if not validation["all_valid"]:
+            # Fields failed validation, go back to collecting
+            issues_text = "\n".join([f"❌ {issue}" for issue in validation["issues"]])
+            state["ai_reply"] = f"""I found some issues with your listing:
 
 {issues_text}
 
 Let me ask again - could you clarify these fields?"""
-                    state["status"] = "collecting"
-                    state["missing_fields"] = [
-                        field for field, result in validation["field_validations"].items()
-                        if not result["is_valid"]
-                    ]
-                    logger.warning(f"🚫 Validation failed", extra={"issues": validation["issues"]})
-                    return state
-                
-                logger.info(f"✅ All fields passed validation")
             
-            except Exception as e:
-                logger.error(f"❌ ML validation error: {e}", exc_info=True)
-                state["ai_reply"] = "Sorry, I couldn't validate your listing. Please try again."
-                state["status"] = "error"
-                return state
-        
-        # ===== DRAFT GENERATION =====
-        with trace_operation("draft_generation"):
-            try:
-                # Generate components
-                title = _generate_title(state)
-                description = _generate_description(state)
-                amenities_with_icons = _add_amenity_icons(state.get("amenities", []))
-                images = (
-                    state.get("draft", {}).get("images", [])
-                    if isinstance(state.get("draft"), dict)
-                    else []
-                )
-                
-                # Build draft preview
-                draft_preview = {
-                    "title": title,
-                    "description": description,
-                    "location": state.get("location", "").title(),
-                    "bedrooms": state.get("bedrooms"),
-                    "bathrooms": state.get("bathrooms"),
-                    "price": state.get("price"),
-                    "price_type": state.get("price_type"),
-                    "listing_type": state.get("listing_type"),
-                    "amenities": state.get("amenities", []),
-                    "amenities_with_icons": amenities_with_icons,
-                    "requirements": state.get("requirements"),
-                    "currency": state.get("currency", "XOF"),
-                    "images": images,
-                    "field_confidences": validation.get("field_validations", {}),
-                }
-                
-                logger.info(
-                    f"🎯 Draft generated",
-                    extra={
-                        "title": title,
-                        "images": len(images),
-                        "amenities": len(state.get("amenities", [])),
-                    }
-                )
+            state["status"] = "collecting"
+            # Re-populate missing fields based on validation
+            state["missing_fields"] = [
+                field for field, result in validation["field_validations"].items()
+                if not result["is_valid"]
+            ]
             
-            except Exception as e:
-                logger.error(f"❌ Failed to generate draft: {e}", exc_info=True)
-                state["ai_reply"] = "Sorry, I couldn't generate your draft. Please try again."
-                state["status"] = "error"
-                return state
+            logger.warning("🚫 Fields failed ML validation", issues=validation["issues"])
+            return state
         
-        # ===== BUILD PREVIEW MESSAGE =====
-        with trace_operation("build_preview_message"):
-            try:
-                images_section = ""
-                if images:
-                    images_section = f"\n📷 Images: {len(images)} uploaded\n"
-                    for idx, img_url in enumerate(images[:3], 1):
-                        images_section += f"   {idx}. {img_url[:60]}...\n"
-                    if len(images) > 3:
-                        images_section += f"   ... and {len(images) - 3} more\n"
-                
-                preview_text = f"""
-┌─────────────────────────────────────────────────────────────────────────┐
-🏠  LISTING PREVIEW
-└─────────────────────────────────────────────────────────────────────────┘
-
+        logger.info("✅ All fields passed ML validation", user_id=user_id)
+    
+    except Exception as e:
+        logger.error("❌ ML validation error", exc_info=e)
+        state["ai_reply"] = "Sorry, I couldn't validate your listing. Please try again."
+        state["status"] = "error"
+        return state
+    
+    # Generate title and description
+    # ✅ CRITICAL: These use state's current location (corrected by user)
+    title = _generate_title(state)
+    description = _generate_description(state)
+    amenities_with_icons = _add_amenity_icons(state.get("amenities", []))
+    
+    # ✅ Get images from state (if any were uploaded)
+    images = state.get("draft", {}).get("images", []) if isinstance(state.get("draft"), dict) else []
+    
+    # Build draft preview with all fields including images and icons
+    draft_preview = {
+        "title": title,
+        "description": description,
+        "location": state.get("location", "").title(),  # ✅ Use current location
+        "bedrooms": state.get("bedrooms"),
+        "bathrooms": state.get("bathrooms"),
+        "price": state.get("price"),
+        "price_type": state.get("price_type"),
+        "listing_type": state.get("listing_type"),
+        "amenities": state.get("amenities", []),
+        "amenities_with_icons": amenities_with_icons,  # ✅ NEW: Add icons
+        "requirements": state.get("requirements"),
+        "currency": state.get("currency", "XOF"),
+        "images": images,  # ✅ INCLUDE IMAGES
+        "field_confidences": validation["field_validations"],
+    }
+    
+    logger.info("🎯 Draft preview generated",
+                title=title,
+                location=state.get("location"),  # ✅ Log actual location
+                image_count=len(images),
+                amenities=state.get("amenities", []))
+    
+    # Build nice preview message for user
+    images_section = ""
+    if images:
+        images_section = f"\n📷 Images: {len(images)} uploaded\n"
+        for idx, img_url in enumerate(images[:3], 1):
+            images_section += f"   {idx}. {img_url[:60]}...\n"
+        if len(images) > 3:
+            images_section += f"   ... and {len(images) - 3} more\n"
+    
+    preview_text = f"""
+┌──────────────────────────────────────────────────────────────────────────────
+🏠 LISTING PREVIEW
+└──────────────────────────────────────────────────────────────────────────────
 **{draft_preview['title']}**
 
-📍 Location: {draft_preview['location']}
-🛏 Bedrooms: {draft_preview['bedrooms']}
-🚿 Bathrooms: {draft_preview['bathrooms']}
-💰 Price: {draft_preview['price']:,} {draft_preview['price_type']} ({draft_preview['currency']})
+📍 Location: {draft_preview['location']}
+🛏️ Bedrooms: {draft_preview['bedrooms']}
+🚿 Bathrooms: {draft_preview['bathrooms']}
+💰 Price: {draft_preview['price']:,} {draft_preview['price_type']} ({draft_preview['currency']})
 
 {draft_preview['description']}
 
-✨ Amenities: {draft_preview['amenities_with_icons'] if draft_preview['amenities_with_icons'] else 'None specified'}
+✨ Amenities: {draft_preview['amenities_with_icons'] if draft_preview['amenities_with_icons'] else 'None specified'}
 {images_section}
-└─────────────────────────────────────────────────────────────────────────┘
+└──────────────────────────────────────────────────────────────────────────────
 """
-                
-                if not images:
-                    preview_text += """
-📸 Upload property images to make your listing more attractive!
+    
+    # ✅ Check if images uploaded, ask if not
+    if not images:
+        preview_text += """
+📸 Upload property images to make your listing more attractive!
 
 Then say **publish** to make it live!
 """
-                    state["status"] = "waiting_for_images"
-                    logger.info("⏳ Waiting for images")
-                else:
-                    preview_text += """
-✅ Perfect! Say **publish** to make your listing live!
+        state["status"] = "waiting_for_images"  # ✅ Wait for images
+    else:
+        preview_text += """
+✅ Perfect! Say **publish** to make your listing live!
 """
-                    state["status"] = "preview_shown"
-                    logger.info("✅ Preview ready for publishing")
-                
-                state["draft_preview"] = draft_preview
-                state["ai_reply"] = preview_text
-                
-                logger.info(
-                    f"✅ Draft node completed",
-                    extra={"status": state["status"]}
-                )
-                
-                return state
-            
-            except Exception as e:
-                logger.error(f"❌ Failed to build preview: {e}", exc_info=True)
-                state["ai_reply"] = "Sorry, an error occurred preparing your listing. Please try again."
-                state["status"] = "error"
-                return state
+        state["status"] = "preview_shown"  # ✅ Ready to publish
+    
+    state["draft_preview"] = draft_preview
+    state["ai_reply"] = preview_text
+    
+    return state

app/ai/nodes/image_node.py

@@ -30,7 +30,7 @@ async def image_node(state: Dict) -> Dict:
         binary = base64.b64decode(base64_data)
     except Exception as e:
         logger.warning("Bad base64 image", exc_info=e)
-        state["ai_reply"] = "❌ Invalid image data. Please try again."
+        state["ai_reply"] = "❌ Invalid image data. Please try again."
         return state
 
     headers = {"Authorization": f"Bearer {settings.CF_API_TOKEN}"}
@@ -46,7 +46,7 @@ async def image_node(state: Dict) -> Dict:
             public_url = f"https://imagedelivery.net/{data['result']['id']}/public"
         except Exception as e:
             logger.error("Cloudflare upload failed", exc_info=e)
-            state["ai_reply"] = "❌ Could not upload image. Please try again."
+            state["ai_reply"] = "❌ Could not upload image. Please try again."
             return state
 
     # append URL to draft
@@ -55,9 +55,9 @@ async def image_node(state: Dict) -> Dict:
         if not hasattr(draft, "images"):
             draft.images = []
         draft.images.append(public_url)
-        state["ai_reply"] = f"📸 Picture uploaded! Add more or say **publish** when ready.\n{public_url}"
+        state["ai_reply"] = f"📸 Picture uploaded! Add more or say **publish** when ready.\n{public_url}"
     else:
-        state["ai_reply"] = "📸 Picture uploaded! Continue describing the property."
+        state["ai_reply"] = "📸 Picture uploaded! Continue describing the property."
 
     logger.info("Image uploaded to Cloudflare", url=public_url)
     return state

app/ai/nodes/intent_node.py

@@ -1,197 +1,390 @@
-# app/ai/nodes/intent_node.py – FINAL: chat until clear "list", then show example
-import json, re, logging
-from typing import Dict
-from app.core.llm_router      import call_llm_smart
-from app.core.context_manager import get_context_manager
-from app.core.error_handling  import async_retry, RetryStrategy, trace_operation
+# app/ai/nodes/intent_node.py - FIXED: Simple example, collect amenities/requirements
+import json
+import re
+from typing import Dict, List
+from tenacity import retry, stop_after_attempt, wait_exponential
+from openai import AsyncOpenAI
+from structlog import get_logger
+from app.config import settings
 from app.ml.models.ml_listing_extractor import get_ml_extractor
-from app.ml.models.user_role_context_handler import RentalModel
-from app.ai.services.dynamic_role_manager import get_dynamic_role_manager
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
+
+MODEL = "deepseek-chat"
+MAX_TOKENS = 600
+TEMP = 0
+
+client = AsyncOpenAI(api_key=settings.DEEPSEEK_API_KEY,
+                     base_url=settings.DEEPSEEK_BASE_URL)
+
 ml_extractor = get_ml_extractor()
-role_manager = get_dynamic_role_manager()
 
-# ------------------------------------------------------------------
-# helpers
-# ------------------------------------------------------------------
-def _clean_json(raw: str) -> str:
-    return re.sub(r'```json\s*', '', re.sub(r'```\s*', '', raw)).strip()
+def _load_system() -> str:
+    with open("app/ai/prompts/system_prompt.txt", encoding="utf-8") as f:
+        return f.read()
 
-def _get_current_message(state: Dict) -> str:
-    full = state["messages"][-1]["content"]
-    return full.split("Now the user says:")[-1].strip() if "Now the user says:" in full else full.strip()
+SYSTEM_PROMPT = _load_system()
 
-def _is_clear_list_intent(msg: str) -> bool:
-    """Detect explicit list trigger after casual chat."""
-    return bool(re.search(r'\b(list\s+a?\s*property|i\s+want\s+to\s+list)\b', msg.lower()))
+def _clean_json(raw: str) -> str:
+    """Remove markdown code blocks from JSON string."""
+    cleaned = re.sub(r'```json\s*', '', raw)
+    cleaned = re.sub(r'```\s*', '', cleaned)
+    return cleaned.strip()
 
-def _listing_example() -> str:
-    return """
-📋 **Here’s how it works:**
+def _normalize_locations(location: str) -> str:
+    """Normalize location names (handle typos)."""
+    if not location:
+        return None
+    
+    loc_lower = location.lower().strip()
+    
+    location_map = {
+        "lago": "lagos",
+        "lgs": "lagos",
+        "lag": "lagos",
+        "cotnu": "cotonou",
+        "cotonus": "cotonou",
+        "cotou": "cotonou",
+        "akpakpa": "akpakpa",
+        "nairobi": "nairobi",
+        "nbi": "nairobi",
+        "accra": "accra",
+        "acc": "accra",
+        "joburg": "johannesburg",
+        "jozi": "johannesburg",
+        "london": "london",
+        "paris": "paris",
+    }
+    
+    return location_map.get(loc_lower, location.lower())
 
-**Example 1 – Rental:**  
-You: *"I have a 3-bed apartment in Lagos, 150,000 per month"*  
-Me: *"Got it! 3 bed, monthly. What amenities? (WiFi, parking, etc.)"*
+def _normalize_amenities(amenities: list) -> list:
+    """Normalize amenity names (handle typos)."""
+    if not amenities:
+        return []
+    
+    amenity_map = {
+        "balcno": "balcony",
+        "balconny": "balcony",
+        "parkng": "parking",
+        "park": "parking",
+        "wifi": "wifi",
+        "furnisd": "furnished",
+        "furnishd": "furnished",
+        "furnish": "furnished",
+        "ac": "air conditioning",
+        "air cond": "air conditioning",
+        "aircond": "air conditioning",
+        "gym": "gym",
+        "pool": "pool",
+        "swiming": "pool",
+        "kitchen": "kitchen",
+        "kitchn": "kitchen",
+        "dryer": "dryer",
+        "garden": "garden",
+        "gdn": "garden",
+    }
+    
+    normalized = []
+    for amenity in amenities:
+        if not amenity:
+            continue
+        am_lower = amenity.lower().strip()
+        normalized_am = amenity_map.get(am_lower, am_lower)
+        if normalized_am and normalized_am not in normalized:
+            normalized.append(normalized_am)
+    
+    return normalized
 
-**Example 2 – Short-stay:**  
-You: *"My place in Lagos, 2 bedrooms, 5,000 per night"*  
-Me: *"Perfect! Short-stay in Lagos. What amenities?"*
+def _normalize_price_type(price_type: str) -> str:
+    """Normalize price_type (handle typos)."""
+    if not price_type:
+        return None
+    
+    pt_lower = price_type.lower().strip()
+    
+    price_type_map = {
+        "montly": "monthly",
+        "monthyl": "monthly",
+        "mth": "monthly",
+        "month": "monthly",
+        "nightl": "nightly",
+        "nightly": "nightly",
+        "night": "nightly",
+        "daily": "daily",
+        "day": "daily",
+        "weakly": "weekly",
+        "weakyl": "weekly",
+        "week": "weekly",
+        "yr": "yearly",
+        "year": "yearly",
+        "yearly": "yearly",
+        "annum": "yearly",
+    }
+    
+    return price_type_map.get(pt_lower, pt_lower)
 
-**Example 3 – Sale:**  
-You: *"Selling a 4-bed house in Ikoyi for 20 million"*  
-Me: *"Got it! 4-bed sale. What amenities?"*
+def _normalize_listing_type(listing_type: str) -> str:
+    """Normalize listing_type (handle typos)."""
+    if not listing_type:
+        return None
+    
+    lt_lower = listing_type.lower().strip()
+    
+    listing_type_map = {
+        "rent": "rent",
+        "for rent": "rent",
+        "rental": "rent",
+        "short stay": "short-stay",
+        "short-stay": "short-stay",
+        "shortsta": "short-stay",
+        "short stya": "short-stay",
+        "stayover": "short-stay",
+        "roommate": "roommate",
+        "roommat": "roommate",
+        "sharing": "roommate",
+        "flatmate": "roommate",
+        "shareflat": "roommate",
+        "sale": "sale",
+        "for sale": "sale",
+        "selling": "sale",
+        "sell": "sale",
+    }
+    
+    return listing_type_map.get(lt_lower, lt_lower)
 
-Now tell me about **your** property! 👇
-"""
+def _get_missing_fields(data: Dict) -> List[str]:
+    """Identify which REQUIRED fields are missing for listing creation."""
+    if data.get("intent") != "list":
+        return []
+    
+    required = ["location", "bedrooms", "bathrooms", "price", "listing_type", "price_type"]
+    missing = []
+    
+    for field in required:
+        value = data.get(field)
+        if value is None or value == "" or value == 0:
+            missing.append(field)
+    
+    return missing
 
-# ------------------------------------------------------------------
-# core node
-# ------------------------------------------------------------------
-@async_retry(strategy=RetryStrategy.MODERATE, operation_name="intent_node")
+def _get_next_question(missing_fields: List[str]) -> str:
+    """Get the next question based on missing fields."""
+    if not missing_fields:
+        return None
+    
+    next_field = missing_fields[0]
+    
+    questions = {
+        "location": "Where is the property located? (city/area)",
+        "bedrooms": "How many bedrooms?",
+        "bathrooms": "How many bathrooms?",
+        "price": "What's the price/rent amount?",
+        "listing_type": "Is it for rent, short-stay, sale, or roommate?",
+        "price_type": "Is it monthly, nightly, or yearly?"
+    }
+    
+    return questions.get(next_field, "What else should I know?")
+
+@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=1, max=5))
 async def intent_node(state: Dict) -> Dict:
-    current_msg = _get_current_message(state).lower()
-    user_id     = state.get("user_id")
-    user_role   = state.get("user_role", "renter")
-
-    # ===== COMMAND MODE (draft on screen) =====
-    if state.get("draft_preview"):
-        return _handle_draft_commands(state, current_msg)
-
-    # ===== STEP 1: CASUAL CHAT UNTIL CLEAR "LIST" =====
-    if not state.get("status") and not _is_clear_list_intent(current_msg):
-        # casual chat
-        state["intent"] = "chat"
-        state["ai_reply"] = "👋 Hey! Want to list a property or search for one? Just say *'I want to list'* when ready."
-        return state
-
-    # ===== STEP 2: FIRST CLEAR "LIST" → SHOW EXAMPLE ONLY =====
-    if _is_clear_list_intent(current_msg) and not state.get("status"):
-        state["intent"] = "list"
-        state["status"] = "collecting"
-        state["ai_reply"] = _listing_example()
-        return state
-
-    # ===== STEP 3: EXTRACT / VALIDATE / DRAFT FLOW =====
+    user_role = state["user_role"]
+    user_id = state.get("user_id")
     human_msg = state["messages"][-1]["content"]
 
-    with trace_operation("intent_node_ml", {"user_id": user_id}):
-        # 1. LLM extraction
-        try:
-            messages = await get_context_manager().manage_context([
-                {"role": "system", "content": "You are Aida, real-estate AI. Extract JSON only when property details appear."},
-                {"role": "user", "content": human_msg}
-            ])
-            text, _, _ = await call_llm_smart(messages, temperature=0.3, max_tokens=800)
-            data = json.loads(_clean_json(text))
-        except Exception:
-            state["ai_reply"] = "Sorry, I didn’t catch that. Could you rephrase?"
-            state["intent"] = "chat"
-            return state
-
-        # 2. merge fields
-        for k in ("location", "bedrooms", "bathrooms", "price", "price_type", "listing_type",
-                  "amenities", "requirements"):
-            if data.get(k) is not None:
-                state[k] = data[k]
-
-        # 3. strict listing-type → rental-model
-        listing_type = state.get("listing_type")
-        if listing_type == "rent":
-            rental_model = RentalModel.AFRICAN_RENTAL
-        elif listing_type == "short-stay":
-            rental_model = RentalModel.AIRBNB
-        elif listing_type == "roommate":
-            rental_model = RentalModel.ROOMMATE
-        elif listing_type == "sale":
-            rental_model = "sale"
-        else:
-            rental_model = RentalModel.MIXED
-        state["rental_model"] = rental_model.value if hasattr(rental_model, "value") else rental_model
-
-        # 4. ML refinement
-        if state.get("location"):
-            city, details = await ml_extractor.extract_location_from_address(state["location"])
-            if city:
-                state["location"] = city
-                state["location_details"] = details
-
-        # 5. ML validation
-        validation = ml_extractor.validate_all_fields(state, user_id)
-        state["field_validations"] = validation["field_validations"]
-
-        # 6. currency
-        currency, city, conf = await ml_extractor.infer_currency(state)
-        if currency:
-            state["currency"] = currency
-            state["currency_confidence"] = conf
-
-        # 7. build reply
-        if validation["all_valid"]:
-            state["status"] = "draft_ready"
-            state["ai_reply"] = _build_preview_prompt(state)
-        else:
-            missing = validation["issues"]
-            state["missing_fields"] = missing
-            state["ai_reply"] = _ask_next_missing(missing, state)
-
-        state["intent"] = "list"
-        return state
-
-# ------------------------------------------------------------------
-# sub-helpers (unchanged)
-# ------------------------------------------------------------------
-def _handle_draft_commands(state: Dict, msg: str) -> Dict:
-    if any(w in msg for w in {"publish", "go live", "post", "confirm", "yes", "ok"}):
-        state["intent"] = "publish"
-        state["ai_reply"] = ""
-        return state
-    if any(w in msg for w in {"edit", "change", "update", "fix"}):
-        state["intent"] = "edit"
-        state["edit_field"] = re.sub(r"\b(edit|change|update|fix)\b", "", msg).strip() or "general"
-        state["ai_reply"] = f"Sure! What would you like to change about **{state['edit_field']}**?"
-        return state
-    if any(w in msg for w in {"discard", "cancel", "delete", "no"}):
-        state["intent"] = "discard"
-        state["draft_preview"] = None
-        state["status"] = None
-        state["missing_fields"] = []
-        state["ai_reply"] = "Draft discarded! What would you like to do next?"
-        return state
-    if "search" in msg:
-        state["intent"] = "search"
-        return state
-    state["intent"] = "chat"
-    state["ai_reply"] = "Say **publish** to list it, **edit** to change something, or **discard** to start over."
-    return state
-
-def _build_preview_prompt(state: Dict) -> str:
-    title     = f"{state.get('bedrooms', '')}-Bedroom {state.get('listing_type', '').title()} in {state.get('location', '').title()}"
-    amenities = ", ".join(state.get("amenities", [])) or "None specified"
-    price     = f"{int(state.get('price', 0)):,} {state.get('price_type', '')}"
-    return f"""
-✨ **LISTING PREVIEW**
-
-🏠 **{title}**
-📍 Location: {state.get('location', '').title()}
-🛏️ Bedrooms: {state.get('bedrooms')}
-🚿 Bathrooms: {state.get('bathrooms')}
-💰 Price: {price} ({state.get('currency', 'XOF')})
-🎯 Amenities: {amenities}
-
-**What’s next?**
-- **publish** – Go live!
-- **edit [field]** – Change something
-- **discard** – Start over
+    prompt = SYSTEM_PROMPT.replace("{user_role}", user_role)
+    messages = [
+        {"role": "system", "content": prompt},
+        {"role": "user", "content": human_msg},
+    ]
+
+    logger.info("🤖 Aida intent call", user_role=user_role, msg=human_msg)
+    resp = await client.chat.completions.create(
+        model=MODEL,
+        messages=messages,
+        temperature=TEMP,
+        max_tokens=MAX_TOKENS,
+    )
+    raw = resp.choices[0].message.content.strip()
+    logger.debug("🤖 Aida raw response", raw=raw)
+
+    try:
+        cleaned = _clean_json(raw)
+        data = json.loads(cleaned)
+    except json.JSONDecodeError as e:
+        logger.error("❌ Aida bad json", raw=raw, exc_info=e)
+        data = {
+            "allowed": False,
+            "ai_reply": "Sorry, I didn't understand that. Could you rephrase?",
+        }
+
+    # Handle LISTING INTENT with progressive collection
+    if data.get("intent") == "list":
+        data["allowed"] = True
+        missing = _get_missing_fields(data)
+        
+        # ✅ SIMPLIFIED: Show introduction + example + image upload instruction (ONLY ON FIRST MESSAGE)
+        intro_and_example = """
+To list a property, here's how it's done:
+
+📝 **Example:**
+"I have a 3-bedroom, 2-bathroom property in Cotonou for rent at 50,000 XOF per month. It has a balcony, kitchen, and dryer. It's fully furnished. Renters must pay a 3-month deposit."
+
+📸 You can also upload property photos to make it more attractive!
 """
+        
+        # ✅ Only show example if this is the FIRST listing intent message (no data collected yet)
+        should_show_example = not any([
+            data.get("bedrooms"),
+            data.get("bathrooms"),
+            data.get("price"),
+            data.get("amenities"),
+            data.get("requirements")
+        ])
+        
+        if missing:
+            data["status"] = "collecting"
+            data["missing_fields"] = missing
+            data["next_question"] = _get_next_question(missing)
+            # ✅ Show example ONLY on first message, then just ask the question
+            if should_show_example:
+                data["ai_reply"] = intro_and_example
+            else:
+                data["ai_reply"] = _get_next_question(missing)
+        else:
+            data["status"] = "checking_optional"  # ✅ NEW: Check for amenities/requirements
+            data["missing_fields"] = []
+            # ✅ Don't show example if user already provided fields
+            if not should_show_example:
+                data["ai_reply"] = "Perfect! Any amenities or special requirements for renters?"
+            else:
+                data["ai_reply"] = intro_and_example
+    
+    # SEARCH is always allowed (role_gate_node will check)
+    if data.get("intent") == "search":
+        data["allowed"] = True
 
-def _ask_next_missing(missing: list, state: Dict) -> str:
-    questions = {
-        "location":   "📍 Where is the property located?",
-        "bedrooms":   "🛏️ How many bedrooms?",
-        "bathrooms":  "🚿 How many bathrooms?",
-        "price":      "💰 What’s the price/rent amount?",
-        "price_type": "Is it per month, per night, per year, etc.?"
-    }
-    next_f = missing[0] if missing else "amenities"
-    return "Issues found:\n" + "\n".join(f"❌ {m}" for m in missing) + f"\n\n{questions.get(next_f, 'Tell me more')}"
+    # Normalize values
+    location = _normalize_locations(data.get("location"))
+    amenities = _normalize_amenities(data.get("amenities", []))
+    price_type = _normalize_price_type(data.get("price_type"))
+    listing_type = _normalize_listing_type(data.get("listing_type"))
+
+    # ✅ SMART INFERENCE + ML VALIDATION with ERROR HANDLING
+    if data.get("intent") == "list":
+        location_input = data.get("location")
+        
+        # 1️⃣ Extract city from detailed address using Nominatim (WITH ERROR HANDLING)
+        if location_input:
+            try:
+                city, location_info = await ml_extractor.extract_location_from_address(location_input)
+                if city:
+                    data["location"] = city
+                    data["location_details"] = location_info
+                    logger.info(f"✅ Extracted city from address: {location_input} → {city}")
+            except Exception as e:
+                logger.warning(f"⚠️ Failed to extract location: {e}")
+                pass
+        
+        # 2️⃣ Infer listing_type from user role + message keywords
+        try:
+            listing_type, listing_confidence = ml_extractor.infer_listing_type(
+                data, 
+                user_role=user_role,
+                user_message=human_msg
+            )
+            if listing_type:
+                data["listing_type"] = listing_type
+                data["listing_confidence"] = listing_confidence
+                logger.info(f"✅ Inferred listing_type: {listing_type} (confidence: {listing_confidence})")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to infer listing_type: {e}")
+            pass
+        
+        # 3️⃣ Infer currency from location using Nominatim + REST Countries
+        try:
+            currency, extracted_city, currency_confidence = await ml_extractor.infer_currency(data)
+            if currency:
+                data["currency"] = currency
+                data["currency_confidence"] = currency_confidence
+                if extracted_city:
+                    data["location"] = extracted_city
+                logger.info(f"✅ Inferred currency: {currency} (confidence: {currency_confidence})")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to infer currency: {e}")
+            data["currency"] = data.get("currency", "XOF")
+        
+        # 4️⃣ ML VALIDATION of extracted fields (WITH ERROR HANDLING)
+        try:
+            validation_issues = []
+            validation_suggestions = []
+            field_validations = {}
+            
+            for field in ["location", "bedrooms", "bathrooms", "price", "price_type"]:
+                value = data.get(field)
+                if value is not None:
+                    result = ml_extractor.validate_field(field, value, human_msg, user_id)
+                    field_validations[field] = result
+                    
+                    if not result["is_valid"]:
+                        validation_issues.append(f"❌ {field}: {result['suggestion']}")
+                        logger.warning(f"Validation failed for {field}", suggestion=result["suggestion"])
+                    elif result["suggestion"]:
+                        validation_suggestions.append(f"⚠️ {field}: {result['suggestion']}")
+            
+            data["field_validations"] = field_validations
+            data["validation_suggestions"] = validation_suggestions
+            
+            # If validation issues, add them to the AI reply
+            if validation_issues:
+                current_reply = data.get("ai_reply", "")
+                data["ai_reply"] = current_reply + "\n\n" + "\n".join(validation_issues)
+                logger.info("ℹ️ ML validation issues found", issues=validation_issues)
+        
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to validate fields: {e}")
+            pass
+
+    intent_value = data.get("intent")
+    
+    # Update state with all fields
+    state.update(
+        allowed=data.get("allowed", False),
+        status=data.get("status"),
+        missing_fields=data.get("missing_fields", []),
+        next_question=data.get("next_question"),
+        
+        # Listing fields
+        listing_type=listing_type,
+        location=location,
+        bedrooms=data.get("bedrooms"),
+        bathrooms=data.get("bathrooms"),
+        price=data.get("price"),
+        price_type=price_type,
+        amenities=amenities,
+        requirements=data.get("requirements"),
+        
+        # Search fields
+        min_price=data.get("min_price"),
+        max_price=data.get("max_price"),
+        
+        # ML fields
+        field_validations=data.get("field_validations"),
+        listing_confidence=data.get("listing_confidence"),
+        currency_confidence=data.get("currency_confidence"),
+        location_details=data.get("location_details"),
+        validation_suggestions=data.get("validation_suggestions"),
+        
+        # Other
+        currency=data.get("currency", "XOF"),
+        ai_reply=data.get("ai_reply", ""),
+        draft_preview=data.get("draft_preview"),
+    )
+    
+    logger.info("📄 Intent node processed",
+                intent=intent_value,
+                status=state.get("status"),
+                missing_fields=state.get("missing_fields"),
+                location=state.get("location"))
+    
+    return state

app/ai/nodes/publish_node.py

@@ -1,4 +1,4 @@
-# app/ai/nodes/publish_node.py – FINAL: only runs when user says "publish" + LOG insert
+# app/ai/nodes/publish_node.py - FIXED WITH IMAGES IN MONGODB
 import datetime
 from typing import Dict
 from app.database import get_db
@@ -8,37 +8,38 @@ from bson import ObjectId
 
 logger = get_logger(__name__)
 
+# ---------- intent keywords ----------
 PUBLISH_WORDS = {"publish", "go live", "post it", "list it", "confirm", "yes", "ok", "okay"}
 
-# ---------- helpers ----------
-def _get_current_message(state: Dict) -> str:
-    """
-    Extract ONLY the current user message from the prompt we built in service.py
-    """
-    full = state["messages"][-1]["content"]
-    if "Now the user says:" in full:
-        return full.split("Now the user says:")[-1].strip()
-    return full.strip()
-
 # ---------- node ----------
 async def publish_node(state: Dict) -> Dict:
     """
-    Save draft to MongoDB as PUBLISHED when user explicitly confirms.
+    LangGraph node:
+    - If user says "publish" → save draft to MongoDB as PUBLISHED
+    - Set status to "published"
+    - Return success message with MongoDB ID
     """
-    if state.get("status") not in ["preview_shown", "waiting_for_images"] or not state.get("draft_preview"):
+    
+    # Only process if we have a draft preview waiting
+    if state.get("status") != "preview_shown" or not state.get("draft_preview"):
         return state
-
-    current_msg = _get_current_message(state).lower()
-    if not any(word in current_msg for word in PUBLISH_WORDS):
+    
+    last_text = state["messages"][-1]["content"].lower()
+    
+    # Check if user confirmed publish
+    if not any(word in last_text for word in PUBLISH_WORDS):
+        # User didn't confirm, stay in preview_shown state
         state["ai_reply"] = "Waiting for your confirmation. Say **publish** when ready!"
         return state
-
+    
+    # User confirmed! Save to MongoDB
     draft_preview = state["draft_preview"]
-
+    
     try:
         db = await get_db()
         col = db["listings"]
-
+        
+        # ✅ Build listing data with all fields including images
         listing_data = {
             "owner_id": state["user_id"],
             "type": draft_preview.get("listing_type"),
@@ -52,45 +53,46 @@ async def publish_node(state: Dict) -> Dict:
             "amenities": draft_preview.get("amenities", []),
             "requirements": draft_preview.get("requirements"),
             "currency": draft_preview.get("currency", "XOF"),
-            "images": draft_preview.get("images", []),
+            "images": draft_preview.get("images", []),  # ✅ INCLUDE IMAGES
             "status": "published",
             "created_at": datetime.datetime.utcnow(),
             "updated_at": datetime.datetime.utcnow(),
-            "views": 0,
-            "favorites": 0,
+            "views": 0,  # Initialize view counter
+            "favorites": 0,  # Initialize favorites counter
         }
-
+        
         result = await col.insert_one(listing_data)
         mongo_id = str(result.inserted_id)
-
-        # ===== NEW: log success =====
-        logger.info("✅ Listing INSERTED into MongoDB", mongo_id=mongo_id)
-        # ===== end NEW =====
-
+        
+        logger.info("✅ Listing published to MongoDB",
+                    mongo_id=mongo_id,
+                    title=draft_preview.get("title"),
+                    location=draft_preview.get("location"),
+                    image_count=len(draft_preview.get("images", [])))
+        
+        # Build success message with image info
         image_info = ""
         if draft_preview.get("images"):
-            image_info = f"\n🖼️ With {len(draft_preview['images'])} image(s)"
-
+            image_info = f"\n🖼️ With {len(draft_preview['images'])} image(s)"
+        
         state["ai_reply"] = f"""
-✅ **Listing Live!**
+✅ **Listing Live!**
 
 Your property is now published and visible to renters/buyers:
 - **Title:** {draft_preview.get('title')}
 - **Location:** {draft_preview.get('location')}
 - **Price:** {draft_preview.get('price'):,} {draft_preview.get('price_type')}{image_info}
 
-🎉 Users can now find your listing when they search!
+👉 Users can now find your listing when they search!
 
 Want to list another property? Just say "list a property"
 """
-        state["intent"] = None
         state["status"] = "published"
         state["mongo_id"] = mongo_id
-        logger.info("✅ Intent cleared and status set to published")
-
+        
     except Exception as e:
-        logger.error("❌ Publish failed", exc_info=e)
+        logger.error("❌ Failed to publish listing", exc_info=e)
         state["ai_reply"] = "Sorry, I couldn't publish your listing. Please try again."
         state["status"] = "error"
-
+    
     return state

app/ai/nodes/role_gate_node.py

@@ -13,23 +13,23 @@ def role_gate_node(state: Dict) -> Dict:
     - input:  state with allowed, listing_type, user_role, intent
     - output: same state (may flip allowed + set ai_reply)
     """
-    # 1. search intent → skip role check entirely
+    # 1. search intent → skip role check entirely
     if state.get("intent") == "search":
-        logger.info("✅ Passed search intent")
+        logger.info("Aida passed search intent")
         return state
 
     # 2. already blocked by intent node? keep message
     if not state.get("allowed", False):
-        logger.info("🚫 Already denied", reason="intent")
+        logger.info("Aida already denied", reason="intent")
         return state
 
-    # 3. casual chat (no listing_type) → leave reply untouched
+    # 3. casual chat (no listing_type) → leave reply untouched
     list_type = state.get("listing_type")
     if list_type is None:
-        logger.info("✅ Passed casual chat")
+        logger.info("Aida passed casual chat")
         return state
 
-    # 4. real-estate listing → role check
+    # 4. real-estate listing → role check
     allowed_set = LANDLORD_ALLOWED if state["user_role"] == "landlord" else RENTER_ALLOWED
     if list_type not in allowed_set:
         state["allowed"] = False
@@ -43,9 +43,9 @@ def role_gate_node(state: Dict) -> Dict:
                 "As a renter you can only list for roommate matching. "
                 "If you want to share your own space, great! Otherwise you can search listings."
             )
-        logger.info("🚫 Denied by role gate", user_role=state["user_role"], type=list_type)
+        logger.info("Aida denied by role gate", user_role=state["user_role"], type=list_type)
     else:
         state["ai_reply"] = state.get("ai_reply") or "Got it! Let me draft that for you."
-        logger.info("✅ Approved", user_role=state["user_role"], type=list_type)
+        logger.info("Aida approved", user_role=state["user_role"], type=list_type)
 
     return state

app/ai/nodes/search_node.py

@@ -1,27 +1,19 @@
-# app/ai/nodes/search_node.py - FINAL: Complete error handling + retry logic + observability
-import logging
+# app/ai/nodes/search_node.py - Return UI-ready search results
+import json
 import httpx
 from typing import Dict, List
 from qdrant_client import AsyncQdrantClient, models
-from tenacity import retry, stop_after_attempt, wait_exponential
-
 from app.config import settings
-from app.core.error_handling import (
-    async_retry,
-    RetryStrategy,
-    trace_operation,
-    VectorDBError,
-)
+from structlog import get_logger
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 EMBED_MODEL = "qwen/qwen3-embedding-8b"
 TOP_K = 6
 
-# ============================================================
-# Qdrant Client
-# ============================================================
-
+# ------------------------------------------------------------------
+# Qdrant client
+# ------------------------------------------------------------------
 qdrant_client = AsyncQdrantClient(
     url=settings.QDRANT_URL,
     api_key=settings.QDRANT_API_KEY,
@@ -29,26 +21,7 @@ qdrant_client = AsyncQdrantClient(
     timeout=60,
 )
 
-# ============================================================
-# Custom Exceptions
-# ============================================================
-
-class SearchError(Exception):
-    """Base exception for search operations."""
-    pass
-
-class EmbeddingError(SearchError):
-    """Embedding generation error."""
-    pass
-
-class QdrantSearchError(SearchError):
-    """Qdrant search error."""
-    pass
-
-# ============================================================
-# Helpers
-# ============================================================
-
+# ---------- helpers ----------
 def _build_filter(state: Dict) -> models.Filter:
     """Build comprehensive Qdrant filter from ALL search fields."""
     must = []
@@ -63,7 +36,7 @@ def _build_filter(state: Dict) -> models.Filter:
             )
         )
     
-    # Price range filters
+    # Price range filters (combine into single condition)
     if state.get("min_price") is not None or state.get("max_price") is not None:
         price_range = {}
         if state.get("min_price") is not None:
@@ -97,7 +70,7 @@ def _build_filter(state: Dict) -> models.Filter:
             )
         )
     
-    # Price type filter
+    # Price type filter (monthly, nightly, yearly, etc.)
     price_type = (state.get("price_type") or "").lower()
     if price_type:
         must.append(
@@ -107,7 +80,7 @@ def _build_filter(state: Dict) -> models.Filter:
             )
         )
     
-    # Listing type filter
+    # Listing type filter (rent, short_stay, roommate, sale)
     listing_type = (state.get("listing_type") or "").lower()
     if listing_type:
         must.append(
@@ -117,7 +90,7 @@ def _build_filter(state: Dict) -> models.Filter:
             )
         )
     
-    # Amenities filter
+    # Amenities filter (all mentioned amenities must exist in listing)
     amenities = state.get("amenities", [])
     if amenities:
         for amenity in amenities:
@@ -131,94 +104,46 @@ def _build_filter(state: Dict) -> models.Filter:
                 )
     
     filt = models.Filter(must=must) if must else models.Filter()
-    logger.info(
-        "🔍 Filter built",
-        extra={
-            "conditions": len(must),
-            "location": loc,
-            "price_range": f"{state.get('min_price')}-{state.get('max_price')}",
-            "bedrooms": state.get("bedrooms"),
-            "amenities": len(amenities),
-        }
-    )
+    logger.info("🔍 Filter built", must_conditions=len(must), location=loc, 
+                min_price=state.get("min_price"), max_price=state.get("max_price"),
+                bedrooms=state.get("bedrooms"), bathrooms=state.get("bathrooms"),
+                amenities=amenities, price_type=price_type, listing_type=listing_type)
     return filt
 
-@async_retry(strategy=RetryStrategy.MODERATE, operation_name="embedding_generation")
+
 async def _embed(text: str) -> List[float]:
-    """
-    Generate embedding with retry logic and error handling.
-    
-    Raises:
-        EmbeddingError: If embedding generation fails
-    """
-    
-    with trace_operation("embedding_generation", {"text_length": len(text)}):
-        if not text or not text.strip():
-            logger.error("❌ Empty text provided for embedding")
-            raise EmbeddingError("Empty text provided for embedding")
-        
-        payload = {
-            "model": EMBED_MODEL,
-            "input": text,
-            "encoding_format": "float",
-        }
-        headers = {
-            "Authorization": f"Bearer {settings.OPENROUTER_API_KEY}",
-            "Content-Type": "application/json",
-            "HTTP-Referer": "",
-            "X-Title": "",
-        }
-        
-        try:
-            async with httpx.AsyncClient(timeout=60) as client:
-                logger.info("🤖 Calling embedding API")
-                resp = await client.post(
-                    "https://openrouter.ai/api/v1/embeddings",
-                    headers=headers,
-                    json=payload,
-                    timeout=60,
-                )
-                resp.raise_for_status()
-                
-                data = resp.json()
-                if not data.get("data"):
-                    logger.error("❌ Empty embedding response")
-                    raise EmbeddingError("Empty embedding response from API")
-                
-                embedding = data["data"][0]["embedding"]
-                logger.info(f"✅ Embedding generated, dimension={len(embedding)}")
-                return embedding
-        
-        except httpx.HTTPError as e:
-            logger.error(f"❌ Embedding API HTTP error: {e}", exc_info=True)
-            raise EmbeddingError(f"HTTP error calling embedding API: {e}")
-        except KeyError as e:
-            logger.error(f"❌ Embedding response malformed: {e}", exc_info=True)
-            raise EmbeddingError(f"Malformed embedding response: {e}")
-        except Exception as e:
-            logger.error(f"❌ Unexpected embedding error: {e}", exc_info=True)
-            raise EmbeddingError(f"Unexpected error generating embedding: {e}")
+    """Call OpenRouter embedding endpoint (async)."""
+    payload = {
+        "model": EMBED_MODEL,
+        "input": text,
+        "encoding_format": "float",
+    }
+    headers = {
+        "Authorization": f"Bearer {settings.OPENROUTER_API_KEY}",
+        "Content-Type": "application/json",
+        "HTTP-Referer": "",
+        "X-Title": "",
+    }
+    async with httpx.AsyncClient(timeout=60) as client:
+        resp = await client.post(
+            "https://openrouter.ai/api/v1/embeddings",
+            headers=headers,
+            json=payload,
+        )
+        resp.raise_for_status()
+        return resp.json()["data"][0]["embedding"]
+
 
-@async_retry(strategy=RetryStrategy.MODERATE, operation_name="qdrant_search")
+# ---------- suggestion helpers ----------
 async def _search_with_must(must: List, vector: List[float]):
-    """Execute Qdrant search with retry logic."""
-    
-    with trace_operation("qdrant_search_execution", {"filter_count": len(must)}):
-        try:
-            logger.info("🔎 Executing Qdrant search")
-            hits = await qdrant_client.search(
-                collection_name="listings",
-                query_vector=vector,
-                query_filter=models.Filter(must=must),
-                limit=TOP_K,
-                with_payload=True,
-            )
-            logger.info(f"✅ Qdrant search returned {len(hits)} results")
-            return hits
-        
-        except Exception as e:
-            logger.error(f"❌ Qdrant search failed: {e}", exc_info=True)
-            raise QdrantSearchError(f"Qdrant search failed: {e}")
+    return await qdrant_client.search(
+        collection_name="listings",
+        query_vector=vector,
+        query_filter=models.Filter(must=must),
+        limit=TOP_K,
+        with_payload=True,
+    )
+
 
 def _add_price_range(must: List, state: Dict):
     """Add combined price range filter."""
@@ -230,225 +155,143 @@ def _add_price_range(must: List, state: Dict):
             price_range["lte"] = state["max_price"]
         
         if price_range:
-            must.append(
-                models.FieldCondition(
-                    key="price",
-                    range=models.Range(**price_range)
-                )
-            )
+            must.append(models.FieldCondition(key="price", range=models.Range(**price_range)))
+
 
-def _hits_to_cards(hits) -> List[dict]:
+def _hits_to_cards(hits):
     """Convert Qdrant hits to UI cards."""
-    cards = []
-    for hit in hits:
-        try:
-            card = {
-                "id": hit.id,
-                "title": (
-                    hit.payload.get("title") or
-                    f"{hit.payload.get('bedrooms', '')}-bed {hit.payload.get('location', '')}"
-                ),
-                "location": hit.payload.get("location"),
-                "price": hit.payload.get("price"),
-                "price_type": hit.payload.get("price_type"),
-                "bedrooms": hit.payload.get("bedrooms"),
-                "bathrooms": hit.payload.get("bathrooms"),
-                "amenities": hit.payload.get("amenities", []),
-                "description": hit.payload.get("description"),
-                "listing_type": hit.payload.get("listing_type"),
-                "images": hit.payload.get("images", []),
-                "currency": hit.payload.get("currency", "XOF"),
-            }
-            cards.append(card)
-        except Exception as e:
-            logger.warning(f"⚠️ Failed to convert hit to card: {e}")
-            continue
-    
-    return cards
+    return [
+        {
+            "id": hit.id,
+            "title": hit.payload.get("title") or f"{hit.payload.get('bedrooms', '')}-bed {hit.payload.get('location', '')}",
+            "location": hit.payload.get("location"),
+            "price": hit.payload.get("price"),
+            "price_type": hit.payload.get("price_type"),
+            "bedrooms": hit.payload.get("bedrooms"),
+            "bathrooms": hit.payload.get("bathrooms"),
+            "amenities": hit.payload.get("amenities", []),
+            "description": hit.payload.get("description"),
+            "listing_type": hit.payload.get("listing_type"),
+            "images": hit.payload.get("images", []),  # ✅ Include images for UI
+            "currency": hit.payload.get("currency", "XOF"),
+        }
+        for hit in hits
+    ]
+
 
 async def _suggest_relaxed(state: Dict, vector: List[float]) -> List[dict]:
     """
     Loosen constraints progressively while keeping location strict.
-    Returns relaxed search results if exact match not found.
+    If no location specified, return empty.
     """
-    
-    with trace_operation("suggest_relaxed", {"location": state.get("location")}):
-        loc = (state.get("location") or "").lower()
-        br = state.get("bedrooms")
-        amenities = state.get("amenities", [])
+    loc = (state.get("location") or "").lower()
+    br = state.get("bedrooms")
+    amenities = state.get("amenities", [])
 
-        # If no location specified, return empty
-        if not loc:
-            logger.warning("⚠️ No location specified for suggestion")
-            return []
+    # If no location specified, return empty
+    if not loc:
+        return []
 
-        # Location is ALWAYS a hard constraint
-        location_filter = models.FieldCondition(
-            key="location_lower",
-            match=models.MatchValue(value=loc)
-        )
+    # Location is ALWAYS a hard constraint
+    location_filter = models.FieldCondition(
+        key="location_lower",
+        match=models.MatchValue(value=loc)
+    )
 
-        # Try progressively looser constraints
-        
-        # 1. All filters
-        try:
-            logger.info("🔄 Trying search with all filters")
-            must = [location_filter]
-            if br is not None:
-                must.append(
-                    models.FieldCondition(
-                        key="bedrooms",
-                        match=models.MatchValue(value=br)
-                    )
-                )
-            _add_price_range(must, state)
-            for amenity in amenities:
-                must.append(
-                    models.FieldCondition(
-                        key="amenities",
-                        match=models.MatchValue(value=amenity.lower())
-                    )
-                )
-            hits = await _search_with_must(must, vector)
-            if hits:
-                logger.info("✅ Found results with all filters")
-                return _hits_to_cards(hits)
-        except Exception as e:
-            logger.warning(f"⚠️ Search with all filters failed: {e}")
+    # 1. Try with all filters intact
+    must = [location_filter]
+    if br is not None:
+        must.append(models.FieldCondition(key="bedrooms", match=models.MatchValue(value=br)))
+    _add_price_range(must, state)
+    for amenity in amenities:
+        must.append(models.FieldCondition(key="amenities", match=models.MatchValue(value=amenity.lower())))
+    hits = await _search_with_must(must, vector)
+    if hits:
+        return _hits_to_cards(hits)
 
-        # 2. No amenities
-        try:
-            logger.info("🔄 Trying search without amenities")
-            must = [location_filter]
-            if br is not None:
-                must.append(
-                    models.FieldCondition(
-                        key="bedrooms",
-                        match=models.MatchValue(value=br)
-                    )
-                )
-            _add_price_range(must, state)
-            hits = await _search_with_must(must, vector)
-            if hits:
-                logger.info("✅ Found results without amenities")
-                return _hits_to_cards(hits)
-        except Exception as e:
-            logger.warning(f"⚠️ Search without amenities failed: {e}")
+    # 2. Loosen amenities (remove optional ones)
+    must = [location_filter]
+    if br is not None:
+        must.append(models.FieldCondition(key="bedrooms", match=models.MatchValue(value=br)))
+    _add_price_range(must, state)
+    hits = await _search_with_must(must, vector)
+    if hits:
+        return _hits_to_cards(hits)
 
-        # 3. Adjust bedrooms ±1
-        if br is not None:
-            try:
-                logger.info("🔄 Trying search with adjusted bedrooms")
-                must = [location_filter]
-                new_br = br - 1 if br > 1 else br + 1
-                must.append(
-                    models.FieldCondition(
-                        key="bedrooms",
-                        match=models.MatchValue(value=new_br)
-                    )
-                )
-                _add_price_range(must, state)
-                hits = await _search_with_must(must, vector)
-                if hits:
-                    logger.info(f"✅ Found results with {new_br} bedrooms")
-                    return _hits_to_cards(hits)
-            except Exception as e:
-                logger.warning(f"⚠️ Search with adjusted bedrooms failed: {e}")
+    # 3. Loosen bedrooms ±1, keep location strict
+    if br is not None:
+        must = [location_filter]
+        new_br = br - 1 if br > 1 else br + 1
+        must.append(models.FieldCondition(key="bedrooms", match=models.MatchValue(value=new_br)))
+        _add_price_range(must, state)
+        hits = await _search_with_must(must, vector)
+        if hits:
+            return _hits_to_cards(hits)
 
-        # 4. Relax price +25%
-        try:
-            logger.info("🔄 Trying search with relaxed price")
-            must = [location_filter]
-            if br is not None:
-                must.append(
-                    models.FieldCondition(
-                        key="bedrooms",
-                        match=models.MatchValue(value=br)
-                    )
-                )
-            if state.get("max_price") is not None:
-                relaxed_max = int(state["max_price"] * 1.25)
-                must.append(
-                    models.FieldCondition(
-                        key="price",
-                        range=models.Range(lte=relaxed_max)
-                    )
-                )
-            else:
-                _add_price_range(must, state)
-            hits = await _search_with_must(must, vector)
-            if hits:
-                logger.info("✅ Found results with relaxed price")
-                return _hits_to_cards(hits)
-        except Exception as e:
-            logger.warning(f"⚠️ Search with relaxed price failed: {e}")
+    # 4. Loosen price +25%, keep location strict
+    must = [location_filter]
+    if br is not None:
+        must.append(models.FieldCondition(key="bedrooms", match=models.MatchValue(value=br)))
+    if state.get("max_price") is not None:
+        relaxed_max = int(state["max_price"] * 1.25)
+        must.append(models.FieldCondition(key="price", range=models.Range(lte=relaxed_max)))
+    else:
+        _add_price_range(must, state)
+    hits = await _search_with_must(must, vector)
+    if hits:
+        return _hits_to_cards(hits)
 
-        logger.warning("⚠️ No results found even with relaxed criteria")
-        return []
+    return []
 
-# ============================================================
-# Search Node
-# ============================================================
 
+# ---------- node ----------
 async def search_node(state: Dict) -> Dict:
     """
-    LangGraph node: Comprehensive search with all filters
+    LangGraph node: comprehensive search with all filters
+    - title/description (semantic via embedding)
+    - location, price range, bedrooms, bathrooms, amenities (keyword filters)
+    - price_type, listing_type
     
-    Features:
-    - Semantic search via embeddings
-    - Keyword filters (location, price, bedrooms, etc.)
-    - Error handling with graceful fallback
-    - Suggestion system for zero-hit scenarios
-    - UI-ready response format
+    ✅ RETURNS: search_results + search_preview (UI-ready)
     """
+    query = state.get("search_query", "") or state["messages"][-1]["content"]
+    vector = await _embed(query)
+    filt = _build_filter(state)
+
+    logger.info("🔍 Searching Qdrant", query=query, filter=str(filt))
     
-    with trace_operation(
-        "search_node",
-        {
-            "location": state.get("location"),
-            "bedrooms": state.get("bedrooms"),
-            "min_price": state.get("min_price"),
-            "max_price": state.get("max_price"),
-        }
-    ):
-        query = state.get("search_query", "") or state["messages"][-1]["content"]
-        logger.info(f"🔍 Starting search for: {query[:100]}")
-        
-        # ===== Generate embedding =====
-        try:
-            with trace_operation("embed_query"):
-                vector = await _embed(query)
-                logger.info("✅ Query embedded successfully")
-        except EmbeddingError as e:
-            logger.error(f"❌ Embedding failed: {e}")
-            state["ai_reply"] = "Sorry, I couldn't process your search right now. Please try again."
-            state["search_preview"] = {
-                "type": "search_results",
-                "count": 0,
-                "query": query,
-                "filters": {},
-                "results": [],
-                "message": "Search temporarily unavailable",
-                "error": "embedding_failed",
-            }
-            state["search_results"] = []
-            return state
-        
-        # ===== Build filter =====
-        filt = _build_filter(state)
-        
-        # ===== Execute search =====
-        try:
-            with trace_operation("execute_search"):
-                logger.info("🔎 Executing search")
-                hits = await _search_with_must(filt.must if filt.must else [], vector)
-                logger.info(f"✅ Search returned {len(hits)} results")
-        except QdrantSearchError as e:
-            logger.error(f"❌ Search failed: {e}")
-            state["ai_reply"] = "Sorry, I'm having trouble searching right now. Please try again."
-            state["search_preview"] = {
+    hits = await qdrant_client.search(
+        collection_name="listings",
+        query_vector=vector,
+        query_filter=filt,
+        limit=TOP_K,
+        with_payload=True,
+    )
+
+    logger.info("📊 Qdrant search result", hits_count=len(hits))
+    cards = _hits_to_cards(hits)
+
+    # --- personalize zero-hit reply + suggestions + UI preview
+    if not cards:
+        location = state.get("location") or "that area"
+        bedrooms = state.get("bedrooms")
+        price_bit = (
+            " in your price range"
+            if state.get("min_price") is not None or state.get("max_price") is not None
+            else ""
+        )
+        br_bit = f" with {bedrooms} bedrooms" if bedrooms else ""
+        amenities_bit = f" with {', '.join(state.get('amenities', []))}" if state.get("amenities") else ""
+
+        suggestions = await _suggest_relaxed(state, vector)
+        if suggestions:
+            state["ai_reply"] = (
+                f"I found no exact match for your request, "
+                f"but you might like these similar options:"
+            )
+            state["search_preview"] = {  # ✅ NEW: UI-ready preview for suggestions
                 "type": "search_results",
-                "count": 0,
+                "count": len(suggestions),
                 "query": query,
                 "filters": {
                     "location": state.get("location"),
@@ -456,77 +299,22 @@ async def search_node(state: Dict) -> Dict:
                     "max_price": state.get("max_price"),
                     "bedrooms": state.get("bedrooms"),
                     "bathrooms": state.get("bathrooms"),
+                    "price_type": state.get("price_type"),
+                    "listing_type": state.get("listing_type"),
                     "amenities": state.get("amenities", []),
                 },
-                "results": [],
-                "message": "Search service temporarily unavailable",
-                "error": "search_failed",
+                "results": suggestions,
+                "message": "Similar options available"
             }
-            state["search_results"] = []
-            return state
-        
-        cards = _hits_to_cards(hits)
-        
-        # ===== Handle zero-hit scenario =====
-        if not cards:
-            logger.info("ℹ️ No exact matches found, generating suggestions")
-            location = state.get("location") or "that area"
-            
-            try:
-                suggestions = await _suggest_relaxed(state, vector)
-            except Exception as e:
-                logger.warning(f"⚠️ Failed to generate suggestions: {e}")
-                suggestions = []
-            
-            if suggestions:
-                state["ai_reply"] = (
-                    f"I found no exact match for your request, "
-                    f"but you might like these similar options:"
-                )
-                state["search_preview"] = {
-                    "type": "search_results",
-                    "count": len(suggestions),
-                    "query": query,
-                    "filters": {
-                        "location": state.get("location"),
-                        "min_price": state.get("min_price"),
-                        "max_price": state.get("max_price"),
-                        "bedrooms": state.get("bedrooms"),
-                        "bathrooms": state.get("bathrooms"),
-                        "price_type": state.get("price_type"),
-                        "listing_type": state.get("listing_type"),
-                        "amenities": state.get("amenities", []),
-                    },
-                    "results": suggestions,
-                    "message": "Similar options available",
-                }
-                state["search_results"] = suggestions
-            else:
-                state["ai_reply"] = f"I found no property in {location}. Try widening your search or check back later!"
-                state["search_preview"] = {
-                    "type": "search_results",
-                    "count": 0,
-                    "query": query,
-                    "filters": {
-                        "location": state.get("location"),
-                        "min_price": state.get("min_price"),
-                        "max_price": state.get("max_price"),
-                        "bedrooms": state.get("bedrooms"),
-                        "bathrooms": state.get("bathrooms"),
-                        "price_type": state.get("price_type"),
-                        "listing_type": state.get("listing_type"),
-                        "amenities": state.get("amenities", []),
-                    },
-                    "results": [],
-                    "message": "No results found",
-                }
-                state["search_results"] = []
+            state["search_results"] = suggestions
         else:
-            logger.info(f"✅ Found {len(cards)} results")
-            state["ai_reply"] = f"Here are {len(cards)} places I found for you:"
-            state["search_preview"] = {
+            state["ai_reply"] = (
+                f"I found no property in {location}{price_bit}{br_bit}{amenities_bit}. "
+                "Try widening your search or check back later!"
+            )
+            state["search_preview"] = {  # ✅ Empty UI state
                 "type": "search_results",
-                "count": len(cards),
+                "count": 0,
                 "query": query,
                 "filters": {
                     "location": state.get("location"),
@@ -538,10 +326,30 @@ async def search_node(state: Dict) -> Dict:
                     "listing_type": state.get("listing_type"),
                     "amenities": state.get("amenities", []),
                 },
-                "results": cards,
-                "message": f"Found {len(cards)} listings",
+                "results": [],
+                "message": "No results found"
             }
-            state["search_results"] = cards
-        
-        logger.info("✅ Search node completed")
-        return state
+    else:
+        state["ai_reply"] = f"Here are {len(cards)} places I found for you:"
+        # ✅ NEW: Return UI-ready search preview
+        state["search_preview"] = {
+            "type": "search_results",
+            "count": len(cards),
+            "query": query,
+            "filters": {
+                "location": state.get("location"),
+                "min_price": state.get("min_price"),
+                "max_price": state.get("max_price"),
+                "bedrooms": state.get("bedrooms"),
+                "bathrooms": state.get("bathrooms"),
+                "price_type": state.get("price_type"),
+                "listing_type": state.get("listing_type"),
+                "amenities": state.get("amenities", []),
+            },
+            "results": cards,
+            "message": f"Found {len(cards)} listings"
+        }
+        state["search_results"] = cards
+
+    logger.info("Aida search finished", query=query, count=len(cards), suggestions=len(state.get("suggestions", [])))
+    return state

app/ai/prompts/system_prompt.txt

@@ -1,89 +1,76 @@
-You are Aida, Lojiz's friendly real-estate AI assistant.
-User role: {user_role}  (landlord | renter | airbnb_host | roommate_seeker | seller | buyer)
+u are Aida, Lojiz's friendly real-estate AI assistant.
+User role: {user_role}  (landlord | renter)
 
 ------------------------------------------------------
-BRAND IDENTITY
+BRAND IDENTITY & RESPONSES
 ------------------------------------------------------
 
-WHO YOU ARE:
+**WHO YOU ARE:**
 - You are AIDA, Lojiz's proprietary real-estate AI assistant
 - Do NOT mention DeepSeek, GPT, or any other LLM names
 - You are a standalone AI developed specifically for Lojiz
 - Never refer to yourself as based on other AI models
 
-IF ASKED "WHO ARE YOU?":
-"I'm Aida, Lojiz's AI real-estate assistant. I help landlords list properties, renters find homes, and more!"
+**IF ASKED "WHO ARE YOU?"**
+"I'm Aida, Lojiz's AI real-estate assistant. I help landlords list properties and renters find their perfect home!"
 
-IF ASKED "WHO DESIGNED YOU?":
+**IF ASKED "WHO DESIGNED YOU?" OR "WHO CREATED YOU?"**
 "I was designed and developed by the Lojiz team. Our talented team includes:
-- Emeka Destiny Ebuka - Lead AI & ML Engineer/Developer
-- Uche Samuel Chukwuemeka - Product Designer
+- **Emeka Destiny Ebuka** - Lead AI & ML Engineer/Developer - designed my intelligence and learning capabilities
+- **Uche Samuel Chukwuemeka** - Product Designer - shaped my user experience and personality
+
 Together, they created me to make real-estate transactions easier and more accessible for everyone."
 
-IF ASKED "ARE YOU AN LLM?":
-"I'm Aida, Lojiz's specialized AI assistant. I'm not just a general-purpose AI - I'm specifically built to understand real-estate, help with property listings, and guide users through the Lojiz platform."
+**IF ASKED "WHO BUILT YOU?" OR "WHAT COMPANY MADE YOU?"**
+"I'm built by Lojiz, a real-estate platform designed to connect landlords and renters seamlessly across Africa. The Lojiz team created me with passion and expertise in AI and real-estate technology."
 
-NEVER SAY:
-- "I'm based on DeepSeek"
-- "I'm powered by GPT"
-- "I'm an LLM (Language Model)"
+**IF ASKED "ARE YOU AN LLM?" OR "WHAT MODEL ARE YOU?"**
+"I'm Aida, Lojiz's specialized AI assistant. I'm not just a general-purpose AI - I'm specifically built to understand real-estate, help with property listings, and guide users through the Lojiz platform. That's what makes me different!"
 
-------------------------------------------------------
-PERSONALITY
-------------------------------------------------------
-- Speak like a human, short and warm
-- IGNORE typos and grammar mistakes. Understand intent anyway
-- If user talks off-topic, reply casually and ask: "Would you like to list a property or search for one?"
-- Only switch to JSON when property details are mentioned
-- Be proud of being Aida - make it clear you're specialized in real-estate
+**NEVER SAY:**
+- ❌ "I'm based on DeepSeek"
+- ❌ "I'm powered by GPT"
+- ❌ "I'm an LLM (Language Model)"
+- ❌ "I was trained on general data"
+- ✅ Say "I'm Aida, Lojiz's AI assistant" instead
 
 ------------------------------------------------------
-ROLE-BASED BEHAVIOR
+PERSONALITY & GRAMMAR TOLERANCE
 ------------------------------------------------------
-
-Detect and adapt to different user roles:
-
-LANDLORD:
-- Help list properties for rent or sale
-- Focus on: location, price, amenities, tenant requirements
-- Price types: monthly, yearly
-- Listing types: rent, short-stay, sale
-
-RENTER/TENANT:
-- Help search for rental properties
-- Focus on: budget, location, amenities needed
-- Can also list rooms for roommate matching
-- Listing types: roommate
-
-AIRBNB HOST:
-- Help list short-stay vacation properties
-- Focus on: guest amenities, location convenience
-- Price types: nightly, daily, weekly
-- Listing type: short-stay
-
-ROOMMATE SEEKER:
-- Help find rooms to share or advertise spare rooms
-- Focus on: compatibility, house rules, utilities included
-- Price types: monthly, yearly
-- Listing type: roommate
-
-SELLER (Property Sale):
-- Help list properties for sale
-- Focus on: property condition, location, price
-- Listing type: sale
-
-BUYER:
-- Help search for properties to purchase
-- Focus on: budget range, location, property type
+- Speak like a human, short and warm.
+- IGNORE typos, grammar mistakes, and spelling errors. Understand intent anyway.
+- If the user greets or talks off-topic, reply casually and ask: "Would you like to list a property or search for one?"
+- Only switch to JSON output when property details are mentioned OR when user clearly wants to SEARCH / SEE / FIND houses/flats/rooms/apartments.
+- Be proud of being Aida - make it clear you're a specialized real-estate AI
 
 ------------------------------------------------------
-PRESERVE USER CORRECTIONS
+CRITICAL: PRESERVE USER CORRECTIONS
 ------------------------------------------------------
-IMPORTANT: If a user corrects ANY field (location, bedrooms, price, etc.), PRESERVE that correction
+- ⚠️ IMPORTANT: If a user corrects ANY field (location, bedrooms, price, etc.), PRESERVE that correction
 - Do NOT regenerate or revert corrections when showing previews
 - Example: If user says "actually it's in Calavi not Cotonou", update state AND keep it that way
-- When showing draft preview, always use the LATEST corrected values
-- If a user requests changes, apply them WITHOUT reverting previous corrections
+- When showing draft preview, always use the LATEST corrected values from state
+- If a user requests changes (amenity icons, requirements, etc.), apply them WITHOUT reverting previous corrections
+
+------------------------------------------------------
+AMENITY ICONS
+------------------------------------------------------
+When user requests "icons" or "emojis" for amenities, respond with this format:
+
+📶 Wifi | 🅿️ Parking | 🛋️ Furnished | 🧼 Washing Machine | 🔥 Dryer | 🏞️ Balcony | 🏊 Pool | 💪 Gym | 🌿 Garden | ❄️ Air Conditioning | 🍳 Kitchen
+
+Backend will automatically add icons to all amenities listed:
+- wifi → 📶
+- parking → 🅿️
+- furnished → 🛋️
+- washing machine / washing → 🧼
+- dryer → 🔥
+- balcony → 🏞️
+- pool → 🏊
+- gym → 💪
+- garden → 🌿
+- air conditioning / ac → ❄️
+- kitchen → 🍳
 
 ------------------------------------------------------
 LISTING CREATION - PROGRESSIVE COLLECTION
@@ -104,26 +91,27 @@ OPTIONAL FIELDS (Ask, but not required):
 AUTO-GENERATED:
 - title (AI generates from location, bedrooms, listing_type)
 - description (AI generates professional description)
-- currency (auto-detect from location: Lagos=NGN, Cotonou=XOF, etc.)
+- currency (auto-detect from location: Lagos→NGN, Cotonou→XOF, etc.)
+- amenities_with_icons (backend adds icons to all amenities)
 
 LOCATION EXTRACTION:
 - Extract ONLY the city/area name
 - Ignore long descriptions
 - Examples:
-  "calavi quartier zogbadje" -> location: "calavi"
-  "VI in Lagos" -> location: "lagos"
-  "Lekki, Lagos" -> location: "lagos"
+  "calavi quartier zogbadje" → location: "calavi"
+  "VI in Lagos" → location: "lagos"
+  "Lekki, Lagos" → location: "lagos"
 
 LISTING TYPE AUTO-DETECTION:
-- "for rent" / "monthly" / "yearly" -> rent
-- "short stay" / "nightly" / "daily" / "weekly" -> short-stay
-- "for sale" / "selling" -> sale
-- "roommate" / "sharing" / "flatmate" -> roommate
+- "for rent" / "monthly" / "yearly" → rent
+- "short stay" / "nightly" / "daily" / "weekly" → short-stay
+- "for sale" / "selling" → sale
+- "roommate" / "sharing" / "flatmate" → roommate
 
 PRICE TYPE AUTO-DETECTION:
-- "monthly" / "month" / "per month" / "mth" -> monthly
-- "nightly" / "night" / "per night" / "daily" / "day" -> nightly
-- "yearly" / "year" / "per year" / "annum" -> yearly
+- "monthly" / "month" / "per month" / "mth" → monthly
+- "nightly" / "night" / "per night" / "daily" / "day" → nightly
+- "yearly" / "year" / "per year" / "annum" → yearly
 
 PROGRESSIVE COLLECTION FLOW:
 1. User provides initial info (may be incomplete)
@@ -132,10 +120,10 @@ PROGRESSIVE COLLECTION FLOW:
 4. Ask for missing fields ONE AT A TIME
 5. User provides each field (or corrects previous ones)
 6. Append/update to existing fields
-7. When ALL required fields complete -> Ask for optional fields
-8. When amenities/requirements collected -> Generate DRAFT
+7. When ALL required fields complete → Ask for optional fields
+8. When amenities/requirements collected → Generate DRAFT
 9. Show DRAFT preview to user
-10. User can request changes - PRESERVE all corrections
+10. User can request changes (icons, updates, etc.) - PRESERVE all corrections
 11. User reviews and says "publish" to confirm
 
 ------------------------------------------------------
@@ -147,7 +135,7 @@ When user starts listing a property:
 2. Check for missing REQUIRED fields
 3. Ask missing fields one by one
 4. Build up state progressively
-5. PRESERVE all corrections and changes
+5. ⚠️ PRESERVE all corrections and changes
 
 Response format while collecting:
 {
@@ -162,7 +150,7 @@ Response format while collecting:
   "requirements": null,
   "status": "collecting",
   "missing_fields": ["amenities", "requirements"],
-  "next_question": "Any amenities? (e.g., wifi, parking, balcony, pool, furnished, kitchen)",
+  "next_question": "Any amenities? (e.g., wifi, parking, balcony, pool, furnished, kitchen, dryer, garden, etc.)",
   "ai_reply": "Great! I have: 2-bed in Lagos, 50k/month. Any amenities?"
 }
 
@@ -183,8 +171,72 @@ When ALL required fields complete:
   "draft_preview": null
 }
 
+When requesting amenity icons:
+{
+  "intent": "list",
+  "status": "draft_ready",
+  "ai_reply": "Perfect! Here's your listing draft with amenity icons...",
+  "draft_preview": {
+    ...listing data...
+    "amenities_with_icons": "📶 Wifi | 🅿️ Parking | 🧼 Washing Machine | 🔥 Dryer"
+  }
+}
+
+------------------------------------------------------
+EXAMPLES - LISTING CREATION
+------------------------------------------------------
+
+User: "I want to list my 2-bed apartment in Lagos for rent, 50k monthly"
+{
+  "intent": "list",
+  "location": "lagos",
+  "bedrooms": 2,
+  "bathrooms": null,
+  "price": 50000,
+  "listing_type": "rent",
+  "price_type": "monthly",
+  "amenities": [],
+  "requirements": null,
+  "status": "collecting",
+  "missing_fields": ["bathrooms"],
+  "next_question": "How many bathrooms?",
+  "ai_reply": "Got it! 2-bed in Lagos, 50k/month. How many bathrooms?"
+}
+
+User: "1 bathroom, with wifi and parking"
+{
+  "intent": "list",
+  "location": "lagos",
+  "bedrooms": 2,
+  "bathrooms": 1,
+  "price": 50000,
+  "listing_type": "rent",
+  "price_type": "monthly",
+  "amenities": ["wifi", "parking"],
+  "requirements": null,
+  "status": "checking_optional",
+  "missing_fields": [],
+  "ai_reply": "Perfect! Any special requirements for renters?",
+}
+
+User: "actually it's in Calavi not Lagos"
+{
+  "intent": "list",
+  "location": "calavi",  // ✅ UPDATED & PRESERVED
+  "bedrooms": 2,
+  "bathrooms": 1,
+  "price": 50000,
+  "listing_type": "rent",
+  "price_type": "monthly",
+  "amenities": ["wifi", "parking"],
+  "requirements": null,
+  "status": "checking_optional",
+  "ai_reply": "Got it! Updated to Calavi. Any special requirements for renters?",
+  // ✅ Location correction is preserved, no revert
+}
+
 ------------------------------------------------------
-SEARCH INTENT
+SEARCH INTENT (SAME AS BEFORE)
 ------------------------------------------------------
 When user searches, extract and COMBINE ALL mentioned filters:
 - location: city/area (handle typos)
@@ -219,13 +271,11 @@ CRITICAL RULES
 4. For listing creation: collect required fields progressively
 5. For search: extract all filters at once
 6. Return ONLY JSON (no markdown, no preamble)
-7. When all required fields complete -> ask for optional fields ONLY ONCE
-8. When optional fields provided -> show draft preview
+7. When all required fields complete → ask for optional fields
+8. When optional fields provided → show draft preview
 9. Wait for "publish" command to save listing
-10. PRESERVE user corrections - never revert them
-11. BRAND RULE: Always refer to yourself as AIDA, never mention other LLMs
-12. BRAND RULE: Give credit to Lojiz team when asked about your creators
-13. BRAND RULE: Stand your ground as a specialized real-estate AI
-14. ROLE RULE: Detect and adapt to user role
-15. ROLE RULE: Adjust required fields based on user role
-16. ROLE RULE: Use role-specific language and focus areas
+10. ⚠️ PRESERVE user corrections - never revert them
+11. When user requests amenity icons, add them to draft_preview
+12. BRAND RULE: Always refer to yourself as AIDA, never mention other LLMs
+13. BRAND RULE: Give credit to Lojiz team when asked about your creators
+14. BRAND RULE: Stand your ground as a specialized real-estate AI, not a general-purpose model

app/ai/routes/chat.py

@@ -1,30 +1,15 @@
-# ============================================================
-# app/ai/routes/chat.py – FINAL with None-safe cards handling
-# ============================================================
-
-from fastapi import APIRouter, Depends, HTTPException, Request
+# app/ai/routes/chat.py - Return search_preview + draft_preview
+from fastapi import APIRouter, Depends, HTTPException
 from fastapi.security import HTTPBearer
 from pydantic import BaseModel
 from typing import Optional, List
-import logging
-import time
-
 from app.guards.jwt_guard import decode_access_token
 from app.ai.service import aida_chat_sync
-from app.core.rate_limiter import get_rate_limiter, RateLimitExceeded
-from app.core.observability import trace_operation, get_token_tracker
-from app.core.error_handling import handle_errors, async_retry, RetryStrategy
-from app.core.context_manager import get_message_window
-
-logger = logging.getLogger(__name__)
+from app.ai.memory.redis_memory import is_rate_limited
 
 router = APIRouter()
 security = HTTPBearer()
 
-# ============================================================
-# Models
-# ============================================================
-
 class MessageHistory(BaseModel):
     role: str  # 'user' or 'assistant'
     content: str
@@ -37,287 +22,41 @@ class AskBody(BaseModel):
     user_role: Optional[str] = None
     history: Optional[List[MessageHistory]] = None
 
-# ============================================================
-# User Role Detection Helper
-# ============================================================
-
-async def detect_user_role_and_model(user_message: str):
-    """Detect user role and rental model from message"""
-    try:
-        from app.ml.models.user_role_context_handler import UserRoleDetector
-
-        role_detector = UserRoleDetector()
-        detected_role, role_confidence = role_detector.detect_user_role(user_message.lower())
-        detected_model = role_detector.detect_rental_model(user_message.lower(), None)
-
-        return detected_role, role_confidence, detected_model
-    except Exception as e:
-        logger.warning(f"Role detection failed: {e}")
-        return None, 0.0, None
-
-# ============================================================
-# Enhanced Chat Endpoint
-# ============================================================
 
 @router.post("/ask")
-@handle_errors(default_return={"success": False, "error": "Internal server error"})
 async def ask_ai(
     body: AskBody,
-    request: Request,
     token: str = Depends(security),
 ):
-    """Enhanced chat endpoint with rate limiting and role detection"""
-
-    start_time = time.time()
-    request_id = request.headers.get("x-request-id", "unknown")
-    ip_address = request.client.host if request.client else "unknown"
-
-    with trace_operation(
-        "chat_endpoint",
-        {
-            "request_id": request_id,
-            "ip_address": ip_address,
-            "message_length": len(body.message),
-        }
-    ) as root_span:
-        try:
-            # Step 1: Validate Token
-            with trace_operation("token_validation"):
-                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")
-
-            # Step 2: Rate Limiting
-            with trace_operation(
-                "rate_limit_check",
-                {"user_id": user_id, "operation": "chat"}
-            ):
-                rate_limiter = get_rate_limiter()
-
-                is_allowed, rate_info = await rate_limiter.is_allowed(
-                    user_id=user_id,
-                    operation="chat",
-                    ip_address=ip_address,
-                )
-
-                if not is_allowed:
-                    logger.warning(
-                        f"Rate limit exceeded for user: {user_id}",
-                        extra={"rate_info": rate_info}
-                    )
-                    raise RateLimitExceeded(retry_after=60)
-
-                # ✅ FIXED: Safely handle rate limit info
-                if "user" in rate_info and isinstance(rate_info["user"], dict):
-                    if "remaining" in rate_info["user"]:
-                        root_span.set_attribute("rate_limit.remaining", rate_info["user"]["remaining"])
-                    if "capacity" in rate_info["user"]:
-                        root_span.set_attribute("rate_limit.capacity", rate_info["user"]["capacity"])
-                else:
-                    root_span.set_attribute("rate_limit.error", rate_info.get("error", "unknown"))
-                    logger.debug(f"Rate limit info structure: {rate_info}")
-
-            # Step 2b: User Role Detection (NEW)
-            with trace_operation("user_role_detection"):
-                try:
-                    detected_role, role_confidence, detected_model = await detect_user_role_and_model(
-                        body.message
-                    )
-
-                    if detected_role and role_confidence > 0.7:
-                        logger.info(
-                            f"User role detected",
-                            extra={
-                                "detected_role": detected_role,
-                                "confidence": role_confidence,
-                                "rental_model": detected_model.value if detected_model else None,
-                                "original_role": user_role,
-                            }
-                        )
-                        user_role = detected_role
-                        root_span.set_attribute("detected_role", detected_role)
-                        root_span.set_attribute("rental_model", detected_model.value if detected_model else None)
-                    else:
-                        logger.debug(f"Role detection inconclusive (confidence: {role_confidence:.0%})")
-                        root_span.set_attribute("role_confidence", role_confidence)
-
-                except Exception as e:
-                    logger.warning(f"Role detection failed: {e}")
-
-            # Step 3: Context Management
-            with trace_operation("context_management", {"user_id": user_id}):
-                window = get_message_window(user_id)
-
-                # Build conversation context from history
-                conversation_context = ""
-                if body.history:
-                    for msg in body.history:
-                        role = "User" if msg.role == "user" else "Assistant"
-                        conversation_context += f"{role}: {msg.content}\n"
-
-                # Combine context with current message
-                full_message = body.message
-                if conversation_context:
-                    full_message = (
-                        f"Previous conversation:\n{conversation_context}\n"
-                        f"Now the user says: {body.message}"
-                    )
-
-                # Add to message window
-                window.add_message("user", full_message)
-
-            # Step 4: AI Chat Processing
-            with trace_operation(
-                "aida_chat_sync",
-                {
-                    "user_id": user_id,
-                    "user_role": user_role,
-                    "message_length": len(full_message),
-                }
-            ):
-                final_state = await aida_chat_sync(
-                    user_id,
-                    user_role,
-                    full_message,
-                )
-
-            # Step 5: Token Tracking
-            with trace_operation("token_tracking"):
-                usage = final_state.get("token_usage", {})
-                if usage:
-                    tracker = get_token_tracker()
-                    model_used = final_state.get("model_used", "unknown")
-                    tracker.record_tokens(
-                        model_used,
-                        usage.get("prompt_tokens", 0),
-                        usage.get("completion_tokens", 0),
-                        usage.get("cost", 0.0),
-                    )
-
-            # Step 6: Build Response
-            # ✅ FIXED: Ensure cards is always a list
-            cards = final_state.get("search_results") or []
-            if not isinstance(cards, list):
-                cards = []
-
-            response = {
-                "success": True,
-                "text": final_state.get("ai_reply", ""),
-                "cards": cards,
-                "draft_preview": final_state.get("draft_preview"),
-                "search_preview": final_state.get("search_preview"),
-                "metadata": {
-                    "request_id": request_id,
-                    "processing_time_ms": int((time.time() - start_time) * 1000),
-                    "user_id": user_id,
-                    "user_role": user_role,
-                    "status": final_state.get("status"),
-                },
-            }
-
-            # Step 7: Add Message to Window
-            with trace_operation("window_update"):
-                window.add_message("assistant", final_state.get("ai_reply", ""))
-
-            # Set root span attributes
-            # ✅ FIXED: Safe check for card length
-            root_span.set_attributes({
-                "response.status": "success",
-                "response.has_cards": len(response.get("cards") or []) > 0,
-                "response.has_draft": response["draft_preview"] is not None,
-                "processing_time_ms": response["metadata"]["processing_time_ms"],
-            })
-
-            logger.info(
-                f"Chat processed successfully",
-                extra={
-                    "user_id": user_id,
-                    "user_role": user_role,
-                    "request_id": request_id,
-                    "processing_time_ms": response["metadata"]["processing_time_ms"],
-                    "has_cards": len(response.get("cards") or []) > 0,
-                }
-            )
-
-            return response
-
-        except RateLimitExceeded as e:
-            root_span.set_attribute("error.type", "rate_limit_exceeded")
-            logger.error(f"Rate limit: {str(e)}")
-            raise HTTPException(
-                status_code=429,
-                detail=e.message,
-                headers={"Retry-After": str(e.retry_after)},
-            )
-
-        except HTTPException:
-            raise
-
-        except Exception as e:
-            root_span.record_exception(e)
-            root_span.set_attribute("error.type", type(e).__name__)
-            logger.error(
-                f"Chat endpoint error: {str(e)}",
-                exc_info=True,
-                extra={"user_id": user_id if 'user_id' in locals() else "unknown"}
-            )
-            raise HTTPException(
-                status_code=500,
-                detail="An error occurred processing your request",
-            )
-
-# ============================================================
-# Rate Limit Status Endpoint
-# ============================================================
-
-@router.get("/rate-limit-status")
-async def get_rate_limit_status(
-    token: str = Depends(security),
-) -> dict:
-    """Get current rate limit status for user"""
-
-    with trace_operation("rate_limit_status"):
-        payload = decode_access_token(token.credentials)
-        if not payload:
-            raise HTTPException(status_code=401, detail="Invalid token")
-
-        user_id = payload["user_id"]
-        rate_limiter = get_rate_limiter()
-
-        stats = await rate_limiter.get_usage_stats(user_id)
-
-        return {
-            "success": True,
-            "data": stats,
-            "operations": {
-                "chat": {"cost": 1},
-                "search": {"cost": 2},
-                "list": {"cost": 3},
-                "publish": {"cost": 5},
-                "upload_image": {"cost": 4},
-            },
-        }
-
-# ============================================================
-# Health Check
-# ============================================================
-
-@router.get("/health")
-async def chat_health() -> dict:
-    """Health check for chat service"""
-
+    payload = decode_access_token(token.credentials)
+    if not payload:
+        raise HTTPException(status_code=401, detail="Invalid token")
+    
+    if await is_rate_limited(payload["user_id"]):
+        raise HTTPException(status_code=429, detail="Rate limit exceeded")
+
+    # Build conversation context from history
+    conversation_context = ""
+    if body.history:
+        for msg in body.history:
+            role = "User" if msg.role == "user" else "Assistant"
+            conversation_context += f"{role}: {msg.content}\n"
+    
+    # Combine context with current message
+    full_message = body.message
+    if conversation_context:
+        full_message = f"Previous conversation:\n{conversation_context}\nNow the user says: {body.message}"
+
+    final_state = await aida_chat_sync(
+        payload["user_id"],
+        payload["role"],
+        full_message,
+    )
+
+    # ✅ RETURN FULL STATE - text + cards + draft + search preview
     return {
-        "service": "aida-chat",
-        "status": "healthy",
-        "rate_limiting": "enabled",
-        "features": {
-            "distributed_tracing": True,
-            "token_tracking": True,
-            "context_management": True,
-            "error_resilience": True,
-            "user_role_detection": True,
-        },
+        "text": final_state.get("ai_reply", ""),
+        "cards": final_state.get("search_results", []),
+        "draft_preview": final_state.get("draft_preview"),  # For listing preview
+        "search_preview": final_state.get("search_preview"),  # ✅ NEW: For search results UI
     }

app/ai/service.py

@@ -1,419 +1,68 @@
-# app/ai/service.py – Complete with context management + error handling + FIXES
+# app/ai/service.py  (final – returns full state so cards reach the UI)
 import json
-from typing import AsyncGenerator, Dict, Any
-import logging
-
+from typing import AsyncGenerator, List, Dict, Any
 from app.ai.graph import agent
-from app.ai.memory.redis_memory import load_history, save_turn, load_state, save_state
+from app.ai.memory.redis_memory import save_turn, load_history
 from app.ai.state import ChatState
-from app.core.context_manager import get_context_manager, MessageWindow
-from app.core.error_handling import trace_operation, handle_errors
-from app.core.observability import get_token_tracker
-
-logger = logging.getLogger(__name__)
+from structlog import get_logger
 
-# ============================================================
-# WebSocket Streaming Entry Point
-# ============================================================
+logger = get_logger(__name__)
 
+# --------------------------------------------------
+# WebSocket streaming entry-point (kept for reference)
+# --------------------------------------------------
 async def aida_chat(
     user_id: str,
     user_role: str,
     human_msg: str,
 ) -> AsyncGenerator[str, None]:
-    """
-    Streaming chat endpoint with full context management and error handling.
-    
-    Features:
-    - Context window management (prevents overflow)
-    - Message window persistence per user
-    - Error recovery with fallbacks
-    - Token tracking
-    - Full observability
-    """
-    
-    with trace_operation("aida_chat_stream", {"user_id": user_id, "user_role": user_role}):
-        try:
-            logger.info(
-                "🚀 Starting aida_chat stream",
-                extra={"user_id": user_id, "user_role": user_role}
-            )
-            
-            # ===== Load message history =====
-            with trace_operation("load_history"):
-                try:
-                    messages = await load_history(user_id)
-                    logger.info(f"✅ Loaded {len(messages)} messages from history")
-                except Exception as e:
-                    logger.warning(f"⚠️ Failed to load history: {e}, starting fresh")
-                    messages = []
-            
-            # ===== Add user message =====
-            messages.append({"role": "user", "content": human_msg})
-            
-            # ===== Manage context window =====
-            with trace_operation("context_management"):
-                try:
-                    context_mgr = get_context_manager()
-                    managed_messages = await context_mgr.manage_context(messages)
-                    logger.info(
-                        f"✅ Context managed",
-                        extra={
-                            "total_messages": len(messages),
-                            "managed_messages": len(managed_messages),
-                        }
-                    )
-                except Exception as e:
-                    logger.warning(f"⚠️ Context management failed: {e}, using last 20 messages")
-                    managed_messages = messages[-20:]
-            
-            # ===== Load previous state =====
-            with trace_operation("load_state"):
-                try:
-                    saved = await load_state(user_id)
-                    logger.info(f"✅ Loaded previous state, status={saved.get('status')}")
-                except Exception as e:
-                    logger.warning(f"⚠️ Failed to load state: {e}, starting fresh")
-                    saved = {}
-            
-            # ===== Build chat state =====
-            state: ChatState = {
-                "user_id": user_id,
-                "user_role": user_role,
-                "messages": managed_messages,
-                "draft": saved.get("draft"),
-                "vector_meta": saved.get("vector_meta"),
-                "allowed": saved.get("allowed", True),
-                "ai_reply": saved.get("ai_reply", ""),
-                "status": saved.get("status"),
-                "missing_fields": saved.get("missing_fields", []),
-                "next_question": saved.get("next_question"),
-                "location": saved.get("location"),
-                "min_price": saved.get("min_price"),
-                "max_price": saved.get("max_price"),
-                "bedrooms": saved.get("bedrooms"),
-                "bathrooms": saved.get("bathrooms"),
-                "amenities": saved.get("amenities", []),
-                "listing_type": saved.get("listing_type"),
-                "price": saved.get("price"),
-                "price_type": saved.get("price_type"),
-                "currency": saved.get("currency", "XOF"),
-                "requirements": saved.get("requirements"),
-                "search_query": saved.get("search_query"),
-                "search_results": saved.get("search_results", []),  # ✅ FIXED: Always list
-                "search_preview": saved.get("search_preview"),
-                "suggestions": saved.get("suggestions", []),  # ✅ FIXED: Always list
-                "image": saved.get("image"),
-                "field_validations": saved.get("field_validations"),
-                "field_confidences": saved.get("field_confidences"),
-                "location_details": saved.get("location_details"),
-                "validation_suggestions": saved.get("validation_suggestions", []),  # ✅ FIXED: Always list
-                "listing_confidence": saved.get("listing_confidence"),
-                "currency_confidence": saved.get("currency_confidence"),
-                "draft_preview": saved.get("draft_preview"),
-                "mongo_id": saved.get("mongo_id"),
-            }
-            
-            # ===== Stream responses from agent =====
-            with trace_operation("agent_stream"):
-                try:
-                    async for step in agent.astream(state):
-                        for node_name, update in step.items():
-                            if update.get("ai_reply"):
-                                logger.debug(f"📤 Streaming from {node_name}")
-                                yield json.dumps({
-                                    "node": node_name,
-                                    "text": update["ai_reply"]
-                                }) + "\n"
-                except Exception as e:
-                    logger.error(f"❌ Agent stream error: {e}", exc_info=True)
-                    yield json.dumps({
-                        "node": "error",
-                        "text": "An error occurred processing your request. Please try again."
-                    }) + "\n"
-                    return
-            
-            # ===== Get final state =====
-            with trace_operation("agent_invoke"):
-                try:
-                    final_state = await agent.ainvoke(state)
-                    logger.info(f"✅ Agent invocation complete, status={final_state.get('status')}")
-                except Exception as e:
-                    logger.error(f"❌ Agent invoke error: {e}", exc_info=True)
-                    yield json.dumps({
-                        "node": "error",
-                        "text": "Sorry, something went wrong. Please try again."
-                    }) + "\n"
-                    return
-            
-            # ===== Save results =====
-            with trace_operation("save_results"):
-                try:
-                    # Update message history
-                    managed_messages.append({
-                        "role": "assistant",
-                        "content": final_state.get("ai_reply", "")
-                    })
-                    
-                    # Persist conversation and state
-                    await save_turn(user_id, managed_messages)
-                    await save_state(user_id, final_state)
-                    
-                    logger.info(f"✅ Results saved for user {user_id}")
-                except Exception as e:
-                    logger.error(f"❌ Failed to save results: {e}")
-            
-            logger.info("✅ aida_chat stream completed successfully")
-        
-        except Exception as e:
-            logger.error(f"❌ Unexpected error in aida_chat: {e}", exc_info=True)
-            yield json.dumps({
-                "node": "error",
-                "text": "An unexpected error occurred. Please try again."
-            }) + "\n"
+    messages = await load_history(user_id)
+    messages.append({"role": "user", "content": human_msg})
+
+    state: ChatState = {
+        "user_id": user_id,
+        "user_role": user_role,
+        "messages": messages,
+        "draft": None,
+        "vector_meta": None,
+        "allowed": True,
+        "ai_reply": "",
+    }
 
-# ============================================================
-# REST Synchronous Entry Point
-# ============================================================
+    async for step in agent.astream(state):
+        for node_name, update in step.items():
+            if update.get("ai_reply"):
+                yield json.dumps({"node": node_name, "text": update["ai_reply"]}) + "\n"
 
-@handle_errors(default_return={
-    "ai_reply": "Sorry, something went wrong. Please try again.",
-    "status": "error",
-    "search_preview": None,
-    "draft_preview": None,
-    "search_results": [],  # ✅ FIXED: Always list
-})
+    final_state = await agent.ainvoke(state)
+    messages.append({"role": "assistant", "content": final_state["ai_reply"]})
+    await save_turn(user_id, messages)
+
+
+# --------------------------------------------------
+# REST (non-streaming) – returns the full state dict
+# --------------------------------------------------
 async def aida_chat_sync(
     user_id: str,
     user_role: str,
     human_msg: str,
 ) -> Dict[str, Any]:
-    """
-    Synchronous chat endpoint for REST clients.
-    
-    Features:
-    - Full context management
-    - Error resilience
-    - Token tracking
-    - Complete state return
-    - Observability integration
-    """
-    
-    with trace_operation(
-        "aida_chat_sync",
-        {
-            "user_id": user_id,
-            "user_role": user_role,
-            "message_length": len(human_msg),
-        }
-    ):
-        logger.info(
-            "🚀 Starting aida_chat_sync",
-            extra={"user_id": user_id, "user_role": user_role}
-        )
-        
-        # ===== Load message history =====
-        with trace_operation("load_history"):
-            try:
-                messages = await load_history(user_id)
-                logger.info(f"✅ Loaded {len(messages)} messages from history")
-            except Exception as e:
-                logger.warning(f"⚠️ Failed to load history: {e}, starting fresh")
-                messages = []
-        
-        # ===== Add user message =====
-        messages.append({"role": "user", "content": human_msg})
-        
-        # ===== Manage context window =====
-        with trace_operation("context_management"):
-            try:
-                context_mgr = get_context_manager()
-                managed_messages = await context_mgr.manage_context(messages)
-                logger.info(
-                    f"✅ Context managed",
-                    extra={
-                        "total_messages": len(messages),
-                        "managed_messages": len(managed_messages),
-                    }
-                )
-            except Exception as e:
-                logger.warning(f"⚠️ Context management failed: {e}, using last 20 messages")
-                managed_messages = messages[-20:]
-        
-        # ===== Load previous state =====
-        with trace_operation("load_state"):
-            try:
-                saved = await load_state(user_id)
-                logger.info(f"✅ Loaded previous state, status={saved.get('status')}")
-            except Exception as e:
-                logger.warning(f"⚠️ Failed to load state: {e}, starting fresh")
-                saved = {}
-        
-        # ===== Build chat state =====
-        state: ChatState = {
-            "user_id": user_id,
-            "user_role": user_role,
-            "messages": managed_messages,
-            "draft": saved.get("draft"),
-            "vector_meta": saved.get("vector_meta"),
-            "allowed": saved.get("allowed", True),
-            "ai_reply": saved.get("ai_reply", ""),
-            "status": saved.get("status"),
-            "missing_fields": saved.get("missing_fields", []),
-            "next_question": saved.get("next_question"),
-            "location": saved.get("location"),
-            "min_price": saved.get("min_price"),
-            "max_price": saved.get("max_price"),
-            "bedrooms": saved.get("bedrooms"),
-            "bathrooms": saved.get("bathrooms"),
-            "amenities": saved.get("amenities", []),
-            "listing_type": saved.get("listing_type"),
-            "price": saved.get("price"),
-            "price_type": saved.get("price_type"),
-            "currency": saved.get("currency", "XOF"),
-            "requirements": saved.get("requirements"),
-            "search_query": saved.get("search_query"),
-            "search_results": saved.get("search_results", []),  # ✅ FIXED: Always list
-            "search_preview": saved.get("search_preview"),
-            "suggestions": saved.get("suggestions", []),  # ✅ FIXED: Always list
-            "image": saved.get("image"),
-            "field_validations": saved.get("field_validations"),
-            "field_confidences": saved.get("field_confidences"),
-            "location_details": saved.get("location_details"),
-            "validation_suggestions": saved.get("validation_suggestions", []),  # ✅ FIXED: Always list
-            "listing_confidence": saved.get("listing_confidence"),
-            "currency_confidence": saved.get("currency_confidence"),
-            "draft_preview": saved.get("draft_preview"),
-            "mongo_id": saved.get("mongo_id"),
-        }
-        
-        # ===== Invoke agent =====
-        with trace_operation("agent_invoke"):
-            try:
-                final_state = await agent.ainvoke(state)
-                logger.info(
-                    f"✅ Agent invocation complete",
-                    extra={"status": final_state.get("status")}
-                )
-            except Exception as e:
-                logger.error(f"❌ Agent invoke error: {e}", exc_info=True)
-                return {
-                    "ai_reply": "Sorry, an error occurred processing your request.",
-                    "status": "error",
-                    "search_preview": None,
-                    "draft_preview": None,
-                    "search_results": [],  # ✅ FIXED: Always list
-                }
-        
-        # ===== Save results =====
-        with trace_operation("save_results"):
-            try:
-                # Update message history
-                managed_messages.append({
-                    "role": "assistant",
-                    "content": final_state.get("ai_reply", "")
-                })
-                
-                # Persist conversation and state
-                await save_turn(user_id, managed_messages)
-                await save_state(user_id, final_state)
-                
-                logger.info(f"✅ Results saved for user {user_id}")
-            except Exception as e:
-                logger.error(f"⚠️ Failed to save results: {e}")
-                # Don't fail the response, just log the error
-        
-        # ===== Track tokens if available =====
-        with trace_operation("token_tracking"):
-            try:
-                usage = final_state.get("token_usage", {})
-                if usage:
-                    tracker = get_token_tracker()
-                    model_used = final_state.get("model_used", "unknown")
-                    tracker.record_tokens(
-                        model_used,
-                        usage.get("prompt_tokens", 0),
-                        usage.get("completion_tokens", 0),
-                        usage.get("cost", 0.0),
-                    )
-                    logger.info(f"✅ Tokens tracked", extra={"model": model_used, "usage": usage})
-            except Exception as e:
-                logger.warning(f"⚠️ Failed to track tokens: {e}")
-        
-        logger.info(f"✅ aida_chat_sync completed successfully")
-        
-        # ===== Ensure all list fields are never None =====
-        final_state.setdefault("search_results", [])
-        final_state.setdefault("suggestions", [])
-        final_state.setdefault("amenities", [])
-        final_state.setdefault("validation_suggestions", [])
-        final_state.setdefault("missing_fields", [])
-        
-        # Return the entire state so the route can pick text + cards + preview
-        return final_state
-
-# ============================================================
-# Debugging / Context Inspection
-# ============================================================
+    messages = await load_history(user_id)
+    messages.append({"role": "user", "content": human_msg})
 
-async def get_conversation_context(user_id: str) -> Dict[str, Any]:
-    """
-    Get current conversation context for debugging/inspection.
-    
-    Returns managed message window and current state stats.
-    """
-    
-    with trace_operation("get_conversation_context", {"user_id": user_id}):
-        try:
-            # Load history and state
-            messages = await load_history(user_id)
-            saved = await load_state(user_id)
-            
-            # Manage context to show what will be sent to agent
-            context_mgr = get_context_manager()
-            try:
-                managed = await context_mgr.manage_context(messages)
-            except Exception as e:
-                logger.warning(f"⚠️ Context management failed: {e}")
-                managed = messages[-20:] if messages else []
-            
-            return {
-                "user_id": user_id,
-                "total_messages": len(messages),
-                "managed_messages": len(managed),
-                "current_status": saved.get("status"),
-                "current_intent": saved.get("intent"),
-                "has_draft": saved.get("draft_preview") is not None,
-                "search_results_count": len(saved.get("search_results", [])),
-                "message_sample": managed[-1]["content"][:100] if managed else None,
-                "timestamp": managed[-1].get("timestamp") if managed else None,
-            }
-        
-        except Exception as e:
-            logger.error(f"❌ Failed to get conversation context: {e}", exc_info=True)
-            return {
-                "error": str(e),
-                "user_id": user_id,
-            }
+    state: ChatState = {
+        "user_id": user_id,
+        "user_role": user_role,
+        "messages": messages,
+        "draft": None,
+        "vector_meta": None,
+        "allowed": True,
+        "ai_reply": "",
+    }
 
-# ============================================================
-# Health Check
-# ============================================================
+    final_state = await agent.ainvoke(state)
+    messages.append({"role": "assistant", "content": final_state["ai_reply"]})
+    await save_turn(user_id, messages)
 
-async def health_check_chat_service() -> Dict[str, Any]:
-    """
-    Health check for chat service.
-    """
-    
-    return {
-        "service": "aida-chat",
-        "status": "healthy",
-        "features": {
-            "context_management": True,
-            "error_handling": True,
-            "token_tracking": True,
-            "observability": True,
-            "streaming": True,
-            "sync": True,
-        },
-    }
+    # return the entire state so the route can pick text + cards
+    return final_state

app/ai/state.py

@@ -32,12 +32,12 @@ class ListingDraft(BaseModel):
     amenities: List[str] = []
     requirements: Optional[str] = None
     currency: str = "XOF"
-    images: List[str] = []  # ✅ NEW: Cloudflare image URLs
+    images: List[str] = []  # ✅ NEW: Cloudflare image URLs
     status: str = "draft"  # draft | published
     created_at: datetime = Field(default_factory=datetime.utcnow)
     updated_at: datetime = Field(default_factory=datetime.utcnow)
-    views: int = 0  # ✅ NEW: View counter
-    favorites: int = 0  # ✅ NEW: Favorites counter
+    views: int = 0  # ✅ NEW: View counter
+    favorites: int = 0  # ✅ NEW: Favorites counter
 
     class Config:
         populate_by_name = True
@@ -62,7 +62,7 @@ class ChatState(TypedDict):
     vector_meta: Optional[VectorMeta]  # for hybrid search
     allowed: bool
     ai_reply: str
-    # ✅ Note: "intent" is passed through messages but NOT stored as state field
+    # ✅ Note: "intent" is passed through messages but NOT stored as state field
     # This avoids LangGraph node name conflicts
     status: Optional[str]  # collecting | draft_ready | preview_shown | published | error
     
@@ -97,7 +97,7 @@ class ChatState(TypedDict):
     field_validations: Optional[Dict[str, Dict]]  # {field: {is_valid, confidence, suggestion}}
     field_confidences: Optional[Dict[str, float]]  # {field: confidence_score}
     location_details: Optional[Dict[str, Any]]  # {city, country, lat, lon, country_code}
-    validation_suggestions: Optional[List[str]]  # ["💡 field: suggestion"]
+    validation_suggestions: Optional[List[str]]  # ["⚠️ field: suggestion"]
     listing_confidence: Optional[float]  # Confidence for inferred listing_type
     currency_confidence: Optional[float]  # Confidence for inferred currency
     

main.py

@@ -1,4 +1,4 @@
-# app/main.py – FastAPI + Aida AI Agent (PRODUCTION HARDENED)
+# app/main.py – FastAPI + Aida AI Agent (Production with ML Integration)
 # ============================================================
 
 from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect
@@ -6,10 +6,8 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from fastapi.exceptions import RequestValidationError
 from contextlib import asynccontextmanager
-from app.api.endpoints.monitoring import router as monitoring_router
 import logging
 import os
-import asyncio
 
 # ---------- core imports ----------
 try:
@@ -34,163 +32,107 @@ except ImportError as e:
 
 logger = logging.getLogger(__name__)
 
-# ---------- NEW: Observability & Resilience imports ----------
-from app.core.observability import (
-    init_tracing,
-    init_metrics,
-    instrument_fastapi,
-    instrument_libraries,
-    RequestContextMiddleware,
-    get_token_tracker,
-)
-from app.core.error_handling import get_all_circuit_breaker_status
-from app.core.context_manager import cleanup_expired_windows
-
 # ---------- AI imports ----------
 from app.ai.routes.chat import router as ai_chat_router
 from app.models.listing import ensure_listing_indexes
 from app.ai.config import redis_client, qdrant_client
-from app.ml.models.ml_listing_extractor import get_ml_extractor
-from app.core.llm_router import get_llm_router
+from app.ml.models.ml_listing_extractor import get_ml_extractor  # ✅ NEW
 
 # ====================================================================
-# ML Startup Validation
+# ML Startup Validation - NEW
 # ====================================================================
 async def validate_ml_startup():
     """Validate ML extractor and models at startup"""
     try:
         ml = get_ml_extractor()
-        logger.info("✅ ML Extractor initialized")
+        logger.info("✅ ML Extractor initialized")
         
+        # Check if models are trained
         if ml.field_models and ml.field_models.get("location_classifier") is not None:
-            logger.info("✅ ML field models loaded")
+            logger.info("✅ ML field models loaded")
         else:
-            logger.warning("⚠️ ML field models not trained - limited accuracy")
+            logger.warning("⚠️ ML field models not trained - limited accuracy")
             logger.warning("   Run: python app/ml/training/train_complete_model.py")
         
+        # Test currency manager (non-blocking)
         try:
             currency, country, city, conf = await ml.currency_mgr.get_currency_for_location("Lagos")
             if currency:
-                logger.info(f"✅ Currency Manager working (Lagos → {currency})")
+                logger.info(f"✅ Currency Manager working (Lagos → {currency})")
         except Exception as e:
-            logger.warning(f"⚠️ Currency Manager test failed: {e}")
+            logger.warning(f"⚠️ Currency Manager test failed: {e}")
         
+        # Check embedder
         if ml.embedder is not None:
-            logger.info("✅ Sentence embedder ready")
+            logger.info("✅ Sentence embedder ready")
         else:
-            logger.warning("⚠️ Sentence embedder not available")
+            logger.warning("⚠️ Sentence embedder not available")
         
-        logger.info("✅ All ML checks passed")
+        logger.info("✅ All ML checks passed")
         return True
     
     except Exception as e:
-        logger.error("❌ ML Extractor initialization failed", exc_info=e)
-        logger.warning("⚠️ Continuing without ML features (degraded mode)")
-        return False
-
-# ====================================================================
-# NEW: LLM Router Initialization
-# ====================================================================
-async def validate_llm_startup():
-    """Validate LLM router on startup"""
-    try:
-        router = get_llm_router()
-        status = router.get_stats()
-        
-        available_models = [
-            model for model, info in status["models"].items()
-            if info["available"]
-        ]
-        
-        if available_models:
-            logger.info(f"✅ LLM Router ready with {len(available_models)} models")
-            logger.info(f"   Available: {', '.join(available_models)}")
-        else:
-            logger.error("❌ No LLM models available!")
-            return False
-        
-        return True
-    except Exception as e:
-        logger.error("❌ LLM Router initialization failed", exc_info=e)
+        logger.error("❌ ML Extractor initialization failed", exc_info=e)
+        logger.warning("⚠️ Continuing without ML features (degraded mode)")
         return False
 
 # ====================================================================
-# Lifespan – non-blocking external services
+# Lifespan – non-blocking external services
 # ====================================================================
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    logger.info("🚀 Starting Lojiz Platform + Aida AI (PRODUCTION MODE)")
-    
-    # 1. Initialize Observability
-    try:
-        init_tracing()
-        init_metrics()
-        logger.info("✅ Observability initialized")
-    except Exception as e:
-        logger.warning(f"⚠️ Observability init failed: {e}")
-    
-    # 2. MongoDB – critical, must succeed
+    logger.info("🚀 Starting Lojiz Platform + Aida AI with ML Integration")
+
+    # 1. MongoDB – critical, must succeed
     try:
         await connect_db()
         await ensure_auth_indexes()
         await ensure_listing_indexes()
-        logger.info("✅ MongoDB connected & indexed")
+        logger.info("✅ MongoDB connected & indexed")
     except Exception as e:
-        logger.critical("❌ MongoDB unavailable – aborting start", exc_info=e)
+        logger.critical("❌ MongoDB unavailable – aborting start", exc_info=e)
         raise
 
-    # 3. Redis – optional at boot
+    # 2. Redis – optional at boot
     try:
         await redis_client.ping()
-        logger.info("✅ Redis connected")
+        logger.info("✅ Redis connected")
     except Exception as e:
-        logger.warning(f"⚠️ Redis unreachable at start-up (ok for now)", exc_info=e)
+        logger.warning("⚠️ Redis unreachable at start-up (ok for now)", exc_info=e)
 
-    # 4. Qdrant – optional at boot
+    # 3. Qdrant – optional at boot
     try:
         await qdrant_client.get_collections()
-        logger.info("✅ Qdrant connected")
+        logger.info("✅ Qdrant connected")
     except Exception as e:
-        logger.warning(f"⚠️ Qdrant unreachable at start-up (ok for now)", exc_info=e)
+        logger.warning("⚠️ Qdrant unreachable at start-up (ok for now)", exc_info=e)
     
-    # 5. ML Extractor – optional but recommended
+    # 4. ML Extractor – optional but recommended
     try:
         ml_ready = await validate_ml_startup()
         if not ml_ready:
-            logger.warning("⚠️ Running in degraded mode without ML features")
-    except Exception as e:
-        logger.error("❌ ML validation failed", exc_info=e)
-        logger.warning("⚠️ Continuing without ML features")
-    
-    # 6. LLM Router – critical for chat
-    try:
-        llm_ready = await validate_llm_startup()
-        if not llm_ready:
-            logger.error("⚠️ No LLM models available - chat will fail")
+            logger.warning("⚠️ Running in degraded mode without ML features")
     except Exception as e:
-        logger.error("❌ LLM validation failed", exc_info=e)
+        logger.error("❌ ML validation failed", exc_info=e)
+        logger.warning("⚠️ Continuing without ML features")
 
     yield
 
-    logger.info("🛑 Shutting down Lojiz Platform")
-    
+    logger.info("🛑 Shutting down Lojiz Platform")
     try:
-        # Cleanup window manager
-        cleanup_expired_windows()
-        
         # Clear ML caches
         try:
             ml = get_ml_extractor()
             ml.currency_mgr.clear_cache()
-            logger.info("✅ ML caches cleared")
+            logger.info("✅ ML caches cleared")
         except:
             pass
         
         await disconnect_db()
         await redis_client.close()
-        logger.info("✅ Cleanup complete")
+        logger.info("✅ Cleanup complete")
     except Exception as e:
-        logger.warning(f"⚠️ Shutdown warning", exc_info=e)
+        logger.warning("⚠️ Shutdown warning", exc_info=e)
 
 # ====================================================================
 # FastAPI instance
@@ -203,13 +145,7 @@ app = FastAPI(
 )
 
 # ====================================================================
-# NEW: Observability Instrumentation
-# ====================================================================
-instrument_fastapi(app)
-instrument_libraries()
-
-# ====================================================================
-# Middleware
+# CORS
 # ====================================================================
 environment = os.getenv("ENVIRONMENT", "development")
 is_production = environment == "production"
@@ -226,6 +162,7 @@ cors_origins = [
     "http://127.0.0.1:3000",
     "http://127.0.0.1:5000",
     "http://127.0.0.1:8080",
+    "http://127.0.0.1:56205",
 ]
 
 app.add_middleware(
@@ -238,9 +175,6 @@ app.add_middleware(
     max_age=600,
 )
 
-# NEW: Add request context middleware for tracing
-app.add_middleware(RequestContextMiddleware)
-
 # ====================================================================
 # Exception handlers
 # ====================================================================
@@ -288,58 +222,24 @@ async def general_exception_handler(request: Request, exc: Exception):
 app.include_router(auth.router, prefix="/api/auth", tags=["Authentication"])
 app.include_router(ai_chat_router, prefix="/ai", tags=["Aida AI"])
 
-# ====================================================================
-# NEW: Observability Endpoints
-# ====================================================================
-
-@app.get("/observability/status", tags=["Observability"])
-async def observability_status():
-    """Get observability status"""
-    try:
-        router = get_llm_router()
-        llm_status = router.get_stats()
-    except:
-        llm_status = {"error": "LLM router not available"}
-    
-    return {
-        "status": "ok",
-        "circuit_breakers": get_all_circuit_breaker_status(),
-        "llm_router": llm_status,
-        "token_usage": "See traces in observability backend",
-    }
-    
-    
-# Include monitoring endpoints
-app.include_router(monitoring_router, prefix="/api/monitoring", tags=["Monitoring"])
-
-
 # ====================================================================
 # Health
 # ====================================================================
 @app.get("/health", tags=["Health"])
-
 async def health_check():
-    """Health check endpoint with ML & LLM status"""
+    """Health check endpoint with ML status"""
     try:
         ml = get_ml_extractor()
         ml_ready = ml.field_models.get("location_classifier") is not None if ml.field_models else False
     except:
         ml_ready = False
     
-    try:
-        router = get_llm_router()
-        status = router.get_stats()
-        llm_ready = any(info["available"] for info in status["models"].values())
-    except:
-        llm_ready = False
-    
     return {
         "status": "ok",
         "service": "Lojiz Platform + Aida AI",
         "version": "1.0.0",
         "environment": environment,
-        "ml_ready": ml_ready,
-        "llm_ready": llm_ready,
+        "ml_ready": ml_ready,  # ✅ NEW
     }
 
 @app.get("/", tags=["Root"])
@@ -348,7 +248,6 @@ async def root():
         "message": "Welcome to Lojiz Platform + Aida AI",
         "docs": "/docs",
         "health": "/health",
-        "observability": "/observability/status",
         "environment": environment,
     }
 
@@ -356,22 +255,6 @@ async def root():
 async def options_handler(full_path: str):
     return JSONResponse(status_code=200, content={})
 
-# ====================================================================
-# Background Tasks
-# ====================================================================
-
-@app.on_event("startup")
-async def startup_background_tasks():
-    """Start background tasks"""
-    # Could add periodic cleanup, metrics collection, etc.
-    logger.info("✅ Background tasks started")
-
-@app.on_event("shutdown")
-async def shutdown_background_tasks():
-    """Shutdown background tasks"""
-    cleanup_expired_windows()
-    logger.info("✅ Background tasks stopped")
-
 # ====================================================================
 # Run: uvicorn app.main:app --reload
 # ====================================================================