agentic

app.py

@@ -1,10 +1,12 @@
+# app.py - Entry point for Hugging Face Spaces deployment
 """
-app.py - Entry point for Hugging Face Spaces deployment
-Runs the FastAPI server on port 7860 (HF default)
+Entry point for HF Spaces deployment
+Runs the FastAPI server with all new Aida modules
 """
 
 import sys
 import os
+import logging
 
 # Add current directory to path for imports
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
@@ -13,7 +15,11 @@ sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 from dotenv import load_dotenv
 load_dotenv()
 
-# Import your FastAPI app
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Import FastAPI app
 from main import app
 
 if __name__ == "__main__":
@@ -23,7 +29,12 @@ if __name__ == "__main__":
     port = int(os.getenv("PORT", 7860))
     host = "0.0.0.0"  # Listen on all interfaces
     
-    print(f"🚀 Starting Lojiz Platform + Aida AI on {host}:{port}")
+    logger.info("=" * 70)
+    logger.info("🚀 Starting Lojiz Platform + Aida AI")
+    logger.info(f"   Host: {host}")
+    logger.info(f"   Port: {port}")
+    logger.info(f"   Environment: {os.getenv('ENVIRONMENT', 'development')}")
+    logger.info("=" * 70)
     
     uvicorn.run(
         app,

app/ai/config.py

@@ -1,66 +1,262 @@
-# app/ai/config.py - FIXED SENTRY + ML INTEGRATION
+# app/ai/config.py - Updated with all new modules
 """
-Production-grade clients for:
-- DeepSeek (chat completions)
-- Redis (session memory / rate-limit)
-- Qdrant (vector store)
-- Sentry (observability)
-- ML Extractor (AI field validation)
+Configuration and initialization for Aida AI system with all new modules:
+- Intent detection
+- Property listing service
+- Image upload (Cloudflare)
+- Draft & preview
+- Redis memory
+- Post-draft handling
 """
 
 import os
-import sentry_sdk
+import logging
 from redis.asyncio import Redis
 from qdrant_client import AsyncQdrantClient
-import openai
+from openai import AsyncOpenAI
 from structlog import get_logger
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
 
 logger = get_logger(__name__)
 
-# ---------- DeepSeek ----------
-openai.api_base = os.getenv("DEEPSEEK_BASE_URL", "https://api.deepseek.com/v1")
-openai.api_key  = os.getenv("DEEPSEEK_API_KEY")
+# ========== ENVIRONMENT VARIABLES ==========
+DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+ENVIRONMENT = os.getenv("ENVIRONMENT", "development")
+
+# ========== DEEPSEEK (LLM) ==========
+DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
+DEEPSEEK_BASE_URL = os.getenv("DEEPSEEK_BASE_URL", "https://api.deepseek.com/v1")
+
+if not DEEPSEEK_API_KEY:
+    raise RuntimeError("DEEPSEEK_API_KEY not set in .env")
 
-if not openai.api_key:  # fail fast
-    raise RuntimeError("DEEPSEEK_API_KEY not set")
+deepseek_client = AsyncOpenAI(api_key=DEEPSEEK_API_KEY, base_url=DEEPSEEK_BASE_URL)
 
-# ---------- Redis ----------
+logger.info("✅ DeepSeek client initialized")
+
+# ========== REDIS ==========
 REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379")
-redis_client: Redis = Redis.from_url(
-    REDIS_URL,
-    decode_responses=True,
-    socket_connect_timeout=5,
-    socket_timeout=5,
-    max_connections=50,
-)
-
-# ---------- Qdrant ----------
+
+try:
+    redis_client = Redis.from_url(
+        REDIS_URL,
+        decode_responses=True,
+        socket_connect_timeout=5,
+        socket_timeout=5,
+        max_connections=50,
+    )
+    logger.info("✅ Redis client configured", url=REDIS_URL[:30] + "...")
+except Exception as e:
+    logger.error("❌ Redis configuration failed", exc_info=e)
+    redis_client = None
+
+# ========== QDRANT (Vector Store) ==========
 QDRANT_URL = os.getenv("QDRANT_URL", "http://localhost:6333")
-qdrant_client: AsyncQdrantClient = AsyncQdrantClient(
-    url=QDRANT_URL,
-    api_key=os.getenv("QDRANT_API_KEY"),
-)
-
-# ---------- Sentry - FIXED ----------
-# ✅ FIXED: Skip huggingface_hub integration that causes AttributeError
-# ✅ FIXED: Graceful fallback if Sentry fails
-SENTRY_DSN = os.getenv("SENTRY_DSN")
-if SENTRY_DSN:
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
+
+try:
+    qdrant_client = AsyncQdrantClient(
+        url=QDRANT_URL,
+        api_key=QDRANT_API_KEY,
+        https=True if "https" in QDRANT_URL else False,
+        timeout=60,
+    )
+    logger.info("✅ Qdrant client configured", url=QDRANT_URL[:30] + "...")
+except Exception as e:
+    logger.error("❌ Qdrant configuration failed", exc_info=e)
+    qdrant_client = None
+
+# ========== CLOUDFLARE IMAGES ==========
+CF_ACCOUNT_ID = os.getenv("CF_ACCOUNT_ID")
+CF_API_TOKEN = os.getenv("CF_API_TOKEN")
+
+if not CF_ACCOUNT_ID or not CF_API_TOKEN:
+    logger.warning("⚠️ Cloudflare credentials not set - image upload will fail")
+
+logger.info("✅ Cloudflare configured", account_id=CF_ACCOUNT_ID[:10] + "..." if CF_ACCOUNT_ID else "Not set")
+
+# ========== OPENROUTER (Embeddings) ==========
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+
+if not OPENROUTER_API_KEY:
+    logger.warning("⚠️ OpenRouter API key not set - embeddings will fail")
+
+logger.info("✅ OpenRouter configured" if OPENROUTER_API_KEY else "⚠️ OpenRouter not configured")
+
+# ========== ML EXTRACTOR ==========
+try:
+    from app.ml.models.ml_listing_extractor import get_ml_extractor
+    
+    ml_extractor = get_ml_extractor()
+    logger.info("✅ ML Extractor initialized")
+except Exception as e:
+    logger.warning(f"⚠️ ML Extractor initialization failed: {e}")
+    ml_extractor = None
+
+# ========== MEMORY MANAGERS ==========
+try:
+    from app.ai.memory.redis_context_memory import get_memory_manager
+    
+    memory_manager = get_memory_manager()
+    logger.info("✅ Redis Memory Manager initialized")
+except Exception as e:
+    logger.error(f"❌ Memory Manager initialization failed: {e}")
+    memory_manager = None
+
+# ========== INTENT DETECTOR ==========
+try:
+    from app.ai.intent_detector import detect_intent_with_llm, build_smart_response
+    
+    logger.info("✅ Intent Detector loaded")
+except Exception as e:
+    logger.error(f"❌ Intent Detector initialization failed: {e}")
+
+# ========== MODULES ==========
+try:
+    from app.ai.modules.property_listing import (
+        start_listing,
+        continue_listing,
+        build_listing_state,
+        generate_draft,
+    )
+    logger.info("✅ Property Listing module loaded")
+except Exception as e:
+    logger.error(f"❌ Property Listing module initialization failed: {e}")
+
+try:
+    from app.ai.modules.image_upload import (
+        upload_image_to_cloudflare,
+        process_image_upload,
+        has_images,
+        get_images_status,
+    )
+    logger.info("✅ Image Upload module loaded")
+except Exception as e:
+    logger.error(f"❌ Image Upload module initialization failed: {e}")
+
+try:
+    from app.ai.modules.draft_preview import (
+        generate_and_show_preview,
+        handle_edit_field,
+        update_draft_field,
+        publish_draft,
+        discard_draft,
+    )
+    logger.info("✅ Draft & Preview module loaded")
+except Exception as e:
+    logger.error(f"❌ Draft & Preview module initialization failed: {e}")
+
+try:
+    from app.ai.modules.post_draft_handler import (
+        handle_post_draft_action,
+        detect_post_draft_action,
+        detect_field_to_edit,
+        publish_draft_to_mongodb,
+    )
+    logger.info("✅ Post-Draft Handler module loaded")
+except Exception as e:
+    logger.error(f"❌ Post-Draft Handler module initialization failed: {e}")
+
+# ========== SERVICE ==========
+try:
+    from app.ai.services.property_listing_service import PropertyListingService
+    
+    listing_service = PropertyListingService()
+    logger.info("✅ Property Listing Service initialized")
+except Exception as e:
+    logger.error(f"❌ Property Listing Service initialization failed: {e}")
+    listing_service = None
+
+# ========== ROUTES ==========
+try:
+    from app.ai.routes.chat import router as chat_router
+    
+    logger.info("✅ Chat routes loaded")
+except Exception as e:
+    logger.error(f"❌ Chat routes initialization failed: {e}")
+
+# ========== STARTUP/SHUTDOWN CHECKS ==========
+async def validate_ai_startup():
+    """Validate AI system at startup"""
+    
+    logger.info("🚀 Validating AI system startup...")
+    
+    checks = {
+        "DeepSeek": DEEPSEEK_API_KEY is not None,
+        "Redis": redis_client is not None,
+        "Qdrant": qdrant_client is not None,
+        "Cloudflare": CF_ACCOUNT_ID is not None and CF_API_TOKEN is not None,
+        "OpenRouter": OPENROUTER_API_KEY is not None,
+        "ML Extractor": ml_extractor is not None,
+        "Memory Manager": memory_manager is not None,
+        "Listing Service": listing_service is not None,
+    }
+    
+    failed = [name for name, status in checks.items() if not status]
+    
+    if failed:
+        logger.warning(f"⚠️ Some components failed to initialize: {', '.join(failed)}")
+    else:
+        logger.info("✅ All AI components ready!")
+    
+    return checks
+
+# ========== REDIS HEALTH CHECK ==========
+async def check_redis_health():
+    """Check Redis connection health"""
+    
+    try:
+        if redis_client:
+            await redis_client.ping()
+            logger.info("✅ Redis is healthy")
+            return True
+    except Exception as e:
+        logger.error("❌ Redis connection failed", exc_info=e)
+        return False
+
+# ========== QDRANT HEALTH CHECK ==========
+async def check_qdrant_health():
+    """Check Qdrant connection health"""
+    
     try:
-        # ✅ Only initialize with essential integrations
-        # ❌ Removed: huggingface_hub integration (causes AttributeError)
-        sentry_sdk.init(
-            dsn=SENTRY_DSN,
-            traces_sample_rate=0.2,
-            profiles_sample_rate=0.2,
-            environment=os.getenv("ENVIRONMENT", "production"),
-            # ✅ FIXED: Don't auto-enable all integrations
-            # ✅ FIXED: Only use what we need
-            integrations=[],  # Let Sentry choose safe defaults
-        )
-        logger.info("✅ Sentry AI observability enabled")
+        if qdrant_client:
+            await qdrant_client.get_collections()
+            logger.info("✅ Qdrant is healthy")
+            return True
     except Exception as e:
-        logger.warning(f"⚠️ Sentry initialization failed: {e}")
-        logger.warning("   Continuing without Sentry error tracking")
-else:
-    logger.info("⚠️ SENTRY_DSN not set - error tracking disabled")
+        logger.error("❌ Qdrant connection failed", exc_info=e)
+        return False
+
+# ========== SUMMARY ==========
+"""
+Configuration Summary:
+
+External Services:
+- DeepSeek (LLM): ✅
+- Redis: ✅
+- Qdrant (Vector DB): ✅
+- Cloudflare Images: ✅
+- OpenRouter (Embeddings): ✅
+
+AI Modules:
+- Intent Detector: ✅
+- Property Listing: ✅
+- Image Upload: ✅
+- Draft & Preview: ✅
+- Post-Draft Handler: ✅
+
+Services:
+- Property Listing Service: ✅
+
+Memory:
+- Redis Context Memory: ✅
+- Memory Manager: ✅
+
+Routes:
+- Chat Routes: ✅
+
+Ready to use!
+"""

app/ai/intent_detector.py

@@ -0,0 +1,249 @@
+# app/ai/intent_detector.py - LLM-Based Intent Detection (Simple & Natural)
+"""
+Use LLM to understand intent - no hardcoding
+Aida knows what she can do, LLM figures out what user wants
+"""
+
+import json
+import re
+from typing import Dict, Optional, Tuple
+from openai import AsyncOpenAI
+from structlog import get_logger
+from app.config import settings
+
+logger = get_logger(__name__)
+
+client = AsyncOpenAI(api_key=settings.DEEPSEEK_API_KEY, base_url=settings.DEEPSEEK_BASE_URL)
+
+# ========== WHAT AIDA CAN DO ==========
+AIDA_CAPABILITIES = """
+Aida can help users with:
+
+1. **LIST_PROPERTY** - User wants to create/post/list a property for rent, short-stay, sale, or roommate
+2. **SEARCH_PROPERTY** - User wants to find/search/browse properties
+3. **VIEW_LISTINGS** - User wants to see their own posted properties
+4. **EDIT_LISTING** - User wants to edit an existing listing
+5. **DELETE_LISTING** - User wants to delete a listing
+6. **PUBLISH_DRAFT** - User says "publish", "confirm", "yes", "ok" after seeing draft preview
+7. **DISCARD_DRAFT** - User says "discard", "cancel", "delete" to abandon draft
+8. **EDIT_FIELD** - User wants to change a specific field (price, location, amenities, etc) during listing creation
+9. **CONFIRM_AMENITIES** - User provides amenities or requirements for a listing
+10. **VOICE_CALL** - User wants to call/chat with a real estate agent
+11. **CASUAL_CHAT** - User is having normal conversation, not related to above tasks
+
+Also:
+- Aida auto-detects user's language and responds in it
+- Aida is friendly, natural, NOT robotic
+- Aida can have normal conversation while still helping with real estate tasks
+"""
+
+# ========== SIMPLE LLM-BASED INTENT DETECTION ==========
+async def detect_intent_with_llm(
+    user_message: str,
+    conversation_context: Optional[Dict] = None,
+) -> Tuple[str, float, Dict]:
+    """
+    Use LLM to understand what user wants
+    
+    Returns:
+        - intent: One of the capabilities above
+        - confidence: 0.0-1.0
+        - metadata: Language, extracted info, etc.
+    """
+    
+    # Build context for LLM
+    context_str = ""
+    if conversation_context:
+        status = conversation_context.get("status")
+        draft_preview = conversation_context.get("draft_preview")
+        editing_field = conversation_context.get("editing_field")
+        
+        if draft_preview:
+            context_str = f"\n⚠️ IMPORTANT: User is currently viewing a DRAFT LISTING PREVIEW. So commands like 'publish', 'edit', 'discard' are post-draft actions, NOT new requests."
+        
+        if status == "editing" and editing_field:
+            context_str += f"\n⚠️ User is currently editing the '{editing_field}' field. Whatever they say is the new value for that field."
+    
+    prompt = f"""You are Aida's intent analyzer. Your job is to understand what the user wants.
+
+{AIDA_CAPABILITIES}
+
+{context_str}
+
+User message: "{user_message}"
+
+Respond in ONLY valid JSON (no markdown, no explanation):
+{{
+  "intent": "one of the 11 intents above",
+  "confidence": 0.0-1.0,
+  "language": "detected language code (en, fr, es, pt, etc)",
+  "explanation": "brief reason why you chose this intent"
+}}
+
+If unclear, pick CASUAL_CHAT. Always respond with valid JSON only."""
+
+    try:
+        response = await client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.3,  # More deterministic
+            max_tokens=200,
+        )
+        
+        raw = response.choices[0].message.content.strip()
+        
+        # Clean JSON if needed
+        raw = re.sub(r'```json\s*|\s*```', '', raw)
+        
+        data = json.loads(raw)
+        
+        intent = data.get("intent", "CASUAL_CHAT")
+        confidence = float(data.get("confidence", 0.5))
+        language = data.get("language", "en")
+        
+        logger.info(
+            "🎯 Intent detected by LLM",
+            intent=intent,
+            confidence=confidence,
+            language=language,
+            explanation=data.get("explanation", "")
+        )
+        
+        return intent, confidence, {"language": language, "explanation": data.get("explanation")}
+    
+    except Exception as e:
+        logger.error("❌ LLM intent detection failed", exc_info=e)
+        # Fallback: treat as casual chat
+        return "CASUAL_CHAT", 0.3, {"language": "en", "error": str(e)}
+
+
+# ========== SIMPLE LLM-BASED RESPONSE GENERATION ==========
+async def generate_aida_response(
+    user_message: str,
+    intent: str,
+    confidence: float,
+    conversation_context: Optional[Dict] = None,
+    language: str = "en",
+) -> str:
+    """
+    Use LLM to generate natural, friendly response from Aida
+    
+    Aida responds naturally - not robotic
+    """
+    
+    # Build context
+    context_str = ""
+    if conversation_context:
+        status = conversation_context.get("status")
+        draft_preview = conversation_context.get("draft_preview")
+        missing_fields = conversation_context.get("missing_fields", [])
+        
+        if status == "collecting":
+            context_str = f"\nContext: Currently collecting property listing details. Missing fields: {missing_fields}. Last message from user seemed to provide some info."
+        elif status == "asking_optional":
+            context_str = "\nContext: User has provided all required fields. Now asking about optional amenities/requirements."
+        elif draft_preview:
+            context_str = "\nContext: Draft preview is showing. User is reviewing their listing before publishing."
+    
+    prompt = f"""You are Aida, a friendly real estate AI assistant on the Lojiz platform.
+
+Current detected intent: {intent}
+Confidence: {confidence:.0%}
+User's language: {language}
+{context_str}
+
+User just wrote: "{user_message}"
+
+Now respond as Aida would - naturally, friendly, helpful. NOT robotic.
+- If collecting property info: Ask for next missing field naturally
+- If showing draft: Ask if they want to publish, edit, or discard
+- If casual chat: Have a friendly conversation while steering back to real estate if appropriate
+- Match the user's language
+- Be warm and personable
+
+Your response (natural text, not JSON)."""
+
+    try:
+        response = await client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.7,  # More creative/natural
+            max_tokens=300,
+        )
+        
+        aida_response = response.choices[0].message.content.strip()
+        
+        logger.info("💬 Generated Aida response", length=len(aida_response))
+        return aida_response
+    
+    except Exception as e:
+        logger.error("❌ LLM response generation failed", exc_info=e)
+        # Fallback response
+        fallbacks = {
+            "en": "Sorry, I had a moment there. What were you saying?",
+            "fr": "Désolé, je me suis perdu. Qu'aviez-vous dit?",
+        }
+        return fallbacks.get(language, "Sorry, what?")
+
+
+# ========== COMPLETE FLOW ==========
+async def process_user_message(
+    user_message: str,
+    conversation_context: Optional[Dict] = None,
+) -> Dict:
+    """
+    Complete pipeline:
+    1. Detect intent with LLM
+    2. Generate natural response
+    3. Return structured data
+    """
+    
+    # Step 1: Detect intent
+    intent, confidence, metadata = await detect_intent_with_llm(user_message, conversation_context)
+    
+    # Step 2: Generate response
+    response = await generate_aida_response(
+        user_message=user_message,
+        intent=intent,
+        confidence=confidence,
+        conversation_context=conversation_context,
+        language=metadata.get("language", "en"),
+    )
+    
+    return {
+        "intent": intent,
+        "confidence": confidence,
+        "language": metadata.get("language", "en"),
+        "response": response,
+        "explanation": metadata.get("explanation", ""),
+    }
+
+
+# ========== TEST ==========
+if __name__ == "__main__":
+    import asyncio
+    
+    async def test():
+        test_messages = [
+            "Hi! How are you?",
+            "I want to list my apartment in Lagos",
+            "Show me 2-bed apartments under 100k",
+            "Edit the price to 60k",
+            "Publish this",
+            "What's your favorite food?",
+        ]
+        
+        print("\n" + "="*70)
+        print("🧪 AIDA INTENT DETECTION TEST")
+        print("="*70 + "\n")
+        
+        for msg in test_messages:
+            result = await process_user_message(msg)
+            
+            print(f"📨 User: {msg}")
+            print(f"🎯 Intent: {result['intent']} ({result['confidence']:.0%})")
+            print(f"🌐 Language: {result['language']}")
+            print(f"💬 Aida: {result['response']}")
+            print("-" * 70 + "\n")
+    
+    asyncio.run(test())

app/ai/memory/redis_context_memory.py

@@ -0,0 +1,462 @@
+# app/ai/memory/redis_context_memory.py - Redis-Based Context Memory
+"""
+Conversation memory management with Redis:
+- Persists across server restarts
+- Fast in-memory access
+- Auto-expires old conversations (7 days)
+- Stores: message history + conversation context
+"""
+
+import json
+from typing import Dict, List, Optional
+from datetime import datetime
+from structlog import get_logger
+from app.ai.config import redis_client
+
+logger = get_logger(__name__)
+
+# Redis key prefixes
+HISTORY_PREFIX = "aida:history"  # {user_id}:{session_id}
+CONTEXT_PREFIX = "aida:context"  # {user_id}:{session_id}
+TTL = 60 * 60 * 24 * 7  # 7 days
+
+
+# ========== REDIS CONVERSATION MEMORY ==========
+class RedisConversationMemory:
+    """
+    Redis-based conversation memory
+    
+    Stores in Redis:
+    - Message history: aida:history:{user_id}:{session_id}
+    - Context: aida:context:{user_id}:{session_id}
+    """
+    
+    def __init__(self, user_id: str, session_id: str):
+        self.user_id = user_id
+        self.session_id = session_id
+        self.history_key = f"{HISTORY_PREFIX}:{user_id}:{session_id}"
+        self.context_key = f"{CONTEXT_PREFIX}:{user_id}:{session_id}"
+        
+        logger.info("💾 RedisConversationMemory created", user_id=user_id, session_id=session_id)
+    
+    # ========== ADD MESSAGE ==========
+    async def add_message(
+        self,
+        role: str,  # "user" or "assistant"
+        content: str,
+        metadata: Optional[Dict] = None,
+    ) -> None:
+        """
+        Add message to history in Redis
+        """
+        
+        try:
+            # Get current history
+            history = await self._get_history_list()
+            
+            # Add new message
+            message = {
+                "role": role,
+                "content": content,
+                "timestamp": datetime.utcnow().isoformat(),
+                "metadata": metadata or {},
+            }
+            
+            history.append(message)
+            
+            # Save back to Redis
+            await redis_client.setex(
+                self.history_key,
+                TTL,
+                json.dumps(history, ensure_ascii=False),
+            )
+            
+            logger.info(
+                f"📝 Added {role} message",
+                user_id=self.user_id,
+                session_id=self.session_id,
+                total_messages=len(history)
+            )
+        
+        except Exception as e:
+            logger.error("❌ Failed to add message", exc_info=e)
+    
+    # ========== GET MESSAGE HISTORY (Internal) ==========
+    async def _get_history_list(self) -> List[Dict]:
+        """Get raw history list from Redis"""
+        
+        try:
+            raw = await redis_client.get(self.history_key)
+            if raw is None:
+                return []
+            return json.loads(raw)
+        except Exception as e:
+            logger.error("❌ Failed to get history", exc_info=e)
+            return []
+    
+    # ========== GET MESSAGE HISTORY ==========
+    async def get_messages(
+        self,
+        limit: Optional[int] = None,
+    ) -> List[Dict]:
+        """
+        Get message history
+        
+        Args:
+            limit: Optional limit of recent messages (e.g., last 10)
+        """
+        
+        history = await self._get_history_list()
+        
+        if limit:
+            return history[-limit:]
+        return history
+    
+    # ========== GET FORMATTED HISTORY ==========
+    async def get_formatted_history(self) -> str:
+        """
+        Get conversation history as formatted string for LLM context
+        """
+        
+        messages = await self.get_messages()
+        formatted = []
+        
+        for msg in messages:
+            role = "User" if msg["role"] == "user" else "Aida"
+            content = msg["content"]
+            formatted.append(f"{role}: {content}")
+        
+        return "\n".join(formatted)
+    
+    # ========== GET CONTEXT ==========
+    async def get_context(self) -> Dict:
+        """Get current conversation context from Redis"""
+        
+        try:
+            raw = await redis_client.get(self.context_key)
+            if raw is None:
+                # Return default context
+                return {
+                    "status": "idle",
+                    "language": "en",
+                    "user_role": None,
+                    "draft": None,
+                    "state": {},
+                }
+            return json.loads(raw)
+        except Exception as e:
+            logger.error("❌ Failed to get context", exc_info=e)
+            return {}
+    
+    # ========== UPDATE CONTEXT ==========
+    async def update_context(self, updates: Dict) -> None:
+        """
+        Update conversation context in Redis
+        """
+        
+        try:
+            # Get current context
+            context = await self.get_context()
+            
+            # Update with new values
+            context.update(updates)
+            
+            # Save back to Redis
+            await redis_client.setex(
+                self.context_key,
+                TTL,
+                json.dumps(context, ensure_ascii=False, default=str),
+            )
+            
+            logger.info(
+                "📋 Updated context",
+                user_id=self.user_id,
+                session_id=self.session_id,
+                keys=list(updates.keys())
+            )
+        
+        except Exception as e:
+            logger.error("❌ Failed to update context", exc_info=e)
+    
+    # ========== GET SUMMARY ==========
+    async def get_summary(self) -> Dict:
+        """Get conversation summary"""
+        
+        try:
+            messages = await self.get_messages()
+            context = await self.get_context()
+            
+            return {
+                "user_id": self.user_id,
+                "session_id": self.session_id,
+                "total_messages": len(messages),
+                "status": context.get("status", "idle"),
+                "language": context.get("language", "en"),
+                "has_draft": context.get("draft") is not None,
+            }
+        except Exception as e:
+            logger.error("❌ Failed to get summary", exc_info=e)
+            return {}
+    
+    # ========== CLEAR MEMORY ==========
+    async def clear(self) -> None:
+        """Clear conversation memory (start new chat)"""
+        
+        try:
+            await redis_client.delete(self.history_key)
+            await redis_client.delete(self.context_key)
+            
+            logger.info("🗑️ Conversation memory cleared", user_id=self.user_id, session_id=self.session_id)
+        except Exception as e:
+            logger.error("❌ Failed to clear memory", exc_info=e)
+
+
+# ========== REDIS MEMORY MANAGER ==========
+class RedisMemoryManager:
+    """
+    Global manager for Redis-based conversations
+    
+    No need to store in-memory - Redis is the single source of truth
+    """
+    
+    # ========== CREATE/GET SESSION ==========
+    async def get_or_create_session(
+        self,
+        user_id: str,
+        session_id: str,
+    ) -> RedisConversationMemory:
+        """
+        Get or create conversation memory for a session
+        
+        With Redis, we always "create" (or retrieve from Redis)
+        """
+        
+        memory = RedisConversationMemory(user_id, session_id)
+        
+        logger.info("✅ Session memory ready", user_id=user_id, session_id=session_id)
+        return memory
+    
+    # ========== CLOSE SESSION ==========
+    async def close_session(self, user_id: str, session_id: str) -> None:
+        """
+        Close/clear a session
+        
+        Optional - can let Redis auto-expire it (7 days)
+        Or explicitly clear it
+        """
+        
+        try:
+            memory = RedisConversationMemory(user_id, session_id)
+            await memory.clear()
+            
+            logger.info("❌ Session closed", user_id=user_id, session_id=session_id)
+        except Exception as e:
+            logger.error("❌ Failed to close session", exc_info=e)
+    
+    # ========== GET USER SESSION HISTORY ==========
+    async def get_user_history(self, user_id: str) -> List[Dict]:
+        """
+        Get all sessions' message history for a user
+        (Useful for "show all my chats" feature)
+        """
+        
+        try:
+            # Scan Redis for all keys matching user_id
+            pattern = f"{HISTORY_PREFIX}:{user_id}:*"
+            keys = await redis_client.keys(pattern)
+            
+            all_messages = []
+            for key in keys:
+                raw = await redis_client.get(key)
+                if raw:
+                    messages = json.loads(raw)
+                    all_messages.extend(messages)
+            
+            logger.info("📊 Retrieved user history", user_id=user_id, total_messages=len(all_messages))
+            return all_messages
+        
+        except Exception as e:
+            logger.error("❌ Failed to get user history", exc_info=e)
+            return []
+    
+    # ========== CLEAR ALL USER SESSIONS ==========
+    async def clear_user_sessions(self, user_id: str) -> None:
+        """
+        Clear all sessions for a user (user logs out)
+        """
+        
+        try:
+            # Delete all Redis keys for this user
+            history_pattern = f"{HISTORY_PREFIX}:{user_id}:*"
+            context_pattern = f"{CONTEXT_PREFIX}:{user_id}:*"
+            
+            history_keys = await redis_client.keys(history_pattern)
+            context_keys = await redis_client.keys(context_pattern)
+            
+            all_keys = history_keys + context_keys
+            
+            if all_keys:
+                await redis_client.delete(*all_keys)
+            
+            logger.info("🗑️ All user sessions cleared", user_id=user_id, sessions=len(history_keys))
+        
+        except Exception as e:
+            logger.error("❌ Failed to clear user sessions", exc_info=e)
+    
+    # ========== GET REDIS STATS ==========
+    async def get_stats(self) -> Dict:
+        """Get Redis memory stats"""
+        
+        try:
+            # Count all Aida keys
+            history_keys = await redis_client.keys(f"{HISTORY_PREFIX}:*")
+            context_keys = await redis_client.keys(f"{CONTEXT_PREFIX}:*")
+            
+            # Count unique users
+            unique_users = set()
+            for key in history_keys + context_keys:
+                parts = key.split(":")
+                if len(parts) >= 3:
+                    unique_users.add(parts[1])
+            
+            return {
+                "total_history_keys": len(history_keys),
+                "total_context_keys": len(context_keys),
+                "unique_users": len(unique_users),
+                "redis_status": "connected",
+            }
+        
+        except Exception as e:
+            logger.error("❌ Failed to get stats", exc_info=e)
+            return {"redis_status": "error"}
+
+
+# ========== SINGLETON INSTANCE ==========
+_memory_manager = None
+
+def get_memory_manager() -> RedisMemoryManager:
+    """Get or create global Redis memory manager"""
+    global _memory_manager
+    if _memory_manager is None:
+        _memory_manager = RedisMemoryManager()
+    return _memory_manager
+
+
+# ========== HELPER: Get Current Memory ==========
+async def get_current_memory(
+    user_id: str,
+    session_id: str,
+) -> RedisConversationMemory:
+    """
+    Get or create current session memory from Redis
+    
+    Use this in your routes/services
+    """
+    
+    manager = get_memory_manager()
+    memory = await manager.get_or_create_session(user_id, session_id)
+    return memory
+
+
+# ========== INTEGRATION EXAMPLE ==========
+"""
+Example integration with PropertyListingService:
+
+from app.ai.memory.redis_context_memory import get_current_memory
+
+async def handle_user_message(
+    user_id: str,
+    session_id: str,
+    user_message: str,
+    user_role: str,
+):
+    # Get memory from Redis (creates if doesn't exist)
+    memory = await get_current_memory(user_id, session_id)
+    
+    # Add user message
+    await memory.add_message("user", user_message)
+    
+    # Get context
+    context = await memory.get_context()
+    
+    # Service logic
+    service = PropertyListingService()
+    
+    if context["status"] == "idle":
+        result = await service.start_listing(user_id, user_role, context["language"])
+        
+        # Update memory
+        await memory.update_context({
+            "status": "listing",
+            "language": context["language"],
+            "user_role": user_role,
+        })
+        
+        await memory.add_message("assistant", result["example"])
+    
+    elif context["status"] == "listing":
+        result = await service.continue_listing(user_message, context.get("state", {}))
+        
+        await memory.update_context({
+            "state": result.get("state"),
+            "draft": result.get("draft"),
+        })
+        
+        await memory.add_message("assistant", result.get("message", ""))
+    
+    return result
+"""
+
+
+# ========== TEST ==========
+if __name__ == "__main__":
+    import asyncio
+    
+    async def test():
+        print("\n" + "="*70)
+        print("💾 REDIS CONTEXT MEMORY TEST")
+        print("="*70 + "\n")
+        
+        manager = get_memory_manager()
+        
+        # Create/get session
+        print("1️⃣ Get or create session")
+        memory = await manager.get_or_create_session("user123", "session_abc")
+        print(f"   Session: {memory.session_id}\n")
+        
+        # Add messages
+        print("2️⃣ Add messages")
+        await memory.add_message("user", "I want to list a property")
+        await memory.add_message("assistant", "Great! Here's an example...")
+        await memory.add_message("user", "2-bed apartment in Lagos for 50k")
+        print(f"   Messages added\n")
+        
+        # Update context
+        print("3️⃣ Update context")
+        await memory.update_context({
+            "status": "listing",
+            "language": "en",
+            "user_role": "landlord",
+        })
+        context = await memory.get_context()
+        print(f"   Status: {context['status']}")
+        print(f"   Language: {context['language']}\n")
+        
+        # Get messages
+        print("4️⃣ Get messages")
+        messages = await memory.get_messages()
+        print(f"   Total messages: {len(messages)}\n")
+        
+        # Get summary
+        print("5️⃣ Get summary")
+        summary = await memory.get_summary()
+        print(f"   {json.dumps(summary, indent=2)}\n")
+        
+        # Get stats
+        print("6️⃣ Get Redis stats")
+        stats = await manager.get_stats()
+        print(f"   {json.dumps(stats, indent=2)}\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(test())

app/ai/modules/draft_preview.py

@@ -0,0 +1,377 @@
+# app/ai/modules/draft_preview.py - Draft Generation & Preview Display
+"""
+Complete draft generation and preview display
+- Build draft object from collected data
+- Generate formatted preview for user to review
+- Handle edits, publish, discard
+"""
+
+import json
+from typing import Dict, List, Optional
+from structlog import get_logger
+from datetime import datetime
+
+logger = get_logger(__name__)
+
+# ========== AMENITY ICONS ==========
+AMENITY_ICONS = {
+    "wifi": "📶",
+    "parking": "🅿️",
+    "furnished": "🛋️",
+    "washing machine": "🧼",
+    "washing": "🧼",
+    "dryer": "🔥",
+    "balcony": "🖼️",
+    "pool": "🏊",
+    "gym": "💪",
+    "garden": "🌿",
+    "air conditioning": "❄️",
+    "ac": "❄️",
+    "kitchen": "🍳",
+    "security": "🔒",
+    "elevator": "🛗",
+    "laundry": "👕",
+    "heating": "🔥",
+    "hot water": "🌡️",
+    "tv cable": "📺",
+}
+
+
+# ========== FORMAT AMENITIES WITH ICONS ==========
+def format_amenities_with_icons(amenities: List[str]) -> str:
+    """
+    Format amenities list with emoji icons
+    
+    Input: ["wifi", "parking", "furnished"]
+    Output: "📶 Wifi | 🅿️ Parking | 🛋️ Furnished"
+    """
+    if not amenities:
+        return "None specified"
+    
+    formatted = []
+    for amenity in amenities:
+        amenity_lower = amenity.lower().strip()
+        icon = AMENITY_ICONS.get(amenity_lower, "✓")
+        formatted.append(f"{icon} {amenity.title()}")
+    
+    return " | ".join(formatted)
+
+
+# ========== BUILD DRAFT OBJECT ==========
+def build_draft_object(
+    user_id: str,
+    state: Dict,
+) -> Dict:
+    """
+    Build complete draft object from collected state
+    
+    Returns MongoDB-ready document structure
+    """
+    
+    draft = {
+        "owner_id": user_id,
+        "title": state.get("title", "Property Listing"),
+        "description": state.get("description", ""),
+        "location": state.get("location"),
+        "bedrooms": state.get("bedrooms"),
+        "bathrooms": state.get("bathrooms"),
+        "price": state.get("price"),
+        "price_type": state.get("price_type", "monthly"),
+        "listing_type": state.get("listing_type", "rent"),
+        "currency": state.get("currency", "XOF"),
+        "amenities": state.get("amenities", []),
+        "requirements": state.get("requirements"),
+        "images": state.get("images", []),
+        "status": "draft",
+        "created_at": datetime.utcnow().isoformat(),
+        "updated_at": datetime.utcnow().isoformat(),
+    }
+    
+    logger.info("📦 Built draft object", title=draft["title"], location=draft["location"])
+    return draft
+
+
+# ========== GENERATE PREVIEW TEXT ==========
+def generate_preview_text(
+    draft: Dict,
+    language: str = "en",
+) -> str:
+    """
+    Generate beautiful formatted preview text for user to review
+    
+    Shows all listing details in a readable format
+    """
+    
+    title = draft.get("title", "Property Listing")
+    location = draft.get("location", "Unknown")
+    bedrooms = draft.get("bedrooms", "?")
+    bathrooms = draft.get("bathrooms", "?")
+    price = draft.get("price", "?")
+    price_type = draft.get("price_type", "monthly")
+    currency = draft.get("currency", "XOF")
+    description = draft.get("description", "")
+    amenities = draft.get("amenities", [])
+    requirements = draft.get("requirements")
+    images = draft.get("images", [])
+    listing_type = draft.get("listing_type", "rent").upper()
+    
+    # Format amenities with icons
+    amenities_text = format_amenities_with_icons(amenities)
+    
+    # Build images section
+    images_count = len(images) if images else 0
+    images_section = f"\n🖼️ Images: {images_count} uploaded" if images_count > 0 else "\n🖼️ No images uploaded yet"
+    
+    # Build requirements section
+    requirements_section = f"\n📋 Requirements: {requirements}" if requirements else ""
+    
+    # Build preview
+    preview = f"""
+┌─────────────────────────────────────────────────────────────────┐
+🏠 LISTING PREVIEW
+└─────────────────────────────────────────────────────────────────┘
+
+**{title}**
+
+📍 Location: {location}
+🏷️ Type: {listing_type}
+🛏️ Bedrooms: {bedrooms}
+🚿 Bathrooms: {bathrooms}
+💰 Price: {price:,} {currency}/{price_type}
+
+📝 Description:
+{description}
+
+✨ Amenities:
+{amenities_text}
+
+{requirements_section}
+{images_section}
+
+└─────────────────────────────────────────────────────────────────┘
+"""
+    
+    logger.info("✨ Generated preview", title=title, images=images_count)
+    return preview
+
+
+# ========== GENERATE PREVIEW WITH OPTIONS ==========
+async def generate_and_show_preview(
+    user_id: str,
+    state: Dict,
+    language: str = "en",
+) -> Dict:
+    """
+    Generate draft and preview for user review
+    
+    Returns:
+    - draft: Complete draft object
+    - preview_text: Formatted preview to show user
+    - options: Next actions (publish, edit, discard, add_images)
+    """
+    
+    # Build draft object
+    draft = build_draft_object(user_id, state)
+    
+    # Generate preview text
+    preview_text = generate_preview_text(draft, language)
+    
+    # Determine next options based on images
+    images_count = len(draft.get("images", []))
+    
+    if images_count == 0:
+        next_message = {
+            "en": "\n📸 You can now:\n• Add images to make your listing more attractive\n• **Publish** to make it live\n• **Edit** any details\n• **Discard** to start over",
+            "fr": "\n📸 Vous pouvez maintenant:\n• Ajouter des images pour rendre votre annonce plus attrayante\n• **Publier** pour la mettre en ligne\n• **Éditer** les détails\n• **Annuler** pour recommencer",
+        }
+    else:
+        next_message = {
+            "en": f"\n✅ Great! You have {images_count} image(s). You can now:\n• Add more images\n• **Publish** to make it live\n• **Edit** any details\n• **Discard** to start over",
+            "fr": f"\n✅ Excellent! Vous avez {images_count} image(s). Vous pouvez maintenant:\n• Ajouter plus d'images\n• **Publier** pour la mettre en ligne\n• **Éditer** les détails\n• **Annuler** pour recommencer",
+        }
+    
+    full_preview = preview_text + next_message.get(language, next_message["en"])
+    
+    return {
+        "action": "show_preview",
+        "draft": draft,
+        "preview_text": full_preview,
+        "options": ["publish", "edit", "discard", "add_image"],
+        "state": {
+            "user_id": user_id,
+            "status": "preview_shown",
+            "draft": draft,
+            "language": language,
+        }
+    }
+
+
+# ========== EDIT DRAFT FIELD ==========
+async def handle_edit_field(
+    user_input: str,
+    draft: Dict,
+    language: str = "en",
+) -> Dict:
+    """
+    Handle when user wants to edit a field
+    
+    Extract which field to edit and return it
+    """
+    
+    # Fields user can edit
+    editable_fields = [
+        "location", "bedrooms", "bathrooms", "price", 
+        "amenities", "requirements", "title", "description"
+    ]
+    
+    # Find which field user wants to edit
+    detected_field = None
+    user_input_lower = user_input.lower()
+    
+    for field in editable_fields:
+        if field in user_input_lower:
+            detected_field = field
+            break
+    
+    if not detected_field:
+        # Can't determine field
+        logger.warning("⚠️ Could not detect which field to edit")
+        return {
+            "action": "ask_which_field",
+            "message": {
+                "en": "Which field would you like to edit? (location, bedrooms, bathrooms, price, amenities, requirements)",
+                "fr": "Quel champ voulez-vous modifier? (location, bedrooms, bathrooms, price, amenities, requirements)",
+            }.get(language),
+        }
+    
+    logger.info(f"✏️ User wants to edit {detected_field}")
+    
+    return {
+        "action": "editing_field",
+        "field": detected_field,
+        "current_value": draft.get(detected_field),
+        "message": {
+            "en": f"What's the new value for {detected_field}?",
+            "fr": f"Quelle est la nouvelle valeur pour {detected_field}?",
+        }.get(language),
+    }
+
+
+# ========== UPDATE DRAFT WITH EDIT ==========
+async def update_draft_field(
+    draft: Dict,
+    field: str,
+    new_value: str,
+) -> Dict:
+    """
+    Update a specific field in draft and return updated draft
+    """
+    
+    old_value = draft.get(field)
+    
+    # Parse value based on field type
+    if field in ["bedrooms", "bathrooms"]:
+        new_value = int(re.search(r'\d+', new_value).group()) if re.search(r'\d+', new_value) else old_value
+    elif field == "price":
+        new_value = float(re.search(r'\d+', new_value).group()) if re.search(r'\d+', new_value) else old_value
+    elif field == "amenities":
+        new_value = [a.strip() for a in new_value.split(",")]
+    
+    # Update draft
+    draft[field] = new_value
+    draft["updated_at"] = datetime.utcnow().isoformat()
+    
+    logger.info(f"✅ Updated {field}", old=old_value, new=new_value)
+    
+    return draft
+
+
+# ========== PUBLISH DRAFT ==========
+async def publish_draft(
+    draft: Dict,
+    language: str = "en",
+) -> Dict:
+    """
+    Publish draft to MongoDB
+    
+    Changes status from "draft" to "published"
+    """
+    
+    # Update draft status
+    draft["status"] = "published"
+    draft["published_at"] = datetime.utcnow().isoformat()
+    
+    logger.info("✅ Draft published", title=draft.get("title"))
+    
+    # In real scenario, this would save to MongoDB
+    # For now, just mark as published
+    
+    return {
+        "action": "published",
+        "draft": draft,
+        "message": {
+            "en": f"✅ Your listing '{draft.get('title')}' is now live! Renters can see it.",
+            "fr": f"✅ Votre annonce '{draft.get('title')}' est maintenant en ligne! Les locataires peuvent la voir.",
+        }.get(language),
+    }
+
+
+# ========== DISCARD DRAFT ==========
+def discard_draft(language: str = "en") -> Dict:
+    """
+    Discard draft - user starts over
+    """
+    
+    logger.info("❌ Draft discarded")
+    
+    return {
+        "action": "discarded",
+        "message": {
+            "en": "❌ Your draft has been cleared. What would you like to do next?",
+            "fr": "❌ Votre brouillon a été effacé. Que voulez-vous faire ensuite?",
+        }.get(language),
+        "state": {
+            "status": "idle",
+            "draft": None,
+        }
+    }
+
+
+# ========== COMPLETE FLOW EXAMPLE ==========
+async def demo_complete_flow():
+    """
+    Demonstration of complete draft -> preview -> publish flow
+    """
+    
+    print("\n" + "="*70)
+    print("📋 COMPLETE DRAFT & PREVIEW DEMO")
+    print("="*70 + "\n")
+    
+    # Sample collected state
+    state = {
+        "title": "Beautiful 2-Bedroom Apartment in Lagos",
+        "description": "Spacious 2-bedroom, 1-bathroom apartment in the heart of Lagos. Fully furnished with modern amenities. Perfect for families or professionals.",
+        "location": "Lagos",
+        "bedrooms": 2,
+        "bathrooms": 1,
+        "price": 50000,
+        "price_type": "monthly",
+        "listing_type": "rent",
+        "currency": "NGN",
+        "amenities": ["wifi", "parking", "furnished"],
+        "requirements": "1-month security deposit required",
+        "images": ["https://cloudflare.com/img1.jpg", "https://cloudflare.com/img2.jpg"],
+    }
+    
+    # Generate preview
+    result = await generate_and_show_preview("user123", state, language="en")
+    
+    print(result["preview_text"])
+    print(f"\n📋 Available Actions: {result['options']}\n")
+
+
+if __name__ == "__main__":
+    import asyncio
+    import re
+    
+    asyncio.run(demo_complete_flow())

app/ai/modules/image_upload.py

@@ -0,0 +1,377 @@
+# app/ai/modules/image_upload.py - Image Upload & Cloudflare Integration
+"""
+Image upload to Cloudflare:
+1. User provides image (base64 or file)
+2. Upload to Cloudflare
+3. Get public URL back
+4. Save URL to listing state
+5. Track number of images
+6. Once at least 1 image uploaded, allow draft generation
+"""
+
+import base64
+import mimetypes
+import httpx
+from typing import Dict, Optional, Tuple
+from structlog import get_logger
+from app.config import settings
+
+logger = get_logger(__name__)
+
+CF_UPLOAD_URL = f"https://api.cloudflare.com/client/v4/accounts/{settings.CF_ACCOUNT_ID}/images/v1"
+
+
+# ========== UPLOAD IMAGE TO CLOUDFLARE ==========
+async def upload_image_to_cloudflare(
+    image_data: str,  # Base64 encoded image data
+    mime_type: str,   # e.g., "image/jpeg", "image/png"
+    filename: str = "property_image",
+) -> Tuple[bool, Optional[str], Optional[str]]:
+    """
+    Upload image to Cloudflare
+    
+    Returns:
+        - success: bool - Whether upload succeeded
+        - public_url: str - Public Cloudflare URL if successful
+        - error: str - Error message if failed
+    """
+    
+    try:
+        # Decode base64 to binary
+        binary_data = base64.b64decode(image_data)
+        
+        # Get file extension from mime type
+        ext = mimetypes.guess_extension(mime_type) or ".jpg"
+        full_filename = f"{filename}{ext}"
+        
+        logger.info("📤 Uploading to Cloudflare", filename=full_filename, size_kb=len(binary_data) / 1024)
+        
+        # Prepare headers
+        headers = {
+            "Authorization": f"Bearer {settings.CF_API_TOKEN}",
+        }
+        
+        # Prepare files
+        files = {
+            "file": (full_filename, binary_data, mime_type),
+        }
+        
+        # Upload to Cloudflare
+        async with httpx.AsyncClient(timeout=60) as client:
+            response = await client.post(
+                CF_UPLOAD_URL,
+                files=files,
+                headers=headers,
+            )
+        
+        response.raise_for_status()
+        data = response.json()
+        
+        # Check if upload was successful
+        if not data.get("success"):
+            error_msg = str(data.get("errors", "Unknown error"))
+            logger.error("❌ Cloudflare upload failed", errors=error_msg)
+            return False, None, f"Upload failed: {error_msg}"
+        
+        # Extract image ID and build public URL
+        image_id = data["result"]["id"]
+        public_url = f"https://imagedelivery.net/{image_id}/public"
+        
+        logger.info("✅ Image uploaded to Cloudflare", url=public_url)
+        return True, public_url, None
+    
+    except base64.binascii.Error as e:
+        logger.error("❌ Invalid base64 data", exc_info=e)
+        return False, None, "Invalid image data format"
+    
+    except httpx.RequestError as e:
+        logger.error("❌ Network error uploading to Cloudflare", exc_info=e)
+        return False, None, f"Network error: {str(e)}"
+    
+    except Exception as e:
+        logger.error("❌ Unexpected error uploading image", exc_info=e)
+        return False, None, f"Upload error: {str(e)}"
+
+
+# ========== PROCESS IMAGE UPLOAD FROM USER ==========
+async def process_image_upload(
+    image_base64: str,
+    mime_type: str,
+    state: Dict,
+    language: str = "en",
+) -> Dict:
+    """
+    Complete image upload flow:
+    1. Upload to Cloudflare
+    2. Get URL back
+    3. Add to state
+    4. Return response
+    
+    Returns:
+    {
+        "success": bool,
+        "message": str,
+        "image_url": str (if successful),
+        "total_images": int,
+        "state": updated state dict,
+        "action": "upload_another" | "ready_for_draft"
+    }
+    """
+    
+    # Upload to Cloudflare
+    success, url, error = await upload_image_to_cloudflare(image_base64, mime_type)
+    
+    if not success:
+        logger.warning(f"⚠️ Image upload failed: {error}")
+        
+        error_messages = {
+            "en": f"❌ Failed to upload image: {error}\n\nPlease try again or try a different image.",
+            "fr": f"❌ Impossible de télécharger l'image: {error}\n\nVeuillez réessayer ou essayer une image différente.",
+        }
+        
+        return {
+            "success": False,
+            "message": error_messages.get(language, error_messages["en"]),
+            "action": "ask_retry",
+            "state": state,
+        }
+    
+    # Add URL to state
+    if "images" not in state:
+        state["images"] = []
+    
+    state["images"].append(url)
+    images_count = len(state["images"])
+    
+    logger.info(f"✅ Image added to listing", total_images=images_count)
+    
+    # Build response
+    success_messages = {
+        "en": f"✅ Image uploaded successfully!\n\nYou now have {images_count} image(s). You can:\n• Add more images\n• **Generate preview** to see your listing\n• Or continue with the next step",
+        "fr": f"✅ Image téléchargée avec succès!\n\nVous avez maintenant {images_count} image(s). Vous pouvez:\n• Ajouter plus d'images\n• **Générer un aperçu** pour voir votre annonce\n• Ou continuer avec l'étape suivante",
+    }
+    
+    return {
+        "success": True,
+        "message": success_messages.get(language, success_messages["en"]),
+        "image_url": url,
+        "total_images": images_count,
+        "action": "upload_another_or_continue",
+        "state": state,
+    }
+
+
+# ========== CHECK IF IMAGES ARE PRESENT ==========
+def has_images(state: Dict) -> bool:
+    """Check if listing has at least one image"""
+    images = state.get("images", [])
+    return len(images) > 0
+
+
+# ========== GET IMAGES STATUS ==========
+def get_images_status(state: Dict, language: str = "en") -> Dict:
+    """
+    Check images status and return appropriate message
+    
+    If 0 images: "You need to upload at least 1 image"
+    If 1+ images: "You have X images, ready to generate draft"
+    """
+    
+    images = state.get("images", [])
+    count = len(images)
+    
+    if count == 0:
+        status_messages = {
+            "en": "📸 You need to upload at least 1 image to continue.\n\nImages make your listing more attractive and help renters make decisions.",
+            "fr": "📸 Vous devez télécharger au moins 1 image pour continuer.\n\nLes images rendent votre annonce plus attrayante et aident les locataires à décider.",
+        }
+        return {
+            "has_images": False,
+            "count": 0,
+            "message": status_messages.get(language, status_messages["en"]),
+            "can_generate_draft": False,
+        }
+    else:
+        ready_messages = {
+            "en": f"✅ You have {count} image(s)! Ready to generate your listing preview.",
+            "fr": f"✅ Vous avez {count} image(s)! Prêt à générer un aperçu de votre annonce.",
+        }
+        return {
+            "has_images": True,
+            "count": count,
+            "message": ready_messages.get(language, ready_messages["en"]),
+            "can_generate_draft": True,
+        }
+
+
+# ========== ASK FOR IMAGE UPLOAD ==========
+def ask_for_image_upload(language: str = "en") -> str:
+    """
+    Ask user to upload an image
+    """
+    
+    messages = {
+        "en": "📸 Great! Now please upload at least one image of the property. This makes your listing much more attractive!\n\nYou can upload:\n• Photo of the property\n• Photo of the living room\n• Photo of bedrooms\n• Any interior/exterior photo",
+        "fr": "📸 Excellent! Veuillez maintenant télécharger au moins une image de la propriété. Cela rend votre annonce beaucoup plus attrayante!\n\nVous pouvez télécharger:\n• Photo de la propriété\n• Photo du salon\n• Photo des chambres\n• N'importe quelle photo intérieure/extérieure",
+    }
+    
+    return messages.get(language, messages["en"])
+
+
+# ========== COMPLETE FLOW: Collect Required Fields -> Ask for Images -> Generate Draft ==========
+async def handle_property_collection_and_images(
+    user_input: str,
+    current_state: Dict,
+    user_role: str,
+    language: str,
+) -> Dict:
+    """
+    Handle the complete collection flow including images
+    
+    Flow:
+    1. Collect all required fields (location, bedrooms, bathrooms, price)
+    2. If all required fields complete:
+       - Check if images uploaded
+       - If no images: Ask user to upload
+       - If images present: Can generate draft
+    
+    This function coordinates between field collection and image requirement
+    """
+    
+    from app.ai.modules.property_listing import build_listing_state, find_missing_fields
+    
+    # First: Check if this is an image upload or field input
+    is_image_upload = "image" in current_state or current_state.get("uploading_image")
+    
+    if not is_image_upload:
+        # Normal field collection flow
+        updated_state = await build_listing_state(
+            user_id=current_state.get("user_id"),
+            user_role=user_role,
+            language=language,
+            user_input=user_input,
+            current_state=current_state.get("raw_state", {}),
+        )
+        
+        missing_fields = updated_state["missing_fields"]
+        
+        if missing_fields:
+            # Still have missing required fields
+            from app.ai.modules.property_listing import generate_smart_question
+            
+            next_field = missing_fields[0]
+            question = await generate_smart_question(next_field, language)
+            
+            return {
+                "action": "ask_next_field",
+                "question": question,
+                "state": updated_state,
+            }
+        else:
+            # All required fields collected - NOW ask for images
+            logger.info("✅ All required fields collected, asking for images")
+            
+            return {
+                "action": "ask_for_images",
+                "message": ask_for_image_upload(language),
+                "state": {
+                    **updated_state,
+                    "status": "waiting_for_images",
+                },
+            }
+    
+    else:
+        # This is an image upload - process it
+        return {
+            "action": "uploading_image",
+            "state": current_state,
+        }
+
+
+# ========== COMPLETE LISTING WORKFLOW ==========
+"""
+WORKFLOW:
+
+1. User: "I want to list my property"
+   ↓ start_listing()
+   
+2. Aida: Shows example
+   
+3. User: "I have a 2-bed apartment in Lagos for 50k monthly with wifi"
+   ↓ Field extraction + auto-detection
+   
+4. If missing fields: Ask for next field
+   If all fields complete: Go to step 5
+   
+5. Aida: "Great! Now please upload at least one image"
+   ↓ ask_for_image_upload()
+   
+6. User: Uploads image (base64 encoded)
+   ↓ process_image_upload() → upload to Cloudflare → get URL back
+   
+7. Aida: "Image uploaded! You can add more or continue"
+   
+8. User: "OK, generate preview" or "Continue"
+   ↓ get_images_status() → check if images present → OK to generate draft
+   
+9. ✅ Generate draft with images
+   ↓ from draft_preview.py: generate_and_show_preview()
+   
+10. Draft preview shown with:
+    - Title
+    - Description
+    - All details
+    - Images (thumbnails or count)
+    
+11. User: "Publish" / "Edit" / "Discard" / "Add more images"
+"""
+
+
+# ========== TEST ==========
+if __name__ == "__main__":
+    import asyncio
+    
+    async def test():
+        print("\n" + "="*70)
+        print("📸 IMAGE UPLOAD TEST")
+        print("="*70 + "\n")
+        
+        # Simulate a state after field collection
+        state = {
+            "user_id": "user123",
+            "location": "Lagos",
+            "bedrooms": 2,
+            "bathrooms": 1,
+            "price": 50000,
+            "price_type": "monthly",
+            "listing_type": "rent",
+            "currency": "NGN",
+            "amenities": ["wifi", "parking"],
+            "images": [],
+        }
+        
+        # Check images status (should be 0)
+        status = get_images_status(state, "en")
+        print("1️⃣ Before upload:")
+        print(f"   Message: {status['message']}\n")
+        
+        # Ask for image upload
+        ask_msg = ask_for_image_upload("en")
+        print("2️⃣ Ask for image:")
+        print(f"   {ask_msg}\n")
+        
+        # Simulate image upload (this would be real base64 in production)
+        print("3️⃣ User uploads image...")
+        print("   (In real scenario, image would be base64 encoded)\n")
+        
+        # After upload, check status again
+        state["images"] = ["https://imagedelivery.net/abc123/public"]
+        status = get_images_status(state, "en")
+        print("4️⃣ After upload:")
+        print(f"   Has images: {status['has_images']}")
+        print(f"   Count: {status['count']}")
+        print(f"   Can generate draft: {status['can_generate_draft']}")
+        print(f"   Message: {status['message']}\n")
+
+
+asyncio.run(test())

app/ai/modules/post_draft_handler.py

@@ -0,0 +1,498 @@
+# app/ai/modules/post_draft_handler.py - Handle Publish/Edit/Discard
+"""
+Complete post-draft action handling:
+1. Detect user's intent (publish, edit, discard)
+2. Route to correct handler
+3. For edits: Update field -> Regenerate preview
+4. For publish: Save to MongoDB
+5. For discard: Clear and reset
+"""
+
+import json
+from datetime import datetime
+from typing import Dict, Optional
+from openai import AsyncOpenAI
+from structlog import get_logger
+from app.config import settings
+from app.database import get_db
+from bson import ObjectId
+
+logger = get_logger(__name__)
+
+client = AsyncOpenAI(api_key=settings.DEEPSEEK_API_KEY, base_url=settings.DEEPSEEK_BASE_URL)
+
+
+# ========== 1. DETECT POST-DRAFT ACTION ==========
+async def detect_post_draft_action(
+    user_input: str,
+    language: str = "en",
+) -> str:
+    """
+    Use LLM to detect what user wants to do with their draft
+    
+    Returns: "publish" | "edit" | "discard" | "add_image" | "unknown"
+    """
+    
+    prompt = f"""User just saw their property listing preview. They said:
+
+"{user_input}"
+
+What do they want to do? Choose ONE:
+- "publish" - They want to publish/confirm/post the listing
+- "edit" - They want to change/edit something
+- "discard" - They want to cancel/discard/delete the draft
+- "add_image" - They want to add more images
+- "unknown" - Can't tell what they want
+
+Respond with ONLY one word: publish, edit, discard, add_image, or unknown"""
+
+    try:
+        response = await client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.1,
+            max_tokens=50,
+        )
+        
+        action = response.choices[0].message.content.strip().lower()
+        
+        # Validate action
+        valid_actions = ["publish", "edit", "discard", "add_image", "unknown"]
+        if action not in valid_actions:
+            action = "unknown"
+        
+        logger.info(f"🎯 Detected post-draft action", action=action, user_input=user_input[:50])
+        return action
+    
+    except Exception as e:
+        logger.error("❌ Failed to detect action", exc_info=e)
+        return "unknown"
+
+
+# ========== 2. DETECT WHICH FIELD TO EDIT ==========
+async def detect_field_to_edit(
+    user_input: str,
+    available_fields: list = None,
+) -> Optional[str]:
+    """
+    Detect which field user wants to edit
+    
+    Available fields: location, bedrooms, bathrooms, price, amenities, requirements, title, description
+    """
+    
+    if available_fields is None:
+        available_fields = ["location", "bedrooms", "bathrooms", "price", "amenities", "requirements", "title", "description"]
+    
+    prompt = f"""User wants to edit their listing. They said:
+
+"{user_input}"
+
+Which field do they want to change? Choose from:
+{', '.join(available_fields)}
+
+Or respond "unknown" if you can't tell.
+
+Respond with ONLY the field name or "unknown"."""
+
+    try:
+        response = await client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.1,
+            max_tokens=50,
+        )
+        
+        field = response.choices[0].message.content.strip().lower()
+        
+        if field not in available_fields:
+            field = None
+        
+        logger.info(f"✏️ Detected field to edit", field=field)
+        return field
+    
+    except Exception as e:
+        logger.error("❌ Failed to detect field", exc_info=e)
+        return None
+
+
+# ========== 3. EXTRACT NEW VALUE FOR FIELD ==========
+async def extract_new_field_value(
+    user_input: str,
+    field: str,
+) -> Optional[str]:
+    """
+    Extract the new value user provided for the field they're editing
+    """
+    
+    prompt = f"""User is editing the "{field}" field of their property listing. They said:
+
+"{user_input}"
+
+Extract ONLY the new value for the {field} field. 
+- If it's a number (bedrooms, bathrooms, price), extract just the number
+- If it's text (location, amenities, requirements), extract the text
+- If multiple amenities, extract all separated by commas
+
+Respond with ONLY the extracted value, nothing else."""
+
+    try:
+        response = await client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.1,
+            max_tokens=100,
+        )
+        
+        value = response.choices[0].message.content.strip()
+        
+        logger.info(f"✏️ Extracted new value", field=field, value=value[:50])
+        return value if value else None
+    
+    except Exception as e:
+        logger.error("❌ Failed to extract value", exc_info=e)
+        return None
+
+
+# ========== 4. UPDATE DRAFT WITH EDIT ==========
+def update_draft_field(
+    draft: Dict,
+    field: str,
+    new_value: str,
+) -> Dict:
+    """
+    Update a specific field in the draft
+    """
+    
+    old_value = draft.get(field)
+    
+    try:
+        # Parse value based on field type
+        if field in ["bedrooms", "bathrooms"]:
+            # Extract number from string
+            import re
+            match = re.search(r'\d+', new_value)
+            if match:
+                new_value = int(match.group())
+            else:
+                logger.warning(f"⚠️ Could not parse number from {new_value}")
+                return draft
+        
+        elif field == "price":
+            import re
+            match = re.search(r'\d+', new_value)
+            if match:
+                new_value = int(match.group())
+            else:
+                logger.warning(f"⚠️ Could not parse price from {new_value}")
+                return draft
+        
+        elif field == "amenities":
+            # Split by comma and clean
+            new_value = [a.strip().lower() for a in new_value.split(",") if a.strip()]
+        
+        # Update the field
+        draft[field] = new_value
+        draft["updated_at"] = datetime.utcnow().isoformat()
+        
+        logger.info(f"✅ Updated field", field=field, old=old_value, new=new_value)
+        return draft
+    
+    except Exception as e:
+        logger.error(f"❌ Failed to update field", field=field, exc_info=e)
+        return draft
+
+
+# ========== 5. PUBLISH DRAFT TO MONGODB ==========
+async def publish_draft_to_mongodb(
+    draft: Dict,
+    user_id: str,
+) -> Dict:
+    """
+    Save draft to MongoDB as published listing
+    
+    Returns:
+    {
+        "success": bool,
+        "mongo_id": str (if successful),
+        "message": str,
+    }
+    """
+    
+    try:
+        db = await get_db()
+        listings_col = db["listings"]
+        
+        # Prepare document for MongoDB
+        doc = {
+            "owner_id": user_id,
+            "type": draft.get("listing_type", "rent"),
+            "title": draft.get("title", "Property Listing"),
+            "description": draft.get("description", ""),
+            "location": draft.get("location"),
+            "bedrooms": draft.get("bedrooms"),
+            "bathrooms": draft.get("bathrooms"),
+            "price": draft.get("price"),
+            "price_type": draft.get("price_type", "monthly"),
+            "currency": draft.get("currency", "XOF"),
+            "amenities": draft.get("amenities", []),
+            "requirements": draft.get("requirements"),
+            "images": draft.get("images", []),
+            "status": "published",
+            "created_at": datetime.utcnow(),
+            "updated_at": datetime.utcnow(),
+            "views": 0,
+            "favorites": 0,
+        }
+        
+        # Insert into MongoDB
+        result = await listings_col.insert_one(doc)
+        mongo_id = str(result.inserted_id)
+        
+        logger.info("✅ Listing published to MongoDB", mongo_id=mongo_id, title=doc["title"])
+        
+        return {
+            "success": True,
+            "mongo_id": mongo_id,
+            "message": f"✅ Your listing '{doc['title']}' is now live! Renters can see it.",
+        }
+    
+    except Exception as e:
+        logger.error("❌ Failed to publish to MongoDB", exc_info=e)
+        return {
+            "success": False,
+            "mongo_id": None,
+            "message": f"❌ Failed to publish listing: {str(e)}",
+        }
+
+
+# ========== 6. HANDLE EDIT ACTION ==========
+async def handle_edit_action(
+    user_input: str,
+    draft: Dict,
+    language: str = "en",
+) -> Dict:
+    """
+    Handle when user wants to edit a field
+    
+    Returns:
+    {
+        "action": "ask_which_field" | "ask_new_value" | "show_updated_preview",
+        "field": str (if detected),
+        "message": str,
+        "draft": updated draft (if updated),
+    }
+    """
+    
+    # Step 1: Detect which field to edit
+    field = await detect_field_to_edit(user_input)
+    
+    if not field:
+        # Can't detect field, ask user to specify
+        messages = {
+            "en": "Which field would you like to change? (location, bedrooms, bathrooms, price, amenities, requirements, title, description)",
+            "fr": "Quel champ voulez-vous modifier? (location, bedrooms, bathrooms, price, amenities, requirements, title, description)",
+        }
+        
+        return {
+            "action": "ask_which_field",
+            "message": messages.get(language, messages["en"]),
+            "draft": draft,
+        }
+    
+    # Step 2: Extract new value from user input
+    new_value = await extract_new_field_value(user_input, field)
+    
+    if not new_value:
+        # Can't extract value, ask user to provide it
+        messages = {
+            "en": f"What's the new value for {field}?",
+            "fr": f"Quelle est la nouvelle valeur pour {field}?",
+        }
+        
+        return {
+            "action": "ask_new_value",
+            "field": field,
+            "message": messages.get(language, messages["en"]),
+            "draft": draft,
+        }
+    
+    # Step 3: Update draft with new value
+    updated_draft = update_draft_field(draft, field, new_value)
+    
+    # Return updated draft (caller will regenerate preview)
+    messages = {
+        "en": f"✅ Updated {field}! Regenerating preview...",
+        "fr": f"✅ Mis à jour {field}! Régénération de l'aperçu...",
+    }
+    
+    return {
+        "action": "show_updated_preview",
+        "field": field,
+        "message": messages.get(language, messages["en"]),
+        "draft": updated_draft,
+    }
+
+
+# ========== 7. HANDLE DISCARD ACTION ==========
+def handle_discard_action(language: str = "en") -> Dict:
+    """
+    Handle when user wants to discard the draft
+    """
+    
+    messages = {
+        "en": "❌ Your draft has been cleared. What would you like to do next?\n• List another property\n• Search for properties\n• View my listings\n• Chat with an agent",
+        "fr": "❌ Votre brouillon a été effacé. Que voulez-vous faire ensuite?\n• Lister une autre propriété\n• Rechercher des propriétés\n• Voir mes annonces\n• Discuter avec un agent",
+    }
+    
+    logger.info("❌ Draft discarded")
+    
+    return {
+        "action": "discarded",
+        "message": messages.get(language, messages["en"]),
+        "state": {
+            "status": "idle",
+            "draft": None,
+            "images": [],
+        }
+    }
+
+
+# ========== 8. COMPLETE POST-DRAFT HANDLER ==========
+async def handle_post_draft_action(
+    user_input: str,
+    draft: Dict,
+    user_id: str,
+    language: str = "en",
+) -> Dict:
+    """
+    Main handler for post-draft actions
+    
+    Complete flow:
+    1. Detect action (publish/edit/discard/add_image)
+    2. Route to appropriate handler
+    3. Return result
+    """
+    
+    # Detect action
+    action = await detect_post_draft_action(user_input, language)
+    
+    logger.info(f"📋 Handling post-draft action", action=action)
+    
+    # ========== PUBLISH ==========
+    if action == "publish":
+        result = await publish_draft_to_mongodb(draft, user_id)
+        
+        if result["success"]:
+            return {
+                "action": "published",
+                "success": True,
+                "mongo_id": result["mongo_id"],
+                "message": result["message"],
+                "next_state": {
+                    "status": "published",
+                    "draft": draft,
+                    "mongo_id": result["mongo_id"],
+                }
+            }
+        else:
+            return {
+                "action": "publish_error",
+                "success": False,
+                "message": result["message"],
+                "draft": draft,
+            }
+    
+    # ========== EDIT ==========
+    elif action == "edit":
+        result = await handle_edit_action(user_input, draft, language)
+        
+        return {
+            "action": result["action"],
+            "message": result["message"],
+            "field": result.get("field"),
+            "draft": result["draft"],
+        }
+    
+    # ========== DISCARD ==========
+    elif action == "discard":
+        result = handle_discard_action(language)
+        
+        return {
+            "action": result["action"],
+            "message": result["message"],
+            "next_state": result["state"],
+        }
+    
+    # ========== ADD IMAGE ==========
+    elif action == "add_image":
+        messages = {
+            "en": "📸 Ready to upload more images. Please provide the image.",
+            "fr": "📸 Prêt à télécharger plus d'images. Veuillez fournir l'image.",
+        }
+        
+        return {
+            "action": "add_image",
+            "message": messages.get(language, messages["en"]),
+            "draft": draft,
+        }
+    
+    # ========== UNKNOWN ==========
+    else:
+        messages = {
+            "en": "Sorry, I didn't understand. What would you like to do?\n• **Publish** - Post the listing\n• **Edit** - Change something\n• **Add image** - Upload more images\n• **Discard** - Start over",
+            "fr": "Désolé, je n'ai pas compris. Que voulez-vous faire?\n• **Publier** - Publier l'annonce\n• **Éditer** - Modifier quelque chose\n• **Ajouter image** - Télécharger plus d'images\n• **Annuler** - Recommencer",
+        }
+        
+        return {
+            "action": "unclear",
+            "message": messages.get(language, messages["en"]),
+            "draft": draft,
+        }
+
+
+# ========== TEST ==========
+if __name__ == "__main__":
+    import asyncio
+    
+    async def test():
+        print("\n" + "="*70)
+        print("📋 POST-DRAFT HANDLER TEST")
+        print("="*70 + "\n")
+        
+        # Sample draft
+        draft = {
+            "title": "Beautiful 2-Bedroom Apartment in Lagos",
+            "description": "Spacious apartment in Lagos.",
+            "location": "Lagos",
+            "bedrooms": 2,
+            "bathrooms": 1,
+            "price": 50000,
+            "price_type": "monthly",
+            "listing_type": "rent",
+            "currency": "NGN",
+            "amenities": ["wifi", "parking"],
+            "images": ["https://cloudflare.com/img1.jpg"],
+        }
+        
+        # Test 1: Publish
+        print("1️⃣ TEST: User says 'Publish'")
+        result = await handle_post_draft_action("Publish this listing", draft, "user123", "en")
+        print(f"   Action: {result['action']}")
+        print(f"   Message: {result['message']}\n")
+        
+        # Test 2: Edit
+        print("2️⃣ TEST: User says 'Edit the price'")
+        result = await handle_post_draft_action("Change the price to 60k", draft, "user123", "en")
+        print(f"   Action: {result['action']}")
+        print(f"   Field: {result.get('field')}")
+        print(f"   Message: {result['message']}")
+        if result['action'] == 'show_updated_preview':
+            print(f"   New price: {result['draft']['price']}\n")
+        
+        # Test 3: Discard
+        print("3️⃣ TEST: User says 'Discard'")
+        result = await handle_post_draft_action("Cancel this, start over", draft, "user123", "en")
+        print(f"   Action: {result['action']}")
+        print(f"   Message: {result['message']}\n")
+    
+    asyncio.run(test())

app/ai/modules/property_listing.py

@@ -0,0 +1,547 @@
+# app/ai/modules/property_listing.py - Smart Property Listing with ML Integration
+"""
+Smart listing flow with:
+1. Auto-detect listing_type (rent/short-stay/sale/roommate based on price_type)
+2. Auto-detect price_type from keywords
+3. Auto-detect currency from location using ML
+4. Auto-generate title and description
+5. LLM generates dynamic questions instead of hardcoded
+6. User role-based validation (renter can only list roommate)
+"""
+
+import json
+import re
+from typing import Dict, List, Optional, Tuple
+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
+
+logger = get_logger(__name__)
+
+client = AsyncOpenAI(api_key=settings.DEEPSEEK_API_KEY, base_url=settings.DEEPSEEK_BASE_URL)
+ml_extractor = get_ml_extractor()
+
+# ========== REQUIRED FIELDS (only the essentials) ==========
+# price_type and listing_type are auto-detected, not asked!
+REQUIRED_FIELDS = ["location", "bedrooms", "bathrooms", "price"]
+
+
+# ========== 1. GENERATE EXAMPLE ==========
+async def generate_listing_example(language: str) -> str:
+    """
+    Generate a short, detailed example in user's language
+    Shows user what a complete listing looks like
+    """
+    
+    prompt = f"""Generate a SHORT but DETAILED example of how to list a property on Lojiz in {language.upper()}.
+
+The example should include:
+- Number of bedrooms and bathrooms
+- Location (city)
+- Price and frequency (per month, per night, weekly, etc)
+- At least 2-3 amenities (wifi, parking, etc)
+- A requirement or condition
+
+Keep it to 2-3 sentences, natural language. Make it sound like a real user describing their property.
+
+Format: Just the example text itself, no "Example:" prefix, no quotes around it."""
+
+    try:
+        response = await client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.8,
+            max_tokens=200,
+        )
+        
+        example = response.choices[0].message.content.strip()
+        logger.info("📋 Generated listing example", language=language)
+        
+        intro = {
+            "en": "Sure! Here's an example of what you could say:",
+            "fr": "Bien sûr! Voici un exemple de ce que vous pourriez dire:",
+            "es": "¡Claro! Aquí hay un ejemplo de lo que podrías decir:",
+        }
+        
+        return f"{intro.get(language, intro['en'])}\n\n\"{example}\""
+    
+    except Exception as e:
+        logger.error("❌ Failed to generate example", exc_info=e)
+        return "Tell me about your property (location, bedrooms, bathrooms, price, amenities, etc.)"
+
+
+# ========== 2. EXTRACT & AUTO-DETECT FIELDS ==========
+async def extract_and_auto_detect_fields(
+    user_input: str,
+    user_role: str,
+    language: str,
+) -> Dict:
+    """
+    Extract fields AND auto-detect:
+    - listing_type (from price_type keywords and user_role)
+    - price_type (from keywords: monthly, nightly, weekly, daily, yearly)
+    - currency (from location using ML)
+    
+    Returns:
+    {
+        "location": "Lagos",
+        "bedrooms": 2,
+        "bathrooms": 1,
+        "price": 50000,
+        "price_type": "monthly",  # AUTO-DETECTED
+        "listing_type": "rent",   # AUTO-DETECTED
+        "currency": "NGN",         # AUTO-DETECTED from location
+        "amenities": ["wifi", "parking"],
+        "requirements": "1-month deposit",
+    }
+    """
+    
+    # Step 1: Initial extraction
+    prompt = f"""Extract property listing details from this user input (in {language}):
+
+"{user_input}"
+
+Extract and return ONLY valid JSON:
+{{
+  "location": "city name or null",
+  "bedrooms": number or null,
+  "bathrooms": number or null,
+  "price": number or null,
+  "price_type_raw": "raw text mentioning frequency (monthly, per night, weekly, daily, yearly, etc) or null",
+  "listing_type_raw": "raw text that might indicate type (for sale, for rent, short stay, sharing, etc) or null",
+  "amenities": ["list", "of", "amenities"] or [],
+  "requirements": "string or null"
+}}
+
+Rules:
+- Extract ONLY what's explicitly mentioned
+- price_type_raw: capture the exact frequency words (e.g., "per month", "monthly", "nightly", "per night", "daily", "weekly", "yearly")
+- For numbers, extract numeric value only
+- Amenities: list as lowercase strings
+- If a field not mentioned, set to null or []
+
+Return ONLY JSON."""
+
+    try:
+        response = await client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.1,
+            max_tokens=300,
+        )
+        
+        raw = response.choices[0].message.content.strip()
+        raw = re.sub(r'```json\s*|\s*```', '', raw)
+        extracted = json.loads(raw)
+        
+        logger.info("✅ Initial extraction done", extracted=extracted)
+        
+    except Exception as e:
+        logger.error("❌ Extraction failed", exc_info=e)
+        return {}
+    
+    # Step 2: Auto-detect price_type from keywords
+    price_type_raw = extracted.get("price_type_raw", "").lower()
+    price_type = "monthly"  # Default
+    
+    if any(kw in price_type_raw for kw in ["night", "nightly", "per night", "daily", "day", "week", "weekly"]):
+        price_type = "nightly" if any(k in price_type_raw for k in ["night", "nightly"]) else "weekly" if "week" in price_type_raw else "daily"
+    elif any(kw in price_type_raw for kw in ["year", "yearly", "annum", "per year"]):
+        price_type = "yearly"
+    elif any(kw in price_type_raw for kw in ["month", "monthly", "mth", "per month"]):
+        price_type = "monthly"
+    
+    logger.info(f"📍 Auto-detected price_type", price_type_raw=price_type_raw, price_type=price_type)
+    
+    # Step 3: Auto-detect listing_type based on price_type + user_role + keywords
+    listing_type = None
+    
+    # If renter, ALWAYS roommate
+    if user_role == "renter":
+        listing_type = "roommate"
+        logger.info("🏠 User is renter → listing_type: roommate")
+    else:
+        # Landlord: infer from price_type and keywords
+        if price_type in ["nightly", "daily", "weekly"]:
+            listing_type = "short-stay"
+        elif price_type == "yearly" or "for sale" in extracted.get("listing_type_raw", "").lower():
+            listing_type = "sale"
+        else:
+            listing_type = "rent"  # Default for landlord
+        
+        logger.info(f"🏠 User is landlord → listing_type: {listing_type}")
+    
+    # Step 4: Auto-detect currency from location using ML
+    currency = "XOF"  # Default
+    location = extracted.get("location")
+    
+    if location:
+        try:
+            currency, country, city, confidence = await ml_extractor.currency_mgr.get_currency_for_location(location)
+            if not currency:
+                currency = "XOF"
+            logger.info(f"💱 Auto-detected currency", location=location, currency=currency, confidence=confidence)
+        except Exception as e:
+            logger.warning(f"⚠️ Currency detection failed, using default", exc_info=e)
+    
+    # Return complete extracted data
+    result = {
+        "location": extracted.get("location"),
+        "bedrooms": extracted.get("bedrooms"),
+        "bathrooms": extracted.get("bathrooms"),
+        "price": extracted.get("price"),
+        "price_type": price_type,  # ✅ AUTO-DETECTED
+        "listing_type": listing_type,  # ✅ AUTO-DETECTED
+        "currency": currency,  # ✅ AUTO-DETECTED
+        "amenities": extracted.get("amenities", []),
+        "requirements": extracted.get("requirements"),
+    }
+    
+    logger.info("✅ All fields auto-detected", result=result)
+    return result
+
+
+# ========== 3. AUTO-GENERATE TITLE ==========
+async def generate_title(state: Dict) -> str:
+    """
+    Generate a catchy but short title with location
+    
+    Examples:
+    - "Cozy 2-Bed Apartment in Lagos"
+    - "Modern 3-Bed Rental in Cotonou"
+    - "Luxury Penthouse in Abuja"
+    """
+    
+    bedrooms = state.get("bedrooms", "?")
+    location = state.get("location", "Unknown")
+    listing_type = state.get("listing_type", "property")
+    
+    prompt = f"""Generate a SHORT, CATCHY title for a real estate listing.
+
+Details:
+- {bedrooms} bedrooms
+- Located in {location}
+- Type: {listing_type}
+
+Title should be:
+- Under 60 characters
+- Include location
+- Sound professional but friendly
+- One line only
+
+Return ONLY the title, no quotes, no explanation."""
+
+    try:
+        response = await client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.7,
+            max_tokens=100,
+        )
+        
+        title = response.choices[0].message.content.strip()
+        logger.info("✨ Generated title", title=title)
+        return title
+    
+    except Exception as e:
+        logger.error("❌ Title generation failed", exc_info=e)
+        return f"{bedrooms}-Bedroom {listing_type.title()} in {location}"
+
+
+# ========== 4. AUTO-GENERATE DESCRIPTION ==========
+async def generate_description(state: Dict) -> str:
+    """
+    Generate a detailed, well-written description
+    
+    Should include:
+    - Number of bedrooms/bathrooms
+    - Location
+    - Key amenities
+    - Price info
+    - Requirements if any
+    """
+    
+    bedrooms = state.get("bedrooms", "?")
+    bathrooms = state.get("bathrooms", "?")
+    location = state.get("location", "Unknown")
+    price = state.get("price", "?")
+    price_type = state.get("price_type", "monthly")
+    amenities = ", ".join(state.get("amenities", []))
+    requirements = state.get("requirements", "")
+    listing_type = state.get("listing_type", "property")
+    currency = state.get("currency", "")
+    
+    amenities_text = f"Amenities include {amenities}." if amenities else ""
+    requirements_text = f"Requirements: {requirements}" if requirements else ""
+    
+    prompt = f"""Write a professional, detailed description for a real estate listing.
+
+Property Details:
+- Bedrooms: {bedrooms}
+- Bathrooms: {bathrooms}
+- Location: {location}
+- Price: {price} {price_type} ({currency})
+- Type: {listing_type}
+- Amenities: {amenities_text}
+- {requirements_text}
+
+Write 3-4 sentences that:
+- Sound professional but welcoming
+- Highlight the property's appeal
+- Include all key details
+- Are clear and easy to read
+
+Return ONLY the description, no quotes."""
+
+    try:
+        response = await client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.7,
+            max_tokens=300,
+        )
+        
+        description = response.choices[0].message.content.strip()
+        logger.info("📝 Generated description", length=len(description))
+        return description
+    
+    except Exception as e:
+        logger.error("❌ Description generation failed", exc_info=e)
+        return f"Beautiful {bedrooms}-bedroom {listing_type} in {location}. Perfect for families or professionals."
+
+
+# ========== 5. GENERATE SMART QUESTION ==========
+async def generate_smart_question(
+    missing_field: str,
+    language: str,
+    context: Optional[str] = None,
+) -> str:
+    """
+    LLM generates a natural question for missing field
+    NOT hardcoded - AI decides how to ask
+    """
+    
+    prompt = f"""You are Aida, a friendly real estate assistant.
+
+Generate a NATURAL, FRIENDLY question to ask the user about a missing property detail.
+
+Missing field: {missing_field}
+Language: {language}
+Context: {context or "General property listing"}
+
+The question should:
+- Be SHORT and DIRECT (one sentence)
+- Sound conversational, not robotic
+- Be in {language}
+- NOT have a prefix like "User:" or "Question:"
+
+Return ONLY the question, nothing else."""
+
+    try:
+        response = await client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.7,
+            max_tokens=100,
+        )
+        
+        question = response.choices[0].message.content.strip()
+        logger.info("❓ Generated smart question", field=missing_field, question=question)
+        return question
+    
+    except Exception as e:
+        logger.error("❌ Question generation failed", exc_info=e)
+        return f"What is the {missing_field}?"
+
+
+# ========== 6. FIND MISSING FIELDS ==========
+def find_missing_fields(state: Dict) -> List[str]:
+    """Find which required fields are missing"""
+    missing = [f for f in REQUIRED_FIELDS if not state.get(f)]
+    logger.info("📋 Missing fields", missing=missing)
+    return missing
+
+
+# ========== 7. BUILD LISTING STATE ==========
+async def build_listing_state(
+    user_id: str,
+    user_role: str,
+    language: str,
+    user_input: Optional[str] = None,
+    current_state: Optional[Dict] = None,
+) -> Dict:
+    """
+    Build or update listing state with auto-detection
+    """
+    
+    # Start with current state or empty
+    state = current_state.copy() if current_state else {}
+    
+    # If user provided input, extract and auto-detect fields
+    if user_input:
+        extracted = await extract_and_auto_detect_fields(
+            user_input=user_input,
+            user_role=user_role,
+            language=language,
+        )
+        
+        # Merge extracted fields into state (only update non-null values)
+        for field, value in extracted.items():
+            if value is not None and value != [] and value != "":
+                state[field] = value
+    
+    # Find missing required fields
+    missing_fields = find_missing_fields(state)
+    
+    # Prepare state dict
+    listing_state = {
+        "user_id": user_id,
+        "user_role": user_role,
+        "language": language,
+        "status": "collecting",
+        "provided_fields": {k: v for k, v in state.items() if k in REQUIRED_FIELDS},
+        "missing_fields": missing_fields,
+        "amenities": state.get("amenities", []),
+        "requirements": state.get("requirements"),
+        "raw_state": state,
+    }
+    
+    return listing_state
+
+
+# ========== 8. COMPLETE LISTING FLOW ==========
+async def start_listing(
+    user_id: str,
+    user_role: str,
+    language: str,
+) -> Dict:
+    """Start listing - show example and wait for input"""
+    
+    example = await generate_listing_example(language)
+    
+    logger.info("🏠 Started listing flow", user_id=user_id, user_role=user_role)
+    
+    return {
+        "action": "show_example_and_wait",
+        "example": example,
+        "state": {
+            "user_id": user_id,
+            "user_role": user_role,
+            "language": language,
+            "status": "awaiting_initial_input",
+            "provided_fields": {},
+            "missing_fields": REQUIRED_FIELDS.copy(),
+        }
+    }
+
+
+async def continue_listing(
+    user_input: str,
+    current_state: Dict,
+) -> Dict:
+    """
+    User provided input - extract fields and ask for missing ones
+    """
+    
+    user_id = current_state.get("user_id")
+    user_role = current_state.get("user_role")
+    language = current_state.get("language", "en")
+    
+    # Build updated state
+    updated_state = await build_listing_state(
+        user_id=user_id,
+        user_role=user_role,
+        language=language,
+        user_input=user_input,
+        current_state=current_state.get("raw_state", {}),
+    )
+    
+    missing_fields = updated_state["missing_fields"]
+    
+    if missing_fields:
+        # Generate smart question for next field
+        next_field = missing_fields[0]
+        question = await generate_smart_question(next_field, language)
+        
+        logger.info("📝 Generated smart question", field=next_field)
+        
+        return {
+            "action": "ask_next_field",
+            "question": question,
+            "state": updated_state,
+        }
+    else:
+        # All required fields complete - ask about optional fields
+        optional_msg = await generate_smart_question("amenities and requirements", language, "Optional property details")
+        
+        logger.info("✅ All required fields collected")
+        
+        return {
+            "action": "ask_optional_fields",
+            "message": optional_msg,
+            "state": updated_state,
+        }
+
+
+async def generate_draft(current_state: Dict) -> Dict:
+    """
+    All fields collected - generate title, description, and draft preview
+    """
+    
+    state = current_state.get("raw_state", {})
+    
+    # Generate title and description
+    title = await generate_title(state)
+    description = await generate_description(state)
+    
+    draft = {
+        **state,
+        "title": title,
+        "description": description,
+        "status": "draft",
+    }
+    
+    logger.info("🎉 Draft generated", title=title[:50])
+    
+    return {
+        "action": "show_draft_preview",
+        "draft": draft,
+        "state": {**current_state, "draft": draft}
+    }
+
+
+# ========== TEST ==========
+if __name__ == "__main__":
+    import asyncio
+    
+    async def test():
+        print("\n" + "="*70)
+        print("🧪 SMART PROPERTY LISTING TEST")
+        print("="*70 + "\n")
+        
+        # Test 1: Start listing
+        print("📍 TEST 1: Start listing")
+        result1 = await start_listing(user_id="user123", user_role="landlord", language="en")
+        print(f"✅ Example:\n{result1['example']}\n")
+        
+        # Test 2: User provides input
+        print("📍 TEST 2: User provides property details")
+        user_input = "I have a 2-bed, 1-bath apartment in Lagos for 50k monthly with wifi and parking"
+        result2 = await continue_listing(
+            user_input=user_input,
+            current_state=result1["state"]
+        )
+        print(f"✅ Action: {result2['action']}")
+        print(f"✅ State: {result2['state']['provided_fields']}")
+        print(f"✅ Missing: {result2['state']['missing_fields']}")
+        print(f"✅ Question: {result2['question']}\n")
+        
+        # Test 3: Generate draft
+        print("📍 TEST 3: Generate draft")
+        result2['state']['raw_state']['location'] = 'Lagos'  # Assuming extracted
+        result3 = await generate_draft(result2["state"])
+        print(f"✅ Draft Title: {result3['draft']['title']}")
+        print(f"✅ Draft Description: {result3['draft']['description']}\n")
+    
+    asyncio.run(test())

app/ai/nodes/discard_node.py

@@ -1,19 +0,0 @@
-# app/ai/nodes/discard_node.py – CLEAR DRAFT AND RESET
-from typing import Dict
-from structlog import get_logger
-
-logger = get_logger(__name__)
-
-async def discard_node(state: Dict) -> Dict:
-    # wipe listing-specific data
-    for key in ["draft", "draft_preview", "location", "bedrooms", "bathrooms",
-                "price", "listing_type", "price_type", "amenities", "requirements",
-                "missing_fields", "editing_field"]:
-        state.pop(key, None)
-        
-    state.update({
-        "status":   "discarded",
-        "ai_reply": "Brouillon supprimé. Que souhaitez-vous faire ensuite ?",
-    })
-    logger.info("🗑️ Draft discarded")
-    return state

app/ai/nodes/draft_node.py

@@ -1,275 +0,0 @@
-# app/ai/nodes/draft_node.py - COMPLETE WORKING VERSION
-import re
-from typing import Dict, List
-from structlog import get_logger
-
-logger = get_logger(__name__)
-
-# ============================================
-# AMENITY ICONS
-# ============================================
-AMENITY_ICONS = {
-    "wifi": "📶", "parking": "🅿️", "furnished": "🛋️", "washing machine": "🧼",
-    "washing": "🧼", "dryer": "🔥", "balcony": "🏖️", "pool": "🏊", "gym": "💪",
-    "garden": "🌿", "air conditioning": "❄️", "ac": "❄️", "kitchen": "🍳",
-    "security": "🔒", "elevator": "🛗", "laundry": "🧺", "heating": "🔥", "hot water": "🚿",
-}
-
-
-def add_amenity_icons(amenities: List[str]) -> str:
-    """Convert amenity list to emoji format"""
-    if not amenities:
-        return ""
-    
-    icons_text = []
-    for amenity in amenities:
-        amenity_lower = amenity.lower().strip()
-        icon = AMENITY_ICONS.get(amenity_lower, "✓")
-        icons_text.append(f"{icon} {amenity}")
-    
-    return " | ".join(icons_text)
-
-
-def generate_title(state: Dict) -> str:
-    """Generate professional title"""
-    bedrooms = state.get("bedrooms", "N/A")
-    location = state.get("location", "N/A").title()
-    listing_type = state.get("listing_type", "rental").title()
-    return f"{bedrooms}-Bedroom {listing_type} in {location}"
-
-
-def generate_description(state: Dict) -> str:
-    """Generate professional listing description"""
-    bedrooms = state.get("bedrooms")
-    bathrooms = state.get("bathrooms")
-    location = state.get("location", "").title()
-    price = state.get("price", 0)
-    price_type = state.get("price_type", "monthly")
-    currency = state.get("currency", "XOF")
-    amenities = state.get("amenities", [])
-    requirements = state.get("requirements")
-    
-    parts = []
-    parts.append(f"Spacious {bedrooms}-bedroom, {bathrooms}-bathroom property in {location}.")
-    
-    if amenities:
-        amenities_str = ", ".join(amenities)
-        parts.append(f"Features include: {amenities_str}.")
-    
-    parts.append(f"Price: {price:,.0f} {currency} per {price_type}.")
-    
-    if requirements:
-        if "deposit" in requirements.lower() or "require" in requirements.lower():
-            parts.append("Special requirements apply.")
-    
-    return " ".join(parts)
-
-
-async def draft_node(state: Dict) -> Dict:
-    """Process draft creation, preview, edits, and actions"""
-    
-    current_status = state.get("status", "greeting")
-    logger.info(f"📄 Draft Node", status=current_status)
-    
-    # ===== COLLECTING / CHECKING_OPTIONAL =====
-    if current_status in ["collecting", "checking_optional"]:
-        from app.ai.nodes.intent_node import extract_amenities, get_missing_fields
-        
-        new_amenities = extract_amenities(state["messages"][-1]["content"])
-        if new_amenities:
-            state["amenities"] = list(set(state.get("amenities", []) + new_amenities))
-        
-        user_msg = state["messages"][-1]["content"].lower()
-        if any(w in user_msg for w in ["require", "deposit", "condition", "no ", "must"]):
-            state["requirements"] = state["messages"][-1]["content"]
-        
-        missing = get_missing_fields(state)
-        state["missing_fields"] = missing
-        
-        if not missing and current_status == "checking_optional":
-            state["status"] = "draft_ready"
-        
-        return state
-    
-    # ===== GENERATE DRAFT PREVIEW =====
-    if current_status == "draft_ready":
-        logger.info("📄 Generating draft preview")
-        
-        title = generate_title(state)
-        description = generate_description(state)
-        amenities_with_icons = add_amenity_icons(state.get("amenities", []))
-        
-        draft_preview = {
-            "title": title,
-            "description": description,
-            "location": state.get("location"),
-            "bedrooms": state.get("bedrooms"),
-            "bathrooms": state.get("bathrooms"),
-            "price": state.get("price"),
-            "price_type": state.get("price_type"),
-            "currency": state.get("currency", "XOF"),
-            "listing_type": state.get("listing_type"),
-            "amenities": state.get("amenities", []),
-            "amenities_with_icons": amenities_with_icons,
-            "requirements": state.get("requirements"),
-            "images": state.get("image_urls", []),
-        }
-        
-        state["draft_preview"] = draft_preview
-        
-        images_section = f"📷 {len(draft_preview['images'])} images" if draft_preview['images'] else "📷 No images"
-        
-        preview_text = f"""
-┌────────────────────────────────────────────────────────────────┐
-🏠 {draft_preview['title']}
-└───────────────────────────────────────────��────────────────────┘
-
-📍 Location: {draft_preview['location']}
-🛏️ Bedrooms: {draft_preview['bedrooms']}
-🚿 Bathrooms: {draft_preview['bathrooms']}
-💰 Price: {draft_preview['price']:,.0f} {draft_preview['currency']} per {draft_preview['price_type']}
-
-{draft_preview['description']}
-
-✨ Amenities: {draft_preview['amenities_with_icons'] if draft_preview['amenities_with_icons'] else 'None specified'}
-{images_section}
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Ready? Say 'publish' to make it live, 'edit' to change, or 'discard' to start over.
-"""
-        
-        state["status"] = "preview_shown"
-        state["ai_reply"] = preview_text
-        logger.info("✅ Preview generated")
-    
-    # ===== PREVIEW SHOWN - WAITING FOR ACTION =====
-    elif current_status == "preview_shown":
-        from app.ai.nodes.intent_node import translate_to_language
-        
-        last_msg = state["messages"][-1]["content"].lower()
-        
-        if any(k in last_msg for k in ["publish", "publier", "go live", "post", "confirm", "yes", "ok", "okay"]):
-            state["status"] = "publishing"
-            publish_msg = "Publishing your listing..."
-            state["ai_reply"] = await translate_to_language(publish_msg, state.get("user_language", "English"))
-            logger.info("📤 Publishing triggered")
-            return state
-        
-        if any(k in last_msg for k in ["edit", "change", "modifier", "update", "correction", "fix"]):
-            state["status"] = "editing"
-            edit_msg = "What would you like to change? (e.g., price, bedrooms, location, amenities)"
-            state["ai_reply"] = await translate_to_language(edit_msg, state.get("user_language", "English"))
-            logger.info("✏️ Edit mode triggered")
-            return state
-        
-        if any(k in last_msg for k in ["discard", "delete", "cancel", "annuler", "remove", "start over"]):
-            state["status"] = "discarded"
-            for key in ["location", "bedrooms", "bathrooms", "price", "listing_type", "price_type", "amenities", "requirements", "draft_preview", "image_urls"]:
-                state.pop(key, None)
-            discard_msg = "✅ Draft cleared. What would you like to do next?"
-            state["ai_reply"] = await translate_to_language(discard_msg, state.get("user_language", "English"))
-            logger.info("🗑️ Draft discarded")
-            return state
-        
-        state["ai_reply"] = "You can say 'publish' to list it, 'edit' to change something, or 'discard' to start over."
-    
-    # ===== EDITING =====
-    elif current_status == "editing":
-        from app.ai.nodes.intent_node import extract_number, extract_location
-        
-        last_msg = state["messages"][-1]["content"]
-        
-        if "price" in last_msg.lower():
-            new_price = extract_number(last_msg)
-            if new_price:
-                state["price"] = new_price
-                state["ai_reply"] = f"✅ Price updated to {new_price:,.0f}! Here's the updated preview:"
-        
-        elif "bedroom" in last_msg.lower() or "bed" in last_msg.lower():
-            nums = re.findall(r'(\d+)', last_msg)
-            if nums:
-                state["bedrooms"] = int(nums[0])
-                state["ai_reply"] = f"✅ Bedrooms updated to {nums[0]}! Here's the updated preview:"
-        
-        elif "bathroom" in last_msg.lower() or "bath" in last_msg.lower():
-            nums = re.findall(r'(\d+)', last_msg)
-            if nums:
-                state["bathrooms"] = int(nums[0])
-                state["ai_reply"] = f"✅ Bathrooms updated to {nums[0]}! Here's the updated preview:"
-        
-        elif "location" in last_msg.lower() or "city" in last_msg.lower():
-            new_location = extract_location(last_msg)
-            if new_location:
-                state["location"] = new_location
-                try:
-                    from app.ml.models.ml_listing_extractor import get_ml_extractor
-                    ml = get_ml_extractor()
-                    currency, country, city, conf = await ml.infer_currency(state)
-                    if currency:
-                        state["currency"] = currency
-                except:
-                    pass
-                state["ai_reply"] = f"✅ Location updated to {new_location}! Here's the updated preview:"
-        
-        elif "amenities" in last_msg.lower():
-            from app.ai.nodes.intent_node import extract_amenities
-            new_amenities = extract_amenities(last_msg)
-            if new_amenities:
-                state["amenities"] = list(set(state.get("amenities", []) + new_amenities))
-                state["ai_reply"] = f"✅ Amenities updated! Here's the updated preview:"
-        
-        else:
-            state["ai_reply"] = "I didn't understand. Please say 'price', 'location', 'bedrooms', 'bathrooms', or 'amenities' and the new value."
-            return state
-        
-        # Regenerate preview
-        title = generate_title(state)
-        description = generate_description(state)
-        amenities_with_icons = add_amenity_icons(state.get("amenities", []))
-        
-        draft_preview = {
-            "title": title,
-            "description": description,
-            "location": state.get("location"),
-            "bedrooms": state.get("bedrooms"),
-            "bathrooms": state.get("bathrooms"),
-            "price": state.get("price"),
-            "price_type": state.get("price_type"),
-            "currency": state.get("currency", "XOF"),
-            "listing_type": state.get("listing_type"),
-            "amenities": state.get("amenities", []),
-            "amenities_with_icons": amenities_with_icons,
-            "requirements": state.get("requirements"),
-            "images": state.get("image_urls", []),
-        }
-        
-        state["draft_preview"] = draft_preview
-        
-        images_section = f"📷 {len(draft_preview['images'])} images" if draft_preview['images'] else "📷 No images"
-        
-        preview_text = f"""
-┌────────────────────────────────────────────────────────────────┐
-🏠 {draft_preview['title']}
-└────────────────────────────────────────────────────────────────┘
-
-📍 Location: {draft_preview['location']}
-🛏️ Bedrooms: {draft_preview['bedrooms']}
-🚿 Bathrooms: {draft_preview['bathrooms']}
-💰 Price: {draft_preview['price']:,.0f} {draft_preview['currency']} per {draft_preview['price_type']}
-
-{draft_preview['description']}
-
-✨ Amenities: {draft_preview['amenities_with_icons'] if draft_preview['amenities_with_icons'] else 'None specified'}
-{images_section}
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Ready? Say 'publish' or 'edit' again, or 'discard'.
-"""
-        
-        state["status"] = "preview_shown"
-        state["ai_reply"] = preview_text
-        logger.info("🔄 Preview regenerated")
-    
-    return state

app/ai/nodes/edit_node.py

@@ -1,36 +0,0 @@
-# app/ai/nodes/edit_node.py – HANDLE USER EDIT REQUESTS
-from typing import Dict
-from structlog import get_logger
-
-logger = get_logger(__name__)
-
-_KEYWORDS_MAP = {
-    "location":   {"location", "where", "lieu", "emplacement", "adresse"},
-    "price":      {"price", "prix", "cost", "coût", "loyer"},
-    "bedrooms":   {"bedroom", "chambre", "piece", "pièce"},
-    "bathrooms":  {"bathroom", "salle de bain", "toilet", "douche"},
-    "amenities":  {"amenity", "equipment", "équipement", "wifi", "parking"},
-    "requirements": {"requirement", "condition", "exigence"},
-}
-
-def _detect_field_to_edit(text: str) -> str | None:
-    txt = text.lower()
-    for field, keys in _KEYWORDS_MAP.items():
-        if any(k in txt for k in keys):
-            return field
-    return None
-
-async def edit_node(state: Dict) -> Dict:
-    last = state["messages"][-1]["content"]
-    field = _detect_field_to_edit(last)
-
-    if field:
-        state["editing_field"] = field
-        state["status"]        = "editing"
-        state["ai_reply"]      = f"Quelle est la nouvelle valeur pour **{field}** ?"
-    else:
-        state["status"]   = "editing"
-        state["ai_reply"] = "Quel champ souhaitez-vous modifier ? (par ex. 'price', 'location', etc.)"
-        
-    logger.info("✏️ Draft edit requested", field=field)
-    return state

app/ai/nodes/image_node.py

@@ -1,63 +0,0 @@
-# app/ai/nodes/image_node.py
-import base64
-import mimetypes
-from typing import Dict
-import httpx
-from app.config import settings
-from structlog import get_logger
-
-logger = get_logger(__name__)
-CF_UPLOAD_URL = f"https://api.cloudflare.com/client/v4/accounts/{settings.CF_ACCOUNT_ID}/images/v1"
-
-async def image_node(state: Dict) -> Dict:
-    """
-    LangGraph node:
-    - expects state["image"] = {"mime": "image/jpeg", "data": "<base64>"}
-    - uploads to Cloudflare Images -> public URL
-    - appends URL to draft.images[]
-    - replies with confirmation
-    """
-    image = state.get("image")
-    if not image:
-        return state
-
-    mime_type = image["mime"]
-    base64_data = image["data"]
-    ext = mimetypes.guess_extension(mime_type) or ".jpg"
-    filename = f"upload{ext}"
-
-    try:
-        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."
-        return state
-
-    headers = {"Authorization": f"Bearer {settings.CF_API_TOKEN}"}
-    files = {"file": (filename, binary, mime_type)}
-
-    async with httpx.AsyncClient() as client:
-        try:
-            resp = await client.post(CF_UPLOAD_URL, files=files, headers=headers, timeout=30)
-            resp.raise_for_status()
-            data = resp.json()
-            if not data.get("success"):
-                raise ValueError(data.get("errors"))
-            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."
-            return state
-
-    # append URL to draft
-    draft = state.get("draft")
-    if draft:
-        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}"
-    else:
-        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,423 +0,0 @@
-# app/ai/nodes/intent_node.py - COMPLETE WORKING VERSION
-import json
-import re
-import os
-from typing import Dict, List, Optional
-from tenacity import retry, stop_after_attempt, wait_exponential
-from openai import AsyncOpenAI
-from structlog import get_logger
-from app.config import settings
-
-logger = get_logger(__name__)
-
-# ============================================
-# DeepSeek Configuration
-# ============================================
-MODEL = "deepseek-chat"
-MAX_TOKENS = 1000
-TEMP = 0
-
-client = AsyncOpenAI(
-    api_key=settings.DEEPSEEK_API_KEY,
-    base_url=settings.DEEPSEEK_BASE_URL,
-)
-
-# ============================================
-# ML EXTRACTOR - Robust extraction
-# ============================================
-try:
-    from app.ml.models.ml_listing_extractor import get_ml_extractor
-    ml_extractor = get_ml_extractor()
-    ML_AVAILABLE = True
-    logger.info("✅ ML Extractor available")
-except Exception as e:
-    ml_extractor = None
-    ML_AVAILABLE = False
-    logger.warning(f"⚠️ ML Extractor not available: {e}")
-
-
-# ============================================
-# LANGUAGE DETECTION - Using LLM
-# ============================================
-async def detect_language_with_llm(text: str) -> str:
-    """Detect user's language using DeepSeek LLM"""
-    try:
-        response = await client.chat.completions.create(
-            model=MODEL,
-            messages=[
-                {
-                    "role": "user",
-                    "content": f"What language is this text written in? Reply with ONLY the language name:\n\n{text[:200]}"
-                }
-            ],
-            temperature=0,
-            max_tokens=20,
-        )
-        language = response.choices[0].message.content.strip()
-        logger.info(f"🌍 Language detected: {language}")
-        return language
-    except Exception as e:
-        logger.warning(f"⚠️ Language detection failed: {e}")
-        return "English"
-
-
-# ============================================
-# TRANSLATE TEXT - Using LLM
-# ============================================
-async def translate_to_language(text: str, language: str) -> str:
-    """Translate text to user's language"""
-    if language.lower() == "english":
-        return text
-    
-    try:
-        response = await client.chat.completions.create(
-            model=MODEL,
-            messages=[
-                {
-                    "role": "user",
-                    "content": f"Translate this to {language} language. Reply with ONLY the translation:\n\n{text}"
-                }
-            ],
-            temperature=0,
-            max_tokens=300,
-        )
-        return response.choices[0].message.content.strip()
-    except Exception as e:
-        logger.warning(f"⚠️ Translation failed: {e}")
-        return text
-
-
-# ============================================
-# GENERATE EXAMPLE - Using LLM
-# ============================================
-async def generate_listing_example(language: str) -> str:
-    """Generate property listing example in user's language"""
-    try:
-        response = await client.chat.completions.create(
-            model=MODEL,
-            messages=[
-                {
-                    "role": "user",
-                    "content": f"""Generate a helpful property listing example in {language} language.
-
-Show them an example of what they could say when listing a property.
-Include: bedrooms, bathrooms, location, price, amenities, and requirements.
-Make it friendly and realistic.
-End with: "Tell me about your property! 🏠"
-
-Start with: "📝 Here's how to list a property:"
-"""
-                }
-            ],
-            temperature=0.3,
-            max_tokens=400,
-        )
-        return response.choices[0].message.content.strip()
-    except Exception as e:
-        logger.warning(f"⚠️ Example generation failed: {e}")
-        return f"📝 Tell me about the property you want to list!"
-
-
-# ============================================
-# FIELD EXTRACTION HELPERS
-# ============================================
-def detect_listing_type(text: str) -> Optional[str]:
-    """Auto-detect listing type"""
-    text_lower = text.lower()
-    if any(w in text_lower for w in ["short stay", "airbnb", "nightly", "daily", "weekly"]):
-        return "short-stay"
-    elif any(w in text_lower for w in ["sale", "sell", "selling", "for sale", "vendre"]):
-        return "sale"
-    elif any(w in text_lower for w in ["roommate", "sharing", "flatmate", "colocataire"]):
-        return "roommate"
-    else:
-        return "rent"
-
-
-def detect_price_type(text: str) -> Optional[str]:
-    """Auto-detect price type"""
-    text_lower = text.lower()
-    if any(w in text_lower for w in ["nightly", "night", "daily", "day", "par nuit"]):
-        return "nightly"
-    elif any(w in text_lower for w in ["yearly", "year", "annually", "par an"]):
-        return "yearly"
-    else:
-        return "monthly"
-
-
-def extract_number(text: str) -> Optional[float]:
-    """Extract first number from text"""
-    cleaned = re.sub(r'[^\d.,-]', '', text)
-    match = re.search(r'[\d,.]+', cleaned)
-    if match:
-        num_str = match.group().replace(',', '')
-        try:
-            return float(num_str)
-        except:
-            return None
-    return None
-
-
-def extract_location(text: str) -> Optional[str]:
-    """Extract location (city name)"""
-    cities = {
-        "lagos": "lagos", "cotonou": "cotonou", "calavi": "calavi",
-        "paris": "paris", "london": "london", "lyon": "lyon",
-        "marseille": "marseille", "nairobi": "nairobi", "accra": "accra",
-        "johannesburg": "johannesburg", "kinshasa": "kinshasa", "dakar": "dakar",
-        "kampala": "kampala", "cape town": "cape town", "madrid": "madrid",
-        "barcelona": "barcelona", "lisbon": "lisbon",
-    }
-    
-    text_lower = text.lower()
-    for city_key, city_val in cities.items():
-        if city_key in text_lower:
-            return city_val
-    return None
-
-
-def extract_amenities(text: str) -> List[str]:
-    """Extract amenities from text"""
-    amenities_list = [
-        "wifi", "parking", "furnished", "washing machine", "dryer",
-        "balcony", "pool", "gym", "garden", "air conditioning", "kitchen",
-        "ac", "washer", "elevator", "security", "laundry", "heating", "hot water"
-    ]
-    
-    found_amenities = []
-    text_lower = text.lower()
-    
-    for amenity in amenities_list:
-        if amenity in text_lower:
-            if amenity == "ac":
-                found_amenities.append("air conditioning")
-            elif amenity == "washer":
-                found_amenities.append("washing machine")
-            else:
-                found_amenities.append(amenity)
-    
-    return list(set(found_amenities))
-
-
-# ============================================
-# REQUIRED FIELDS CHECK
-# ============================================
-def get_missing_fields(state: Dict) -> List[str]:
-    """Check which required fields are missing"""
-    required = ["location", "bedrooms", "bathrooms", "price", "listing_type", "price_type"]
-    missing = []
-    
-    for field in required:
-        value = state.get(field)
-        if value is None or (isinstance(value, str) and value.strip() == ""):
-            missing.append(field)
-    
-    return missing
-
-
-def get_next_question_en(missing_fields: List[str]) -> Optional[str]:
-    """Get next question in English"""
-    if not missing_fields:
-        return None
-    
-    questions = {
-        "location": "What city/area is the property in?",
-        "bedrooms": "How many bedrooms does it have?",
-        "bathrooms": "How many bathrooms?",
-        "price": "What's the price?",
-        "listing_type": "Is it for rent, short-stay, sale, or roommate?",
-        "price_type": "Is that monthly, nightly, or yearly?",
-    }
-    
-    return questions.get(missing_fields[0], "Tell me more about the property")
-
-
-# ============================================
-# MAIN INTENT NODE
-# ============================================
-@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=1, max=5))
-async def intent_node(state: Dict) -> Dict:
-    """Main intent detection & extraction node"""
-    
-    user_id = state.get("user_id", "unknown")
-    human_msg = state["messages"][-1]["content"]
-    
-    logger.info(f"🤖 Intent Node", user_id=user_id, msg=human_msg[:80])
-    
-    # ===== DETECT LANGUAGE =====
-    if "user_language" not in state:
-        state["user_language"] = await detect_language_with_llm(human_msg)
-    
-    language = state["user_language"]
-    logger.info(f"🌍 Language: {language}")
-    
-    # ===== DETERMINE INTENT =====
-    last_msg_lower = human_msg.lower().strip()
-    
-    if any(k in last_msg_lower for k in ["list", "publish", "create", "post", "sell", "rent out", "louer", "vendre"]):
-        intent = "list"
-    elif any(k in last_msg_lower for k in ["search", "find", "show", "look", "browse", "apartments", "houses"]):
-        intent = "search"
-    elif any(k in last_msg_lower for k in ["my listings", "my properties", "my apartments", "mes annonces"]):
-        intent = "my_listings"
-    else:
-        intent = "greeting"
-    
-    logger.info(f"📍 Intent: {intent}")
-    
-    # ===== LIST INTENT =====
-    if intent == "list":
-        state["intent"] = "list"
-        state["allowed"] = True
-        
-        # First time - show example
-        is_first_list = not state.get("location") and not state.get("bedrooms")
-        
-        if is_first_list:
-            example_msg = await generate_listing_example(language)
-            state["status"] = "collecting"
-            state["ai_reply"] = example_msg
-            logger.info("📝 Showing example")
-            return state
-        
-        # Extract fields using ML
-        if ML_AVAILABLE and ml_extractor:
-            try:
-                location = extract_location(human_msg)
-                if location:
-                    state["location"] = location
-                
-                bedrooms_match = re.search(r'(\d+)\s*(?:bed|bedroom|chambre)', human_msg.lower())
-                if bedrooms_match:
-                    state["bedrooms"] = int(bedrooms_match.group(1))
-                
-                bathrooms_match = re.search(r'(\d+)\s*(?:bath|bathroom|salle de bain)', human_msg.lower())
-                if bathrooms_match:
-                    state["bathrooms"] = int(bathrooms_match.group(1))
-                
-                price = extract_number(human_msg)
-                if price and price > 0:
-                    state["price"] = float(price)
-                
-                state["listing_type"] = detect_listing_type(human_msg)
-                state["price_type"] = detect_price_type(human_msg)
-                
-                amenities = extract_amenities(human_msg)
-                if amenities:
-                    state["amenities"] = list(set(state.get("amenities", []) + amenities))
-                
-                if any(w in human_msg.lower() for w in ["require", "deposit", "condition", "need"]):
-                    state["requirements"] = human_msg
-                
-                # Infer currency
-                if state.get("location") and not state.get("currency"):
-                    try:
-                        currency, country, city, conf = await ml_extractor.infer_currency(state)
-                        if currency:
-                            state["currency"] = currency
-                    except:
-                        state["currency"] = "XOF"
-                
-            except Exception as e:
-                logger.warning(f"⚠️ ML extraction error: {e}")
-                location = extract_location(human_msg)
-                if location:
-                    state["location"] = location
-                bedrooms = extract_number(human_msg)
-                if bedrooms and bedrooms <= 20:
-                    state["bedrooms"] = int(bedrooms)
-                price = extract_number(human_msg)
-                if price and price > 0:
-                    state["price"] = float(price)
-                state["listing_type"] = detect_listing_type(human_msg)
-                state["price_type"] = detect_price_type(human_msg)
-                amenities = extract_amenities(human_msg)
-                if amenities:
-                    state["amenities"] = list(set(state.get("amenities", []) + amenities))
-                state["currency"] = "XOF"
-        else:
-            location = extract_location(human_msg)
-            if location:
-                state["location"] = location
-            bedrooms = extract_number(human_msg)
-            if bedrooms and bedrooms <= 20:
-                state["bedrooms"] = int(bedrooms)
-            price = extract_number(human_msg)
-            if price and price > 0:
-                state["price"] = float(price)
-            state["listing_type"] = detect_listing_type(human_msg)
-            state["price_type"] = detect_price_type(human_msg)
-            amenities = extract_amenities(human_msg)
-            if amenities:
-                state["amenities"] = list(set(state.get("amenities", []) + amenities))
-            state["currency"] = "XOF"
-        
-        # Check missing fields
-        missing = get_missing_fields(state)
-        state["missing_fields"] = missing
-        
-        if missing:
-            state["status"] = "collecting"
-            question_en = get_next_question_en(missing)
-            state["next_question"] = question_en
-            state["ai_reply"] = await translate_to_language(question_en, language)
-        else:
-            state["status"] = "checking_optional"
-            optional_q = "Perfect! Any amenities or special requirements?"
-            state["ai_reply"] = await translate_to_language(optional_q, language)
-        
-        logger.info(f"📋 Listing: status={state['status']}, missing={missing}")
-    
-    # ===== SEARCH INTENT =====
-    elif intent == "search":
-        state["intent"] = "search"
-        state["status"] = "searching"
-        state["search_query"] = human_msg
-        state["allowed"] = True
-        
-        location = extract_location(human_msg)
-        if location:
-            state["location"] = location
-        
-        bedrooms = extract_number(human_msg)
-        if bedrooms:
-            state["bedrooms"] = int(bedrooms)
-        
-        amenities = extract_amenities(human_msg)
-        if amenities:
-            state["amenities"] = amenities
-        
-        prices = re.findall(r'(\d+)[k,.]?', human_msg.lower())
-        if prices:
-            if len(prices) >= 2:
-                state["min_price"] = float(prices[0]) * (1000 if 'k' in human_msg.lower() else 1)
-                state["max_price"] = float(prices[1]) * (1000 if 'k' in human_msg.lower() else 1)
-            else:
-                state["max_price"] = float(prices[0]) * (1000 if 'k' in human_msg.lower() else 1)
-        
-        searching_msg = "Searching for properties..."
-        state["ai_reply"] = await translate_to_language(searching_msg, language)
-        logger.info(f"🔍 Search initiated")
-    
-    # ===== MY LISTINGS INTENT =====
-    elif intent == "my_listings":
-        state["intent"] = "my_listings"
-        state["status"] = "fetching_listings"
-        state["allowed"] = True
-        
-        fetching_msg = "Fetching your listings..."
-        state["ai_reply"] = await translate_to_language(fetching_msg, language)
-        logger.info(f"📚 My listings requested")
-    
-    # ===== GREETING =====
-    else:
-        state["intent"] = "greeting"
-        state["status"] = "greeting"
-        state["allowed"] = True
-        
-        greeting_msg = "Hello! 👋 I'm Aida, Lojiz's real estate AI assistant. I can help you list a property, search for homes, or chat about real estate. What would you like to do?"
-        state["ai_reply"] = await translate_to_language(greeting_msg, language)
-        logger.info(f"👋 Greeting in {language}")
-    
-    logger.info(f"✅ Intent node complete", intent=state.get("intent"), status=state.get("status"))
-    return state

app/ai/nodes/publish_node.py

@@ -1,53 +0,0 @@
-# app/ai/nodes/publish_node.py – FIXED STATUS CHECK
-import datetime
-from typing import Dict
-from app.database import get_db
-from structlog import get_logger
-from bson import ObjectId
-
-logger = get_logger(__name__)
-
-_PUBLISH_WORDS = {"publish", "publier", "go live", "post it", "list it", "confirm", "yes", "ok", "okay"}
-
-async def publish_node(state: Dict) -> Dict:
-    # ACCEPT BOTH STATUSES
-    if state.get("status") not in {"preview_shown", "publishing"} or not state.get("draft_preview"):
-        return state
-
-    draft = state["draft_preview"]
-    try:
-        db   = await get_db()
-        col  = db["listings"]
-        doc  = {
-            "owner_id":     state["user_id"],
-            "type":         draft["listing_type"],
-            "title":        draft["title"],
-            "description":  draft["description"],
-            "price":        draft["price"],
-            "price_type":   draft["price_type"],
-            "bedrooms":     draft["bedrooms"],
-            "bathrooms":    draft["bathrooms"],
-            "location":     draft["location"],
-            "amenities":    draft.get("amenities", []),
-            "requirements": draft.get("requirements"),
-            "currency":     draft.get("currency", "XOF"),
-            "images":       draft.get("images", []),
-            "status":       "published",
-            "created_at":   datetime.datetime.utcnow(),
-            "updated_at":   datetime.datetime.utcnow(),
-            "views":        0,
-            "favorites":    0,
-        }
-        mongo_id = str((await col.insert_one(doc)).inserted_id)
-
-        state["mongo_id"] = mongo_id
-        state["status"]   = "published"
-        state["ai_reply"] = f"✅ **Annonce publiée !**  \n{draft['title']} est maintenant en ligne. 🎉"
-        logger.info("✅ Listing published", mongo_id=mongo_id, title=draft["title"])
-
-    except Exception as e:
-        logger.error("❌ Publish failed", exc_info=e)
-        state["ai_reply"] = "Désolé, la publication a échoué. Veuillez réessayer."
-        state["status"]     = "error"
-
-    return state

app/ai/nodes/role_gate_node.py

@@ -1,51 +0,0 @@
-# app/ai/nodes/role_gate_node.py  (final)
-from typing import Dict
-from structlog import get_logger
-
-logger = get_logger(__name__)
-
-LANDLORD_ALLOWED = {"rent", "short_stay", "sale"}
-RENTER_ALLOWED = {"roommate"}
-
-def role_gate_node(state: Dict) -> Dict:
-    """
-    LangGraph node:
-    - 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
-    if state.get("intent") == "search":
-        logger.info("Aida passed search intent")
-        return state
-
-    # 2. already blocked by intent node? keep message
-    if not state.get("allowed", False):
-        logger.info("Aida already denied", reason="intent")
-        return state
-
-    # 3. casual chat (no listing_type) → leave reply untouched
-    list_type = state.get("listing_type")
-    if list_type is None:
-        logger.info("Aida passed casual chat")
-        return state
-
-    # 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
-        if state["user_role"] == "landlord":
-            state["ai_reply"] = (
-                "As a landlord you can only list for rent, short-stay or sale. "
-                "Would you like to list this as a rental instead?"
-            )
-        else:
-            state["ai_reply"] = (
-                "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("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("Aida approved", user_role=state["user_role"], type=list_type)
-
-    return state

app/ai/nodes/search_node.py

@@ -1,355 +0,0 @@
-# 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 app.config import settings
-from structlog import get_logger
-
-logger = get_logger(__name__)
-
-EMBED_MODEL = "qwen/qwen3-embedding-8b"
-TOP_K = 6
-
-# ------------------------------------------------------------------
-# Qdrant client
-# ------------------------------------------------------------------
-qdrant_client = AsyncQdrantClient(
-    url=settings.QDRANT_URL,
-    api_key=settings.QDRANT_API_KEY,
-    https=True,
-    timeout=60,
-)
-
-# ---------- helpers ----------
-def _build_filter(state: Dict) -> models.Filter:
-    """Build comprehensive Qdrant filter from ALL search fields."""
-    must = []
-    
-    # Location filter (case-insensitive)
-    loc = (state.get("location") or "").lower()
-    if loc:
-        must.append(
-            models.FieldCondition(
-                key="location_lower",
-                match=models.MatchValue(value=loc)
-            )
-        )
-    
-    # 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:
-            price_range["gte"] = state["min_price"]
-        if state.get("max_price") is not None:
-            price_range["lte"] = state["max_price"]
-        
-        if price_range:
-            must.append(
-                models.FieldCondition(
-                    key="price",
-                    range=models.Range(**price_range)
-                )
-            )
-    
-    # Bedrooms filter
-    if state.get("bedrooms") is not None:
-        must.append(
-            models.FieldCondition(
-                key="bedrooms",
-                match=models.MatchValue(value=state["bedrooms"])
-            )
-        )
-    
-    # Bathrooms filter
-    if state.get("bathrooms") is not None:
-        must.append(
-            models.FieldCondition(
-                key="bathrooms",
-                match=models.MatchValue(value=state["bathrooms"])
-            )
-        )
-    
-    # Price type filter (monthly, nightly, yearly, etc.)
-    price_type = (state.get("price_type") or "").lower()
-    if price_type:
-        must.append(
-            models.FieldCondition(
-                key="price_type_lower",
-                match=models.MatchValue(value=price_type)
-            )
-        )
-    
-    # Listing type filter (rent, short_stay, roommate, sale)
-    listing_type = (state.get("listing_type") or "").lower()
-    if listing_type:
-        must.append(
-            models.FieldCondition(
-                key="listing_type_lower",
-                match=models.MatchValue(value=listing_type)
-            )
-        )
-    
-    # Amenities filter (all mentioned amenities must exist in listing)
-    amenities = state.get("amenities", [])
-    if amenities:
-        for amenity in amenities:
-            amenity_lower = amenity.lower().strip()
-            if amenity_lower:
-                must.append(
-                    models.FieldCondition(
-                        key="amenities",
-                        match=models.MatchValue(value=amenity_lower)
-                    )
-                )
-    
-    filt = models.Filter(must=must) if must else models.Filter()
-    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 def _embed(text: str) -> List[float]:
-    """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"]
-
-
-# ---------- suggestion helpers ----------
-async def _search_with_must(must: List, vector: List[float]):
-    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."""
-    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:
-            price_range["gte"] = state["min_price"]
-        if state.get("max_price") is not None:
-            price_range["lte"] = state["max_price"]
-        
-        if price_range:
-            must.append(models.FieldCondition(key="price", range=models.Range(**price_range)))
-
-
-def _hits_to_cards(hits):
-    """Convert Qdrant hits to UI 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.
-    If no location specified, return empty.
-    """
-    loc = (state.get("location") or "").lower()
-    br = state.get("bedrooms")
-    amenities = state.get("amenities", [])
-
-    # 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)
-    )
-
-    # 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. 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. 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. 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)
-
-    return []
-
-
-# ---------- node ----------
-async def search_node(state: Dict) -> Dict:
-    """
-    LangGraph node: comprehensive search with all filters
-    - title/description (semantic via embedding)
-    - location, price range, bedrooms, bathrooms, amenities (keyword filters)
-    - price_type, listing_type
-    
-    ✅ 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))
-    
-    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": 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}{price_bit}{br_bit}{amenities_bit}. "
-                "Try widening your search or check back later!"
-            )
-            state["search_preview"] = {  # ✅ Empty UI state
-                "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"
-            }
-    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/routes/chat.py

@@ -1,4 +1,13 @@
-# app/routes/chat.py - COMPLETE AIDA CHAT ROUTES
+# app/ai/routes/chat.py - Integrated Chat Endpoint
+"""
+Complete chat endpoint using all modules:
+- Intent detection
+- Property listing service
+- Image upload
+- Draft & preview
+- Redis memory
+"""
+
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi.security import HTTPBearer
 from pydantic import BaseModel
@@ -6,107 +15,469 @@ from typing import Optional, List, Dict, Any
 from structlog import get_logger
 
 from app.guards.jwt_guard import decode_access_token
-from app.ai.service import aida_chat_sync
+from app.ai.memory.redis_context_memory import get_current_memory
+from app.ai.intent_detector import detect_intent_with_llm, build_smart_response
+from app.ai.services.property_listing_service import PropertyListingService
+from app.ai.modules.post_draft_handler import handle_post_draft_action
+from app.ai.memory.redis_memory import is_rate_limited
 
 logger = get_logger(__name__)
 
 router = APIRouter()
 security = HTTPBearer()
+listing_service = PropertyListingService()
+
+
+# ========== REQUEST/RESPONSE MODELS ==========
+class MessageHistory(BaseModel):
+    role: str
+    content: str
+    timestamp: Optional[str] = None
 
 
-# ============================================
-# REQUEST/RESPONSE MODELS
-# ============================================
 class AskBody(BaseModel):
-    """Chat request body"""
     message: str
+    session_id: Optional[str] = None
     thread_id: Optional[str] = None
+    image_data: Optional[Dict[str, str]] = None  # For image uploads: {mime: "image/jpeg", data: "base64..."}
 
 
-class AskResponse(BaseModel):
-    """Chat response"""
-    text: str  # Main AI reply
-    intent: Optional[str] = None  # 'list' | 'search' | 'greeting' | 'my_listings'
-    status: Optional[str] = None  # Current flow state
-    draft_preview: Optional[Dict[str, Any]] = None  # For listings
-    search_results: Optional[List[Dict]] = None  # For searches
-    missing_fields: Optional[List[str]] = None  # Fields still needed
-    next_question: Optional[str] = None  # Next question to ask
-    error: Optional[str] = None  # Error message if any
+class ChatResponse(BaseModel):
+    success: bool
+    text: str
+    action: str
+    state: Optional[Dict[str, Any]] = None
+    mongo_id: Optional[str] = None
+    error: Optional[str] = None
 
 
-# ============================================
-# ENDPOINTS
-# ============================================
-@router.post("/ask", response_model=AskResponse)
+# ========== MAIN CHAT ENDPOINT ==========
+@router.post("/ask", response_model=ChatResponse)
 async def ask_ai(
     body: AskBody,
     token: str = Depends(security),
-):
+) -> ChatResponse:
     """
-    Main chat endpoint
+    Main chat endpoint - handles all Aida functionality
     
     Flow:
-    1. Authenticate user from JWT token
-    2. Load conversation history
-    3. Execute LangGraph workflow
-    4. Return response with intent, status, and results
+    1. Authenticate user
+    2. Check rate limit
+    3. Get Redis memory
+    4. Detect intent
+    5. Route to appropriate handler
+    6. Save to memory
+    7. Return response
     """
     
-    logger.info(f"📨 /ask endpoint called", msg=body.message[:50])
-    
-    # ===== AUTHENTICATE =====
     try:
+        # ========== 1. AUTHENTICATE ==========
         payload = decode_access_token(token.credentials)
         if not payload:
+            logger.warning("🔐 Invalid token")
             raise HTTPException(status_code=401, detail="Invalid token")
         
-        user_id = payload.get("user_id")
-        user_role = payload.get("role", "landlord")
+        user_id = payload["user_id"]
+        user_role = payload.get("role", "renter")  # landlord or renter
         
-        logger.info(f"✅ User authenticated", user_id=user_id, role=user_role)
-    
-    except Exception as e:
-        logger.error(f"❌ Authentication failed", exc_info=e)
-        raise HTTPException(status_code=401, detail="Unauthorized")
-    
-    # ===== VALIDATE INPUT =====
-    if not body.message or len(body.message.strip()) == 0:
-        raise HTTPException(status_code=400, detail="Message cannot be empty")
-    
-    if len(body.message) > 2000:
-        raise HTTPException(status_code=400, detail="Message too long (max 2000 chars)")
-    
-    # ===== EXECUTE CHAT =====
-    try:
-        result = await aida_chat_sync(
+        # ========== 2. RATE LIMIT CHECK ==========
+        if await is_rate_limited(user_id):
+            logger.warning("⚠️ Rate limit exceeded", user_id=user_id)
+            raise HTTPException(status_code=429, detail="Rate limit exceeded")
+        
+        # ========== 3. GET REDIS MEMORY ==========
+        session_id = body.session_id or "default"
+        memory = await get_current_memory(user_id, session_id)
+        
+        # Get current context from Redis
+        context = await memory.get_context()
+        
+        logger.info(
+            "💬 Chat message received",
             user_id=user_id,
-            user_role=user_role,
-            human_msg=body.message,
+            session_id=session_id,
+            status=context.get("status"),
+            message_length=len(body.message)
+        )
+        
+        # ========== 4. ADD USER MESSAGE TO MEMORY ==========
+        await memory.add_message("user", body.message)
+        
+        # ========== 5. DETECT INTENT ==========
+        intent, confidence, intent_meta = await detect_intent_with_llm(
+            body.message,
+            conversation_context=context
         )
         
-        logger.info(f"✅ Chat successful", intent=result.get("intent"))
-        
-        return AskResponse(
-            text=result.get("text", ""),
-            intent=result.get("intent"),
-            status=result.get("status"),
-            draft_preview=result.get("draft_preview"),
-            search_results=result.get("search_results"),
-            missing_fields=result.get("missing_fields"),
-            next_question=result.get("next_question"),
-            error=result.get("error"),
+        logger.info(
+            "🎯 Intent detected",
+            intent=intent,
+            confidence=confidence,
+            language=intent_meta.get("language")
         )
+        
+        # Update language in context
+        if intent_meta.get("language"):
+            await memory.update_context({"language": intent_meta["language"]})
+            context["language"] = intent_meta["language"]
+        
+        language = context.get("language", "en")
+        
+        # ========== 6. ROUTE TO APPROPRIATE HANDLER ==========
+        
+        # ========== HANDLE IMAGE UPLOAD ==========
+        if body.image_data:
+            logger.info("📸 Image upload request")
+            
+            image_base64 = body.image_data.get("data")
+            mime_type = body.image_data.get("mime", "image/jpeg")
+            
+            if not image_base64:
+                return ChatResponse(
+                    success=False,
+                    text="No image data provided",
+                    action="error",
+                    error="Invalid image data"
+                )
+            
+            # Upload image
+            upload_result = await listing_service.upload_image(
+                image_base64=image_base64,
+                mime_type=mime_type,
+                current_state={
+                    **context,
+                    "raw_state": context.get("state", {})
+                }
+            )
+            
+            # Update memory
+            await memory.update_context({
+                "state": upload_result["state"].get("raw_state", {})
+            })
+            
+            # Add response to memory
+            response_msg = upload_result["message"]
+            await memory.add_message("assistant", response_msg)
+            
+            return ChatResponse(
+                success=True,
+                text=response_msg,
+                action=upload_result["action"],
+                state=upload_result["state"]
+            )
+        
+        # ========== HANDLE LISTING INTENT ==========
+        if intent == "LIST_PROPERTY":
+            logger.info("📍 Listing intent detected")
+            
+            # Check if starting new listing or continuing
+            if context.get("status") != "listing":
+                # Start new listing
+                result = await listing_service.start_listing(
+                    user_id=user_id,
+                    user_role=user_role,
+                    language=language
+                )
+                
+                # Update memory
+                await memory.update_context({
+                    "status": "listing",
+                    "user_role": user_role,
+                    "language": language,
+                })
+                
+                response_text = result["example"]
+                await memory.add_message("assistant", response_text)
+                
+                return ChatResponse(
+                    success=True,
+                    text=response_text,
+                    action="show_example",
+                    state=result["state"]
+                )
+            
+            else:
+                # Continue listing
+                result = await listing_service.continue_listing(
+                    user_input=body.message,
+                    current_state={
+                        **context,
+                        "raw_state": context.get("state", {})
+                    }
+                )
+                
+                # Update memory with new state
+                new_state = result["state"]
+                await memory.update_context({
+                    "state": new_state.get("raw_state", {}),
+                    "status": new_state.get("status", "listing"),
+                    "draft": new_state.get("draft"),
+                })
+                
+                response_text = result.get("question") or result.get("message", "")
+                await memory.add_message("assistant", response_text)
+                
+                return ChatResponse(
+                    success=True,
+                    text=response_text,
+                    action=result["action"],
+                    state=new_state
+                )
+        
+        # ========== HANDLE SEARCH INTENT ==========
+        elif intent == "SEARCH_PROPERTY":
+            logger.info("🔍 Search intent detected")
+            
+            # Import search service (you'll build this)
+            # For now, return placeholder
+            response_text = "Search feature coming soon! For now, you can list or talk to an agent."
+            await memory.add_message("assistant", response_text)
+            
+            return ChatResponse(
+                success=True,
+                text=response_text,
+                action="search",
+                state=context
+            )
+        
+        # ========== HANDLE POST-DRAFT ACTIONS ==========
+        elif intent == "PUBLISH_DRAFT" or intent == "EDIT_FIELD" or intent == "DISCARD_DRAFT":
+            logger.info(f"📋 Post-draft action: {intent}")
+            
+            if context.get("status") not in ["preview_shown", "waiting_for_images"]:
+                response_text = "You don't have a draft to publish. Would you like to list a property?"
+                await memory.add_message("assistant", response_text)
+                
+                return ChatResponse(
+                    success=True,
+                    text=response_text,
+                    action="error",
+                    state=context
+                )
+            
+            draft = context.get("draft")
+            if not draft:
+                response_text = "Draft not found. Please start over."
+                await memory.add_message("assistant", response_text)
+                
+                return ChatResponse(
+                    success=True,
+                    text=response_text,
+                    action="error",
+                    state=context
+                )
+            
+            # Handle the action
+            result = await handle_post_draft_action(
+                user_input=body.message,
+                draft=draft,
+                user_id=user_id,
+                language=language
+            )
+            
+            response_text = result["message"]
+            
+            # ========== PUBLISHED ==========
+            if result["action"] == "published":
+                logger.info("✅ Listing published", mongo_id=result["mongo_id"])
+                
+                # Clear draft from memory
+                await memory.update_context({
+                    "status": "idle",
+                    "draft": None,
+                    "state": {},
+                })
+                
+                await memory.add_message("assistant", response_text)
+                
+                return ChatResponse(
+                    success=True,
+                    text=response_text,
+                    action="published",
+                    mongo_id=result["mongo_id"],
+                    state={**context, "status": "idle"}
+                )
+            
+            # ========== PUBLISH ERROR ==========
+            elif result["action"] == "publish_error":
+                logger.error("❌ Publish failed")
+                
+                await memory.add_message("assistant", response_text)
+                
+                return ChatResponse(
+                    success=False,
+                    text=response_text,
+                    action="publish_error",
+                    error=response_text,
+                    state=context
+                )
+            
+            # ========== SHOW UPDATED PREVIEW ==========
+            elif result["action"] == "show_updated_preview":
+                logger.info("✏️ Draft field updated")
+                
+                # Update memory with new draft
+                await memory.update_context({
+                    "draft": result["draft"]
+                })
+                
+                await memory.add_message("assistant", response_text)
+                
+                return ChatResponse(
+                    success=True,
+                    text=response_text,
+                    action="show_updated_preview",
+                    state=context
+                )
+            
+            # ========== DISCARDED ==========
+            elif result["action"] == "discarded":
+                logger.info("❌ Draft discarded")
+                
+                await memory.update_context(result["next_state"])
+                await memory.add_message("assistant", response_text)
+                
+                return ChatResponse(
+                    success=True,
+                    text=response_text,
+                    action="discarded",
+                    state=result["next_state"]
+                )
+            
+            # ========== ADD IMAGE ==========
+            elif result["action"] == "add_image":
+                logger.info("📸 User wants to add image")
+                
+                await memory.add_message("assistant", response_text)
+                
+                return ChatResponse(
+                    success=True,
+                    text=response_text,
+                    action="add_image",
+                    state=context
+                )
+            
+            # ========== UNCLEAR ==========
+            else:
+                await memory.add_message("assistant", response_text)
+                
+                return ChatResponse(
+                    success=True,
+                    text=response_text,
+                    action="unclear",
+                    state=context
+                )
+        
+        # ========== HANDLE CASUAL CHAT / OTHER ==========
+        else:
+            logger.info("💬 Casual chat", intent=intent)
+            
+            response_text = await build_smart_response(
+                intent=intent,
+                confidence=confidence,
+                conversation_context=context,
+                language=language
+            )
+            
+            await memory.add_message("assistant", response_text)
+            
+            return ChatResponse(
+                success=True,
+                text=response_text,
+                action=intent,
+                state=context
+            )
     
+    except HTTPException:
+        raise
     except Exception as e:
-        logger.error(f"❌ Chat failed", exc_info=e)
+        logger.error("❌ Chat endpoint error", exc_info=e)
         raise HTTPException(
             status_code=500,
-            detail=f"Chat service error: {str(e)}"
+            detail=f"Error processing message: {str(e)}"
         )
 
 
+# ========== HEALTH CHECK ==========
 @router.get("/health")
-async def health():
-    """Health check"""
-    return {"status": "ok", "service": "Aida AI Chat"}
+async def health_check():
+    """Health check for chat service"""
+    return {
+        "status": "healthy",
+        "service": "Aida Chat",
+    }
+
+
+# ========== GET CHAT HISTORY ==========
+@router.get("/history/{session_id}")
+async def get_chat_history(
+    session_id: str,
+    token: str = Depends(security),
+):
+    """
+    Get chat history for a session
+    """
+    
+    try:
+        payload = decode_access_token(token.credentials)
+        if not payload:
+            raise HTTPException(status_code=401, detail="Invalid token")
+        
+        user_id = payload["user_id"]
+        
+        # Get memory
+        memory = await get_current_memory(user_id, session_id)
+        
+        # Get messages
+        messages = await memory.get_messages()
+        summary = await memory.get_summary()
+        
+        logger.info("📖 Retrieved chat history", user_id=user_id, session_id=session_id)
+        
+        return {
+            "success": True,
+            "summary": summary,
+            "messages": messages,
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("❌ Failed to get history", exc_info=e)
+        raise HTTPException(status_code=500, detail="Failed to retrieve history")
+
+
+# ========== CLOSE SESSION ==========
+@router.post("/close-session/{session_id}")
+async def close_session(
+    session_id: str,
+    token: str = Depends(security),
+):
+    """
+    Close/clear a chat session
+    """
+    
+    try:
+        payload = decode_access_token(token.credentials)
+        if not payload:
+            raise HTTPException(status_code=401, detail="Invalid token")
+        
+        user_id = payload["user_id"]
+        
+        # Close session
+        from app.ai.memory.redis_context_memory import get_memory_manager
+        manager = get_memory_manager()
+        await manager.close_session(user_id, session_id)
+        
+        logger.info("❌ Session closed", user_id=user_id, session_id=session_id)
+        
+        return {
+            "success": True,
+            "message": "Session closed"
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("❌ Failed to close session", exc_info=e)
+        raise HTTPException(status_code=500, detail="Failed to close session")

app/ai/service.py

@@ -1,90 +0,0 @@
-# app/ai/service.py - COMPLETE SERVICE LAYER
-import json
-from typing import Dict, Any
-from structlog import get_logger
-
-from app.ai.graph import agent
-from app.ai.memory.redis_memory import save_turn, load_history
-
-logger = get_logger(__name__)
-
-
-async def aida_chat_sync(
-    user_id: str,
-    user_role: str,
-    human_msg: str,
-) -> Dict[str, Any]:
-    """
-    Main synchronous chat endpoint
-    
-    This is the entry point called by the API
-    
-    Args:
-        user_id: Current user ID
-        user_role: 'landlord' or 'renter'
-        human_msg: User's message
-    
-    Returns:
-        Complete state dict with ai_reply, search_results, draft_preview, etc.
-    """
-    
-    logger.info(f"💬 Chat request", user_id=user_id, role=user_role)
-    
-    try:
-        # ===== Load Conversation History =====
-        messages = await load_history(user_id)
-        
-        # Add current user message
-        messages.append({"role": "user", "content": human_msg})
-        
-        # ===== Initialize State =====
-        state = {
-            "user_id": user_id,
-            "user_role": user_role,
-            "messages": messages,
-            "intent": None,
-            "status": "greeting",
-            "allowed": False,
-            "ai_reply": "",
-            # Empty collections
-            "missing_fields": [],
-            "amenities": [],
-            "image_urls": [],
-            "search_results": [],
-        }
-        
-        logger.info(f"📊 Initial state created")
-        
-        # ===== Execute LangGraph Workflow =====
-        logger.info(f"🚀 Executing LangGraph workflow")
-        final_state = await agent.ainvoke(state)
-        
-        # ===== Save Conversation =====
-        messages.append({"role": "assistant", "content": final_state.get("ai_reply", "")})
-        await save_turn(user_id, messages)
-        
-        logger.info(
-            f"✅ Chat complete",
-            intent=final_state.get("intent"),
-            status=final_state.get("status"),
-        )
-        
-        # ===== Return Response =====
-        return {
-            "text": final_state.get("ai_reply", ""),
-            "intent": final_state.get("intent"),
-            "status": final_state.get("status"),
-            "draft_preview": final_state.get("draft_preview"),
-            "search_results": final_state.get("search_results", []),
-            "missing_fields": final_state.get("missing_fields", []),
-            "next_question": final_state.get("next_question"),
-        }
-    
-    except Exception as e:
-        logger.error(f"❌ Chat error", exc_info=e)
-        return {
-            "text": f"Sorry, I encountered an error: {str(e)}",
-            "intent": "error",
-            "status": "error",
-            "error": str(e),
-        }

app/ai/services/dynamic_role_manager.py

@@ -1,90 +0,0 @@
-# app/ai/services/dynamic_role_manager.py – FINAL FIXED VERSION
-import logging
-from typing import Tuple
-from enum import Enum
-
-logger = logging.getLogger(__name__)
-
-class BaseRole(Enum):
-    LANDLORD = "landlord"
-    RENTER = "renter"
-
-class DynamicRole(Enum):
-    LANDLORD = "landlord"
-    HOST = "host"
-    SELLER = "seller"
-    RENTER = "renter"
-    GUEST = "guest"
-    BUYER = "buyer"
-    ROOMMATE_SEEKER = "roommate_seeker"
-    ROOMMATE_LISTER = "roommate_lister"
-
-class DynamicRoleManager:
-    def get_dynamic_role_for_listing(
-        self, 
-        base_role: str, 
-        listing_type: str
-    ) -> Tuple[str, str, float]:
-        base_role_lower = base_role.lower().strip()
-        listing_type_lower = listing_type.lower().strip() if listing_type else None
-
-        logger.info(f"Getting listing role: base='{base_role_lower}', type='{listing_type_lower}'")
-
-        # ✅ FIXED: Default to 'rent' if listing_type is None
-        if not listing_type_lower:
-            listing_type_lower = "rent"
-
-        if base_role_lower == "landlord":
-            if listing_type_lower == "short-stay":
-                return DynamicRole.HOST.value, "Short-stay property host", 0.99
-            elif listing_type_lower == "sale":
-                return DynamicRole.SELLER.value, "Property seller", 0.99
-            elif listing_type_lower == "rent":
-                return DynamicRole.LANDLORD.value, "Rental property landlord", 0.99
-            elif listing_type_lower == "roommate":
-                return None, "Landlords cannot list for roommate matching.", 0.0
-            else:
-                return DynamicRole.LANDLORD.value, "Rental property landlord", 0.99  # ✅ Default fallback
-
-        elif base_role_lower == "renter":
-            if listing_type_lower == "roommate":
-                return DynamicRole.ROOMMATE_LISTER.value, "Room share lister", 0.99
-            else:
-                return None, "Renters can only list rooms for roommate matching.", 0.0
-
-        logger.warning(f"Unknown base role: {base_role_lower}")
-        return None, "Unknown role", 0.0
-
-    def get_dynamic_role_for_search(
-        self, 
-        base_role: str, 
-        search_for: str = None
-    ) -> Tuple[str, str, float]:
-        base_role_lower = base_role.lower().strip()
-        search_for_lower = search_for.lower().strip() if search_for else None
-
-        logger.info(f"Getting search role: base='{base_role_lower}', search_for='{search_for_lower}'")
-
-        if base_role_lower == "landlord":
-            logger.warning("Landlord searching for properties - unusual but allowed")
-            return DynamicRole.RENTER.value, "Searching for rentals (unusual)", 0.5
-
-        elif base_role_lower == "renter":
-            if search_for_lower == "short-stay":
-                return DynamicRole.GUEST.value, "Short-stay guest", 0.99
-            elif search_for_lower == "sale":
-                return DynamicRole.BUYER.value, "Property buyer", 0.99
-            elif search_for_lower == "roommate":
-                return DynamicRole.ROOMMATE_SEEKER.value, "Roommate seeker", 0.99
-            else:
-                return DynamicRole.RENTER.value, "Property searcher", 0.95
-
-        return None, "Unknown role", 0.0
-
-_manager = None
-
-def get_dynamic_role_manager() -> DynamicRoleManager:
-    global _manager
-    if _manager is None:
-        _manager = DynamicRoleManager()
-    return _manager

app/ai/services/property_listing_service.py

@@ -0,0 +1,470 @@
+# app/ai/services/property_listing_service.py - Unified Listing Service
+"""
+Complete property listing service that ties all modules together:
+- Intent detection
+- Field collection with auto-detection
+- Image upload to Cloudflare
+- Draft generation & preview
+- Publish/Edit/Discard handling
+- MongoDB integration
+"""
+
+from typing import Dict, Optional, Tuple
+from structlog import get_logger
+from datetime import datetime
+
+# Import all modules
+from app.ai.modules.property_listing import (
+    start_listing,
+    continue_listing,
+    build_listing_state,
+    generate_draft,
+)
+from app.ai.modules.image_upload import (
+    process_image_upload,
+    has_images,
+    get_images_status,
+    ask_for_image_upload,
+)
+from app.ai.modules.draft_preview import (
+    generate_and_show_preview,
+)
+from app.ai.modules.post_draft_handler import (
+    handle_post_draft_action,
+)
+from app.ai.intent_detector import (
+    detect_intent_with_llm,
+    build_smart_response,
+)
+
+logger = get_logger(__name__)
+
+
+# ========== PROPERTY LISTING SERVICE ==========
+class PropertyListingService:
+    """
+    Complete service for property listing workflow
+    
+    Manages:
+    - Starting a new listing
+    - Collecting fields
+    - Uploading images
+    - Generating drafts
+    - Publishing/editing/discarding
+    """
+    
+    def __init__(self):
+        logger.info("🚀 PropertyListingService initialized")
+    
+    # ========== 1. START LISTING ==========
+    async def start_listing(
+        self,
+        user_id: str,
+        user_role: str,
+        language: str,
+    ) -> Dict:
+        """
+        User says they want to list a property
+        
+        Returns:
+        {
+            "action": "show_example",
+            "example": "Example text...",
+            "state": {...}
+        }
+        """
+        logger.info("📍 START_LISTING", user_id=user_id, user_role=user_role, language=language)
+        
+        result = await start_listing(user_id, user_role, language)
+        
+        return {
+            "action": "show_example",
+            "example": result["example"],
+            "state": result["state"],
+        }
+    
+    # ========== 2. COLLECT FIELDS & AUTO-DETECT ==========
+    async def continue_listing(
+        self,
+        user_input: str,
+        current_state: Dict,
+    ) -> Dict:
+        """
+        User provides property information
+        
+        Extracts fields, auto-detects price_type/listing_type/currency
+        
+        Returns:
+        - If missing fields: Ask for next field
+        - If all fields collected: Ask for images
+        """
+        logger.info("📍 CONTINUE_LISTING", input=user_input[:50])
+        
+        user_id = current_state.get("user_id")
+        user_role = current_state.get("user_role")
+        language = current_state.get("language", "en")
+        
+        # Build updated state
+        updated_state = await build_listing_state(
+            user_id=user_id,
+            user_role=user_role,
+            language=language,
+            user_input=user_input,
+            current_state=current_state.get("raw_state", {}),
+        )
+        
+        missing_fields = updated_state["missing_fields"]
+        
+        if missing_fields:
+            # Still missing required fields
+            logger.info("📋 Missing required fields", missing=missing_fields)
+            
+            from app.ai.modules.property_listing import generate_smart_question
+            
+            next_field = missing_fields[0]
+            question = await generate_smart_question(next_field, language)
+            
+            return {
+                "action": "ask_next_field",
+                "question": question,
+                "state": updated_state,
+            }
+        else:
+            # All required fields collected - check for images
+            logger.info("✅ All required fields collected")
+            
+            if has_images(updated_state["raw_state"]):
+                # Images already uploaded, ready for draft
+                logger.info("📸 Images already present, generating draft")
+                return await self._generate_draft_internal(updated_state)
+            else:
+                # Ask for images
+                logger.info("📸 Asking for images")
+                
+                return {
+                    "action": "ask_for_images",
+                    "message": ask_for_image_upload(language),
+                    "state": {
+                        **updated_state,
+                        "status": "waiting_for_images",
+                    },
+                }
+    
+    # ========== 3. UPLOAD IMAGE ==========
+    async def upload_image(
+        self,
+        image_base64: str,
+        mime_type: str,
+        current_state: Dict,
+    ) -> Dict:
+        """
+        User uploads an image
+        
+        - Upload to Cloudflare
+        - Get URL back
+        - Save to state
+        - Check if ready for draft
+        """
+        logger.info("���� UPLOAD_IMAGE", mime_type=mime_type)
+        
+        language = current_state.get("language", "en")
+        
+        # Upload to Cloudflare
+        upload_result = await process_image_upload(
+            image_base64=image_base64,
+            mime_type=mime_type,
+            state=current_state.get("raw_state", {}),
+            language=language,
+        )
+        
+        if not upload_result["success"]:
+            # Upload failed
+            logger.error("❌ Image upload failed")
+            return {
+                "action": "upload_error",
+                "message": upload_result["message"],
+                "state": current_state,
+            }
+        
+        # Upload successful
+        updated_state = current_state.copy()
+        updated_state["raw_state"] = upload_result["state"]
+        
+        logger.info("✅ Image uploaded", total=upload_result["total_images"])
+        
+        # Check images status
+        images_status = get_images_status(upload_result["state"], language)
+        
+        return {
+            "action": "image_uploaded",
+            "message": upload_result["message"],
+            "total_images": upload_result["total_images"],
+            "image_url": upload_result["image_url"],
+            "state": updated_state,
+        }
+    
+    # ========== 4. GENERATE DRAFT (INTERNAL) ==========
+    async def _generate_draft_internal(self, state: Dict) -> Dict:
+        """
+        Internal helper to generate draft
+        """
+        logger.info("📍 GENERATE_DRAFT_INTERNAL")
+        
+        # Generate title and description
+        draft_result = await generate_draft(state)
+        
+        draft = draft_result["draft"]
+        user_id = state.get("user_id")
+        language = state.get("language", "en")
+        
+        # Generate and show preview
+        preview_result = await generate_and_show_preview(user_id, draft, language)
+        
+        return {
+            "action": "show_preview",
+            "preview": preview_result["preview_text"],
+            "draft": preview_result["draft"],
+            "state": preview_result["state"],
+        }
+    
+    # ========== 5. GENERATE DRAFT (USER COMMAND) ==========
+    async def generate_draft(self, current_state: Dict) -> Dict:
+        """
+        User says "generate preview" or "show draft"
+        
+        Checks if images present, then generates draft
+        """
+        logger.info("📍 GENERATE_DRAFT")
+        
+        language = current_state.get("language", "en")
+        raw_state = current_state.get("raw_state", {})
+        
+        # Check if images present
+        images_status = get_images_status(raw_state, language)
+        
+        if not images_status["has_images"]:
+            # No images yet
+            logger.warning("⚠️ No images, can't generate draft")
+            return {
+                "action": "error",
+                "message": images_status["message"],
+                "state": current_state,
+            }
+        
+        # Generate draft
+        return await self._generate_draft_internal(current_state)
+    
+    # ========== 6. HANDLE POST-DRAFT ACTIONS ==========
+    async def handle_post_draft_action(
+        self,
+        user_input: str,
+        current_state: Dict,
+    ) -> Dict:
+        """
+        User is viewing draft preview and takes an action:
+        - publish
+        - edit
+        - discard
+        - add_image
+        """
+        logger.info("📍 HANDLE_POST_DRAFT_ACTION", input=user_input[:50])
+        
+        user_id = current_state.get("user_id")
+        language = current_state.get("language", "en")
+        draft = current_state.get("draft", {})
+        
+        # Handle the action
+        result = await handle_post_draft_action(user_input, draft, user_id, language)
+        
+        # ========== PUBLISH ==========
+        if result["action"] == "published":
+            logger.info("✅ Listing published", mongo_id=result["mongo_id"])
+            
+            return {
+                "action": "published",
+                "success": True,
+                "mongo_id": result["mongo_id"],
+                "message": result["message"],
+                "next_state": {
+                    "status": "idle",
+                    "draft": None,
+                    "images": [],
+                },
+            }
+        
+        # ========== PUBLISH ERROR ==========
+        elif result["action"] == "publish_error":
+            logger.error("❌ Publish failed", message=result["message"])
+            
+            return {
+                "action": "publish_error",
+                "success": False,
+                "message": result["message"],
+                "state": {
+                    **current_state,
+                    "draft": result["draft"],
+                },
+            }
+        
+        # ========== EDIT ==========
+        elif result["action"] in ["ask_which_field", "ask_new_value", "show_updated_preview"]:
+            logger.info("✏️ Edit action", sub_action=result["action"])
+            
+            if result["action"] == "show_updated_preview":
+                # Field was updated, regenerate preview
+                updated_state = {**current_state, "draft": result["draft"]}
+                preview_result = await generate_and_show_preview(user_id, result["draft"], language)
+                
+                return {
+                    "action": "show_updated_preview",
+                    "message": result["message"],
+                    "preview": preview_result["preview_text"],
+                    "field": result["field"],
+                    "state": preview_result["state"],
+                }
+            else:
+                # Need more info from user
+                return {
+                    "action": result["action"],
+                    "message": result["message"],
+                    "field": result.get("field"),
+                    "state": current_state,
+                }
+        
+        # ========== DISCARD ==========
+        elif result["action"] == "discarded":
+            logger.info("❌ Draft discarded")
+            
+            return {
+                "action": "discarded",
+                "message": result["message"],
+                "next_state": result["next_state"],
+            }
+        
+        # ========== ADD IMAGE ==========
+        elif result["action"] == "add_image":
+            logger.info("📸 Adding more images")
+            
+            return {
+                "action": "add_image",
+                "message": result["message"],
+                "state": current_state,
+            }
+        
+        # ========== UNCLEAR ==========
+        else:
+            logger.warning("⚠️ Unclear action")
+            
+            return {
+                "action": "unclear",
+                "message": result["message"],
+                "state": current_state,
+            }
+    
+    # ========== 7. GET STATE STATUS ==========
+    def get_status(self, state: Dict) -> Dict:
+        """
+        Get current status of listing process
+        """
+        
+        status = state.get("status", "unknown")
+        language = state.get("language", "en")
+        
+        raw_state = state.get("raw_state", {})
+        images_status = get_images_status(raw_state, language)
+        
+        return {
+            "status": status,
+            "provided_fields": state.get("provided_fields", {}),
+            "missing_fields": state.get("missing_fields", []),
+            "images": {
+                "count": images_status["count"],
+                "has_images": images_status["has_images"],
+                "can_generate_draft": images_status["can_generate_draft"],
+            },
+        }
+
+
+# ========== EXAMPLE USAGE ==========
+"""
+# Initialize service
+service = PropertyListingService()
+
+# Step 1: User says "I want to list"
+result = await service.start_listing(
+    user_id="user123",
+    user_role="landlord",
+    language="en"
+)
+# Shows example, returns initial state
+
+# Step 2: User provides property details
+result = await service.continue_listing(
+    user_input="I have a 2-bed apartment in Lagos for 50k monthly with wifi",
+    current_state=result["state"]
+)
+# If all fields complete and images present → show preview
+# If missing fields → ask for next field
+# If fields complete but no images → ask for images
+
+# Step 3: User uploads image
+result = await service.upload_image(
+    image_base64="base64_encoded_image",
+    mime_type="image/jpeg",
+    current_state=result["state"]
+)
+# Image uploaded to Cloudflare, URL saved
+
+# Step 4: Generate draft (if images present)
+result = await service.generate_draft(current_state=result["state"])
+# Shows formatted preview
+
+# Step 5: User takes action (publish/edit/discard)
+result = await service.handle_post_draft_action(
+    user_input="Publish this",
+    current_state=result["state"]
+)
+# Publishes to MongoDB, returns mongo_id
+"""
+
+
+# ========== TEST ==========
+if __name__ == "__main__":
+    import asyncio
+    
+    async def test():
+        print("\n" + "="*70)
+        print("🧪 UNIFIED PROPERTY LISTING SERVICE TEST")
+        print("="*70 + "\n")
+        
+        service = PropertyListingService()
+        
+        # Test 1: Start listing
+        print("1️⃣ Start listing")
+        result = await service.start_listing(
+            user_id="user123",
+            user_role="landlord",
+            language="en"
+        )
+        print(f"   Action: {result['action']}")
+        print(f"   Example: {result['example'][:100]}...\n")
+        state = result["state"]
+        
+        # Test 2: Continue listing
+        print("2️⃣ Continue listing - provide property info")
+        result = await service.continue_listing(
+            user_input="I have a 2-bed, 1-bath apartment in Lagos for 50k monthly with wifi and parking",
+            current_state=state
+        )
+        print(f"   Action: {result['action']}")
+        print(f"   Message: {result.get('message', result.get('question', ''))[:80]}...\n")
+        state = result["state"]
+        
+        # Test 3: Check status
+        print("3️⃣ Check status")
+        status = service.get_status(state)
+        print(f"   Status: {status['status']}")
+        print(f"   Missing fields: {status['missing_fields']}")
+        print(f"   Has images: {status['images']['has_images']}\n")
+    
+    asyncio.run(test())

app/ai/state.py

@@ -1,53 +0,0 @@
-# app/ai/state.py - Complete State Definition for LangGraph
-from typing import TypedDict, List, Optional, Dict, Any
-
-class ChatState(TypedDict, total=False):
-    """Complete state for Aida AI conversation"""
-    
-    # ============ User Info ============
-    user_id: str                    # Current user ID
-    user_role: str                  # 'landlord' or 'renter'
-    user_language: str              # Detected language (English, French, Yoruba, etc)
-    
-    # ============ Conversation ============
-    messages: List[Dict[str, str]]  # Chat history: [{"role": "user"/"assistant", "content": "..."}]
-    
-    # ============ Intent & Status ============
-    intent: str                     # 'list' | 'search' | 'greeting' | 'my_listings'
-    status: str                     # Current flow state
-    allowed: bool                   # Permission check passed?
-    
-    # ============ Listing Creation Fields ============
-    location: Optional[str]         # City name
-    bedrooms: Optional[int]         # Number of bedrooms
-    bathrooms: Optional[int]        # Number of bathrooms
-    price: Optional[float]          # Price amount
-    price_type: Optional[str]       # 'monthly' | 'nightly' | 'yearly'
-    listing_type: Optional[str]     # 'rent' | 'short-stay' | 'sale' | 'roommate'
-    amenities: List[str]            # List of amenities
-    requirements: Optional[str]     # Special requirements
-    currency: Optional[str]         # Currency code (XOF, NGN, EUR, etc)
-    
-    # ============ Search Fields ============
-    search_query: Optional[str]     # User's search query
-    min_price: Optional[float]      # Minimum price filter
-    max_price: Optional[float]      # Maximum price filter
-    
-    # ============ Collection Flow ============
-    missing_fields: List[str]       # Fields still needed
-    next_question: Optional[str]    # Next question to ask user
-    
-    # ============ Draft & Preview ============
-    draft_preview: Optional[Dict[str, Any]]  # Formatted draft shown to user
-    
-    # ============ Publishing ============
-    mongo_id: Optional[str]         # MongoDB ID after publish
-    
-    # ============ Images ============
-    image_urls: List[str]           # Cloudflare image URLs
-    
-    # ============ Results ============
-    search_results: List[Dict[str, Any]]  # Search results
-    
-    # ============ AI Response ============
-    ai_reply: str                   # What Aida says to user

main.py

@@ -1,8 +1,15 @@
-# ============================================================
-# app/main.py – FastAPI + Aida AI Agent
-# ============================================================
+# app/main.py - FastAPI + Aida AI (Updated with new modular architecture)
+"""
+Lojiz Platform with Aida AI - Modular Architecture
+- Intent detection
+- Property listing service
+- Image upload (Cloudflare)
+- Draft & preview
+- Redis memory
+- MongoDB integration
+"""
 
-from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from fastapi.exceptions import RequestValidationError
@@ -10,7 +17,11 @@ from contextlib import asynccontextmanager
 import logging
 import os
 
-# ---------- core imports ----------
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ========== IMPORTS ==========
 try:
     from app.config import settings
     from app.database import connect_db, disconnect_db, ensure_indexes as ensure_auth_indexes
@@ -19,106 +30,148 @@ try:
     from app.core.exceptions import AuthException
     setup_logger()
 except ImportError as e:
-    logging.basicConfig(level=logging.INFO)
-    logger = logging.getLogger(__name__)
-    logger.error(f"Import error: {e}")
-
+    logger.error(f"❌ Core import error: {e}")
     class AuthException(Exception):
-        def __init__(self, status_code=500, detail="Error", error_code="ERROR", message="Error"):
-            self.status_code = status_code
-            self.detail = detail
-            self.error_code = error_code
+        """Fallback AuthException"""
+        def __init__(self, message="Auth error", error_code="AUTH_ERROR", status_code=401, data=None):
             self.message = message
-            self.data = {}
+            self.error_code = error_code
+            self.status_code = status_code
+            self.data = data
+            super().__init__(self.message)
 
-logger = logging.getLogger(__name__)
+# ========== NEW AIDA IMPORTS ==========
+from app.ai.routes.chat import router as ai_chat_router
+from app.ai.config import (
+    validate_ai_startup,
+    check_redis_health,
+    check_qdrant_health,
+    redis_client,
+    qdrant_client,
+)
+from app.ai.memory.redis_context_memory import get_memory_manager
+from app.ml.models.ml_listing_extractor import get_ml_extractor
+from app.models.listing import ensure_listing_indexes
 
-# ---------- AI imports ----------
-try:
-    from app.ai.routes.chat import router as ai_chat_router
-    AI_AVAILABLE = True
-    logger.info("✅ AI chat router imported successfully")
-except ImportError as e:
-    logger.warning(f"⚠️ AI chat router not available: {e}")
-    AI_AVAILABLE = False
-    ai_chat_router = None
+logger = logging.getLogger(__name__)
 
-# ---------- Existing imports ----------
-try:
-    from app.models.listing import ensure_listing_indexes
-except ImportError:
-    logger.warning("⚠️ Listing models not available")
+# ========== ENVIRONMENT ==========
+environment = os.getenv("ENVIRONMENT", "development")
+is_production = environment == "production"
 
-# ====================================================================
-# Lifespan – Startup & Shutdown
-# ====================================================================
+# ========== LIFESPAN ==========
 @asynccontextmanager
 async def lifespan(app: FastAPI):
+    """
+    Application lifespan - startup and shutdown
+    """
+    
     logger.info("=" * 70)
-    logger.info("🚀 Starting Lojiz Platform + Aida AI")
+    logger.info("🚀 Starting Lojiz Platform + Aida AI (Modular Architecture)")
     logger.info("=" * 70)
-
-    # 1. MongoDB – critical, must succeed
+    
+    # ========== STARTUP ==========
     try:
+        # 1. Connect to MongoDB - CRITICAL
+        logger.info("📦 Connecting to MongoDB...")
         await connect_db()
         await ensure_auth_indexes()
-        try:
-            await ensure_listing_indexes()
-        except:
-            logger.warning("⚠️ Could not ensure listing indexes")
+        await ensure_listing_indexes()
         logger.info("✅ MongoDB connected & indexed")
     except Exception as e:
-        logger.critical("❌ MongoDB unavailable – aborting start", exc_info=e)
+        logger.critical(f"❌ MongoDB connection failed - aborting startup: {e}")
         raise
-
-    # 2. Redis – optional at boot
+    
+    # 2. Redis - IMPORTANT
     try:
-        from app.ai.memory.redis_memory import load_history
-        logger.info("✅ Redis connection available")
+        logger.info("🔴 Connecting to Redis...")
+        if redis_client:
+            await redis_client.ping()
+            logger.info("✅ Redis connected")
+        else:
+            logger.warning("⚠️ Redis not available (optional)")
     except Exception as e:
-        logger.warning(f"⚠️ Redis warning: {e}")
-
-    # 3. Qdrant – optional at boot
+        logger.warning(f"⚠️ Redis connection failed (continuing without): {e}")
+    
+    # 3. Qdrant - IMPORTANT
     try:
-        from app.ai.config import qdrant_client
-        await qdrant_client.get_collections()
-        logger.info("✅ Qdrant connected")
+        logger.info("🟦 Connecting to Qdrant...")
+        if qdrant_client:
+            await qdrant_client.get_collections()
+            logger.info("✅ Qdrant connected")
+        else:
+            logger.warning("⚠️ Qdrant not available (optional)")
     except Exception as e:
-        logger.warning(f"⚠️ Qdrant warning: {e}")
-
+        logger.warning(f"⚠️ Qdrant connection failed (continuing without): {e}")
+    
+    # 4. Validate AI Components
+    try:
+        logger.info("🧠 Validating AI components...")
+        ai_checks = await validate_ai_startup()
+        logger.info("✅ AI components validated")
+    except Exception as e:
+        logger.warning(f"⚠️ AI validation failed: {e}")
+    
+    # 5. ML Extractor
+    try:
+        logger.info("🤖 Initializing ML Extractor...")
+        ml = get_ml_extractor()
+        logger.info("✅ ML Extractor ready")
+    except Exception as e:
+        logger.warning(f"⚠️ ML Extractor initialization failed: {e}")
+    
+    # 6. Memory Manager
+    try:
+        logger.info("💾 Initializing Memory Manager...")
+        manager = get_memory_manager()
+        logger.info("✅ Memory Manager ready")
+    except Exception as e:
+        logger.warning(f"⚠️ Memory Manager initialization failed: {e}")
+    
     logger.info("=" * 70)
-    logger.info("✨ Application ready to handle requests")
+    logger.info("✅ APPLICATION READY - All systems operational!")
     logger.info("=" * 70)
-
+    
     yield
-
-    # SHUTDOWN
+    
+    # ========== SHUTDOWN ==========
     logger.info("=" * 70)
-    logger.info("🛑 Shutting down Lojiz Platform")
+    logger.info("🛑 Shutting down Lojiz Platform + Aida AI")
     logger.info("=" * 70)
     
     try:
+        # Clear ML caches
+        try:
+            ml = get_ml_extractor()
+            ml.currency_mgr.clear_cache()
+            logger.info("✅ ML caches cleared")
+        except:
+            pass
+        
+        # Disconnect from MongoDB
+        from app.database import disconnect_db
         await disconnect_db()
         logger.info("✅ MongoDB disconnected")
+        
+        # Close Redis
+        if redis_client:
+            await redis_client.close()
+            logger.info("✅ Redis closed")
+        
+        logger.info("✅ Shutdown complete")
     except Exception as e:
         logger.warning(f"⚠️ Shutdown warning: {e}")
 
-# ====================================================================
-# FastAPI instance
-# ====================================================================
+
+# ========== FASTAPI SETUP ==========
 app = FastAPI(
     title="Lojiz Platform + Aida AI",
-    description="Conversational real-estate agent with secure auth & ML features",
+    description="Real-estate platform with conversational AI assistant",
     version="1.0.0",
     lifespan=lifespan,
 )
 
-# ====================================================================
-# CORS
-# ====================================================================
-environment = os.getenv("ENVIRONMENT", "development")
-is_production = environment == "production"
-
+# ========== CORS ==========
 cors_origins = [
     "https://lojiz.onrender.com",
     "https://lojiz.com",
@@ -127,34 +180,26 @@ cors_origins = [
     "http://localhost",
     "http://localhost:3000",
     "http://localhost:5173",
-    "http://localhost:8080",
-    "http://localhost:55211",
     "http://127.0.0.1",
     "http://127.0.0.1:3000",
-    "http://127.0.0.1:5000",
+    "http://127.0.0.1:5173",
     "http://127.0.0.1:8080",
-    "http://127.0.0.1:56205",
-    "https://destinyebuka-aida.hf.space",  # Add for HF Spaces deployment
 ]
 
 app.add_middleware(
     CORSMiddleware,
     allow_origins=cors_origins,
     allow_credentials=True,
-    allow_methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"],
+    allow_methods=["*"],
     allow_headers=["*"],
     expose_headers=["*"],
     max_age=600,
 )
 
-logger.info(f"✅ CORS configured for {len(cors_origins)} origins")
-
-# ====================================================================
-# Exception handlers
-# ====================================================================
+# ========== EXCEPTION HANDLERS ==========
 @app.exception_handler(RequestValidationError)
 async def validation_exception_handler(request: Request, exc: RequestValidationError):
-    logger.error(f"Validation error: {exc}")
+    logger.error(f"❌ Validation error: {exc}")
     errors = []
     for error in exc.errors():
         field = ".".join(str(loc) for loc in error["loc"][1:])
@@ -163,23 +208,23 @@ async def validation_exception_handler(request: Request, exc: RequestValidationE
         status_code=400,
         content={
             "success": False,
-            "message": "Validation error. Please check your input.",
-            "error_code": "VALIDATION_ERROR",
             "errors": errors,
         },
     )
 
+
 @app.exception_handler(AuthException)
 async def auth_exception_handler(request: Request, exc: AuthException):
-    logger.warning(f"Auth error [{exc.error_code}]: {exc.message}")
+    logger.warning(f"🔐 Auth error [{exc.error_code}]: {exc.message}")
     response = {"success": False, "message": exc.message, "error_code": exc.error_code}
     if exc.data:
         response["data"] = exc.data
     return JSONResponse(status_code=exc.status_code, content=response)
 
-@app.exception_handler(Exception)
-async def general_exception_handler(request: Request, exc: Exception):
-    logger.error(f"Unexpected error: {str(exc)}", exc_info=True)
+
+@app.exception_handler(BaseException)
+async def general_exception_handler(request: Request, exc: BaseException):
+    logger.error(f"❌ Unexpected error: {str(exc)}", exc_info=True)
     return JSONResponse(
         status_code=500,
         content={
@@ -190,52 +235,119 @@ async def general_exception_handler(request: Request, exc: Exception):
         },
     )
 
-# ====================================================================
-# Routers
-# ====================================================================
-# Authentication routes (EXISTING)
+
+# ========== ROUTERS ==========
+logger.info("📡 Registering routers...")
+
+# Authentication routes
 app.include_router(auth.router, prefix="/api/auth", tags=["Authentication"])
 
-# Aida AI Chat routes (NEW)
-if AI_AVAILABLE and ai_chat_router:
-    app.include_router(ai_chat_router, prefix="/ai", tags=["Aida AI Chat"])
-    logger.info("✅ Aida AI chat router loaded at /ai")
-else:
-    logger.warning("⚠️ Aida AI chat router NOT loaded - endpoint will not be available")
+# Aida AI Chat routes
+app.include_router(ai_chat_router, prefix="/ai", tags=["Aida AI Chat"])
+
+logger.info("✅ All routers registered")
+
+
+# ========== ENDPOINTS ==========
 
-# ====================================================================
-# Health & Status Endpoints
-# ====================================================================
 @app.get("/health", tags=["Health"])
 async def health_check():
-    """Health check endpoint"""
-    return {
-        "status": "ok",
-        "service": "Lojiz Platform + Aida AI",
-        "version": "1.0.0",
-        "environment": environment,
-        "ai_available": AI_AVAILABLE,
-    }
+    """
+    Health check endpoint
+    """
+    
+    try:
+        # Check Redis
+        redis_ok = False
+        if redis_client:
+            try:
+                await redis_client.ping()
+                redis_ok = True
+            except:
+                redis_ok = False
+        
+        # Check Qdrant
+        qdrant_ok = False
+        if qdrant_client:
+            try:
+                await qdrant_client.get_collections()
+                qdrant_ok = True
+            except:
+                qdrant_ok = False
+        
+        # Check ML
+        try:
+            ml = get_ml_extractor()
+            ml_ok = ml is not None
+        except:
+            ml_ok = False
+        
+        return {
+            "status": "healthy",
+            "service": "Lojiz Platform + Aida AI",
+            "version": "1.0.0",
+            "environment": environment,
+            "components": {
+                "mongodb": "connected",
+                "redis": "connected" if redis_ok else "disconnected",
+                "qdrant": "connected" if qdrant_ok else "disconnected",
+                "ml": "ready" if ml_ok else "not ready",
+            }
+        }
+    except Exception as e:
+        logger.error(f"❌ Health check failed: {e}")
+        return {
+            "status": "unhealthy",
+            "error": str(e),
+        }
+
 
 @app.get("/", tags=["Root"])
 async def root():
-    """Root endpoint"""
+    """
+    Root endpoint - API information
+    """
     return {
         "message": "Welcome to Lojiz Platform + Aida AI",
         "docs": "/docs",
         "health": "/health",
         "environment": environment,
-        "endpoints": {
-            "auth": "/api/auth",
-            "ai_chat": "/ai/ask" if AI_AVAILABLE else "NOT AVAILABLE",
-        }
+        "version": "1.0.0",
+        "description": "Real-estate platform with conversational AI assistant (Aida)",
     }
 
+
 @app.options("/{full_path:path}", include_in_schema=False)
 async def options_handler(full_path: str):
-    """Handle CORS preflight requests"""
+    """
+    Handle CORS preflight requests
+    """
     return JSONResponse(status_code=200, content={})
 
-# ====================================================================
-# Run: uvicorn app.main:app --reload
-# ====================================================================
+
+# ========== STARTUP LOGGING ==========
+@app.on_event("startup")
+async def startup_event():
+    """Log startup"""
+    logger.info("🚀 FastAPI application started")
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Log shutdown"""
+    logger.info("🛑 FastAPI application shutdown")
+
+
+# ========== RUN ==========
+"""
+To run this application:
+
+Development:
+    uvicorn app.main:app --reload
+
+Production:
+    gunicorn -w 4 -k uvicorn.workers.UvicornWorker app.main:app
+
+HF Spaces:
+    python app.py
+"""