fyp

app/ai/graph.py

@@ -1,101 +0,0 @@
-# app/ai/graph.py - COMPLETE LANGGRAPH WORKFLOW
-from langgraph.graph import StateGraph, START, END
-from typing import Dict
-from structlog import get_logger
-
-from app.ai.state import ChatState
-from app.ai.nodes.intent_node import intent_node
-from app.ai.nodes.draft_node import draft_node
-from app.ai.nodes.search_node import search_node
-from app.ai.nodes.publish_node import publish_node
-
-logger = get_logger(__name__)
-
-# ============================================
-# BUILD WORKFLOW
-# ============================================
-workflow = StateGraph(ChatState)
-
-# ===== ADD NODES =====
-workflow.add_node("intent", intent_node)
-workflow.add_node("draft", draft_node)
-workflow.add_node("search", search_node)
-workflow.add_node("publish", publish_node)
-
-
-# ===== ROUTING LOGIC =====
-def route_from_intent(state: Dict) -> str:
-    """Route based on intent"""
-    intent = state.get("intent")
-    
-    logger.info(f"🔀 Routing from intent", intent=intent)
-    
-    if intent == "list":
-        return "draft"
-    elif intent == "search":
-        return "search"
-    elif intent == "my_listings":
-        return "search"  # Reuse search node
-    else:
-        return END
-
-
-def route_from_draft(state: Dict) -> str:
-    """Route from draft"""
-    status = state.get("status")
-    
-    logger.info(f"🔀 Routing from draft", status=status)
-    
-    if status == "publishing":
-        return "publish"
-    elif status == "discarded":
-        return END
-    elif status == "preview_shown":
-        return END
-    else:
-        return END
-
-
-def route_after_publish(state: Dict) -> str:
-    """Route after publish"""
-    logger.info(f"🔀 Routing after publish")
-    return END
-
-
-# ===== ADD EDGES =====
-
-# Start → Intent (always start here)
-workflow.add_edge(START, "intent")
-
-# Intent → Draft/Search/End (conditional)
-workflow.add_conditional_edges(
-    "intent",
-    route_from_intent,
-    {
-        "draft": "draft",
-        "search": "search",
-        END: END,
-    }
-)
-
-# Draft → Publish/End (conditional)
-workflow.add_conditional_edges(
-    "draft",
-    route_from_draft,
-    {
-        "publish": "publish",
-        END: END,
-    }
-)
-
-# Publish → End
-workflow.add_edge("publish", END)
-
-# Search → End
-workflow.add_edge("search", END)
-
-
-# ===== COMPILE =====
-agent = workflow.compile()
-
-logger.info("✅ LangGraph workflow compiled successfully")

app/ai/routes/chat.py

@@ -1,29 +1,17 @@
-# app/ai/routes/chat.py - FIXED: Better context handling & session management
-"""
-Chat Endpoint - Main integration point.
-
-Flow:
-1. Authenticate user
-2. Validate/clear stale session if needed
-3. Handle image upload (if present)
-4. Process message with LLM tool calling (intent detection + routing)
-5. Save to memory
-6. Return response to frontend
-"""
+# app/ai/routes/chat.py
+# Chat Endpoint - Intent detection & tool routing
+# Image uploads use SEPARATE endpoint /ai/upload-image
 
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi.security import HTTPBearer
 from pydantic import BaseModel
-from typing import Optional, List, Dict, Any
+from typing import Optional, Dict, Any
 from structlog import get_logger
 from datetime import datetime, timedelta
 
 from app.guards.jwt_guard import decode_access_token
 from app.ai.memory.redis_context_memory import get_current_memory
 from app.ai.tools.intent_detector_tool import process_user_message
-from app.ai.tools.listing_tool import process_listing
-from app.ai.tools.casual_chat_tool import process_casual_chat
-from app.ai.services.image_service import upload_to_cloudflare
 from app.ai.memory.redis_memory import is_rate_limited
 
 logger = get_logger(__name__)
@@ -32,14 +20,12 @@ router = APIRouter()
 security = HTTPBearer()
 
 
-# ========== REQUEST/RESPONSE MODELS ==========
+# REQUEST/RESPONSE MODELS
 class AskBody(BaseModel):
     message: str
     session_id: Optional[str] = None
     thread_id: Optional[str] = None
-    image_file: Optional[bytes] = None
-    image_mime: Optional[str] = None
-    start_new_session: Optional[bool] = False  # NEW: Allow client to start fresh
+    start_new_session: Optional[bool] = False
 
 
 class ChatResponse(BaseModel):
@@ -52,13 +38,9 @@ class ChatResponse(BaseModel):
     error: Optional[str] = None
 
 
-# ========== HELPER: Clear stale context ==========
+# HELPER: Clear stale context
 async def should_reset_context(context: Dict) -> bool:
-    """
-    Determine if context should be reset based on:
-    - User has been idle for 30+ minutes
-    - Session is in incomplete state for too long
-    """
+    """Determine if context should be reset"""
     
     if not context or not context.get("last_activity"):
         return False
@@ -69,7 +51,7 @@ async def should_reset_context(context: Dict) -> bool:
         
         # Reset if idle for more than 30 minutes
         if idle_time > timedelta(minutes=30):
-            logger.info("⏱️ Session idle for 30+ minutes, resetting context")
+            logger.info("Session idle for 30+ minutes, resetting context")
             return True
         
         return False
@@ -90,13 +72,9 @@ def reset_context() -> Dict:
     }
 
 
-# ========== HELPER: Detect if user wants to start fresh ==========
+# HELPER: Detect if user wants to start fresh
 def user_wants_fresh_start(message: str) -> bool:
-    """
-    Detect if user is trying to start a new conversation:
-    - "start fresh", "new listing", "clear", "reset"
-    - "start over", "begin again", "clear session"
-    """
+    """Detect if user is trying to start a new conversation"""
     
     message_lower = message.lower().strip()
     fresh_start_keywords = [
@@ -113,13 +91,13 @@ def user_wants_fresh_start(message: str) -> bool:
     ]
     
     if any(keyword in message_lower for keyword in fresh_start_keywords):
-        logger.info("🔄 User requested fresh start")
+        logger.info("User requested fresh start")
         return True
     
     return False
 
 
-# ========== MAIN CHAT ENDPOINT ==========
+# MAIN CHAT ENDPOINT
 @router.post("/ask", response_model=ChatResponse)
 async def ask_ai(
     body: AskBody,
@@ -128,47 +106,39 @@ async def ask_ai(
     """
     Main chat endpoint - Intent detection & tool routing.
     
-    Flow:
-    1. Authenticate
-    2. Rate limit check
-    3. Get session memory
-    4. Check if context should be reset (idle/stale)
-    5. Handle image upload (if present)
-    6. Process message with LLM (intent detection + tool calling)
-    7. Save to memory
-    8. Return response
+    IMPORTANT: Images are NOT handled here.
+    Use POST /ai/upload-image for image uploads.
     """
     
     try:
-        # ========== 1. AUTHENTICATE ==========
+        # AUTHENTICATE
         payload = decode_access_token(token.credentials)
         if not payload:
-            logger.warning("🔓 Invalid token")
+            logger.warning("Invalid token")
             raise HTTPException(status_code=401, detail="Invalid token")
         
         user_id = payload["user_id"]
         user_role = payload.get("role", "renter")
         
-        # ========== 2. RATE LIMIT CHECK ==========
+        # RATE LIMIT CHECK
         if await is_rate_limited(user_id):
-            logger.warning("⚠️ Rate limit exceeded", user_id=user_id)
+            logger.warning("Rate limit exceeded", user_id=user_id)
             raise HTTPException(status_code=429, detail="Rate limit exceeded")
         
-        # ========== 3. GET SESSION MEMORY ==========
+        # GET SESSION MEMORY
         session_id = body.session_id or "default"
         memory = await get_current_memory(user_id, session_id)
         context = await memory.get_context()
         
         logger.info(
-            "💬 Chat message received",
+            "Chat message received",
             user_id=user_id,
             session_id=session_id,
             status=context.get("status"),
-            has_image=body.image_file is not None,
             message_len=len(body.message) if body.message else 0
         )
         
-        # ========== 4. CHECK IF CONTEXT SHOULD BE RESET ==========
+        # CHECK IF CONTEXT SHOULD BE RESET
         should_reset = (
             body.start_new_session or
             user_wants_fresh_start(body.message) or
@@ -176,15 +146,13 @@ async def ask_ai(
         )
         
         if should_reset:
-            logger.info("🔄 Resetting context", user_id=user_id, session_id=session_id)
+            logger.info("Resetting context", user_id=user_id, session_id=session_id)
             context = reset_context()
             context["user_role"] = user_role
             await memory.update_context(context)
-            
-            # Clear message history too
             await memory.clear()
             
-            response_msg = "✨ Fresh start! What can I help you with? I can help you list a property, search for one, or just chat!"
+            response_msg = "Fresh start! What can I help you with? I can help you list a property, search for one, or just chat!"
             
             return ChatResponse(
                 success=True,
@@ -193,70 +161,19 @@ async def ask_ai(
                 state=context
             )
         
-        # ========== 5. HANDLE IMAGE UPLOAD (if present) ==========
-        if body.image_file:
-            logger.info("📸 Image upload request")
-            
-            success, image_url, error = await upload_to_cloudflare(
-                image_bytes=body.image_file,
-                mime_type=body.image_mime or "image/jpeg",
-            )
-            
-            if not success:
-                logger.error("❌ Image upload failed", error=error)
-                return ChatResponse(
-                    success=False,
-                    text=f"❌ Image upload failed: {error}",
-                    action="error",
-                    error=error
-                )
-            
-            logger.info("✅ Image URL received from Cloudflare", url=image_url[:50] + "...")
-            
-            # Update state with image URL
-            if "state" not in context:
-                context["state"] = {}
-            
-            if "images" not in context["state"]:
-                context["state"]["images"] = []
-            
-            context["state"]["images"].append(image_url)
-            context["last_activity"] = datetime.utcnow().isoformat()
-            
-            # Add to message history
-            user_message = f"[Image uploaded: {image_url}]"
-            await memory.add_message("user", user_message)
-            await memory.update_context(context)
-            
-            logger.info(
-                "💾 Image URL saved to state",
-                total_images=len(context["state"]["images"]),
-                user_id=user_id
-            )
-            
-            # Return success
-            total = len(context["state"]["images"])
-            return ChatResponse(
-                success=True,
-                text=f"✅ Image uploaded successfully!\n\nYou now have {total} image(s).\n\nYou can:\n• Add more images\n• Generate preview\n• Continue with next step",
-                action="image_uploaded",
-                state=context
-            )
-        
-        # ========== 6. VALIDATE MESSAGE ==========
+        # VALIDATE MESSAGE
         if not body.message or body.message.strip() == "":
             return ChatResponse(
                 success=False,
-                text="Please provide a message or upload an image.",
+                text="Please provide a message.",
                 action="error",
                 error="Empty message"
             )
         
-        # ========== 7. PROCESS MESSAGE WITH LLM (INTENT DETECTION + TOOL CALLING) ==========
-        logger.info("🚀 Processing user message with LLM", user_id=user_id)
+        # PROCESS MESSAGE WITH LLM
+        logger.info("Processing user message with LLM", user_id=user_id)
         
         try:
-            # Process with LLM - includes intent detection + tool calling
             reply, tool_result = await process_user_message(
                 user_message=body.message,
                 user_id=user_id,
@@ -265,25 +182,23 @@ async def ask_ai(
             )
             
             logger.info(
-                "✅ LLM processing complete",
+                "LLM processing complete",
                 tool_called=tool_result.get("tool"),
                 success=tool_result.get("success")
             )
             
-            # Add user message to history
+            # Add messages to history
             await memory.add_message("user", body.message)
-            
-            # Add assistant reply to history
             await memory.add_message("assistant", reply)
             
-            # Update context with latest state and activity timestamp
+            # Update context
             context["last_activity"] = datetime.utcnow().isoformat()
             if "tool" in tool_result:
                 context["last_tool"] = tool_result["tool"]
             
             await memory.update_context(context)
             
-            # ========== 8. RETURN RESPONSE ==========
+            # RETURN RESPONSE
             return ChatResponse(
                 success=tool_result.get("success", True),
                 text=reply,
@@ -293,7 +208,7 @@ async def ask_ai(
             )
         
         except Exception as e:
-            logger.error("❌ LLM processing error", exc_info=e)
+            logger.error("LLM processing error", exc_info=e)
             
             fallback_reply = "Sorry, I had an error processing your request. Please try again."
             await memory.add_message("user", body.message)
@@ -313,14 +228,14 @@ async def ask_ai(
     except HTTPException:
         raise
     except Exception as e:
-        logger.error("❌ Chat endpoint error", exc_info=e)
+        logger.error("Chat endpoint error", exc_info=e)
         raise HTTPException(
             status_code=500,
             detail=f"Error processing message: {str(e)}"
         )
 
 
-# ========== HEALTH CHECK ==========
+# HEALTH CHECK
 @router.get("/health")
 async def health_check():
     """Health check for chat service"""
@@ -330,7 +245,7 @@ async def health_check():
     }
 
 
-# ========== GET CHAT HISTORY ==========
+# GET CHAT HISTORY
 @router.get("/history/{session_id}")
 async def get_chat_history(
     session_id: str,
@@ -349,7 +264,7 @@ async def get_chat_history(
         messages = await memory.get_messages()
         summary = await memory.get_summary()
         
-        logger.info("📖 Retrieved chat history", user_id=user_id, session_id=session_id)
+        logger.info("Retrieved chat history", user_id=user_id, session_id=session_id)
         
         return {
             "success": True,
@@ -360,11 +275,11 @@ async def get_chat_history(
     except HTTPException:
         raise
     except Exception as e:
-        logger.error("❌ Failed to get history", exc_info=e)
+        logger.error("Failed to get history", exc_info=e)
         raise HTTPException(status_code=500, detail="Failed to retrieve history")
 
 
-# ========== CLOSE SESSION ==========
+# CLOSE SESSION
 @router.post("/close-session/{session_id}")
 async def close_session(
     session_id: str,
@@ -383,7 +298,7 @@ async def close_session(
         manager = get_memory_manager()
         await manager.close_session(user_id, session_id)
         
-        logger.info("❌ Session closed", user_id=user_id, session_id=session_id)
+        logger.info("Session closed", user_id=user_id, session_id=session_id)
         
         return {
             "success": True,
@@ -393,11 +308,11 @@ async def close_session(
     except HTTPException:
         raise
     except Exception as e:
-        logger.error("❌ Failed to close session", exc_info=e)
+        logger.error("Failed to close session", exc_info=e)
         raise HTTPException(status_code=500, detail="Failed to close session")
 
 
-# ========== NEW: START FRESH ENDPOINT ==========
+# RESET SESSION
 @router.post("/reset-session/{session_id}")
 async def reset_session_endpoint(
     session_id: str,
@@ -405,7 +320,6 @@ async def reset_session_endpoint(
 ):
     """
     Explicitly reset a session to fresh state.
-    Useful for when user wants to start over without closing.
     """
     
     try:
@@ -424,7 +338,7 @@ async def reset_session_endpoint(
         fresh_context["user_role"] = user_role
         await memory.update_context(fresh_context)
         
-        logger.info("✨ Session reset to fresh state", user_id=user_id, session_id=session_id)
+        logger.info("Session reset to fresh state", user_id=user_id, session_id=session_id)
         
         return {
             "success": True,
@@ -435,5 +349,5 @@ async def reset_session_endpoint(
     except HTTPException:
         raise
     except Exception as e:
-        logger.error("❌ Failed to reset session", exc_info=e)
+        logger.error("Failed to reset session", exc_info=e)
         raise HTTPException(status_code=500, detail="Failed to reset session")

app/ai/routes/image_upload_routes.py

@@ -0,0 +1,164 @@
+# app/ai/routes/image_upload_routes.py
+# Dedicated image upload endpoint - handles image uploads to Cloudflare
+
+import base64
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.security import HTTPBearer
+from pydantic import BaseModel
+from typing import Optional
+from structlog import get_logger
+from datetime import datetime
+
+from app.guards.jwt_guard import decode_access_token
+from app.ai.memory.redis_context_memory import get_current_memory
+from app.ai.services.image_service import upload_to_cloudflare
+
+logger = get_logger(__name__)
+
+router = APIRouter()
+security = HTTPBearer()
+
+
+# REQUEST/RESPONSE MODELS
+class UploadImageBody(BaseModel):
+    image_data: str  # Base64 encoded image
+    mime_type: str  # e.g., "image/jpeg"
+    session_id: Optional[str] = None
+
+
+class ImageUploadResponse(BaseModel):
+    success: bool
+    image_url: Optional[str] = None
+    error: Optional[str] = None
+    message: Optional[str] = None
+
+
+# UPLOAD IMAGE ENDPOINT
+@router.post("/upload-image", response_model=ImageUploadResponse)
+async def upload_image(
+    body: UploadImageBody,
+    token: str = Depends(security),
+) -> ImageUploadResponse:
+    """
+    Upload image to Cloudflare.
+    
+    Flow:
+    1. Authenticate user
+    2. Decode base64 image
+    3. Upload to Cloudflare Images API
+    4. Return public URL
+    5. Save URL to user's state (optional)
+    """
+    
+    try:
+        # AUTHENTICATE
+        payload = decode_access_token(token.credentials)
+        if not payload:
+            logger.warning("Invalid token")
+            raise HTTPException(status_code=401, detail="Invalid token")
+        
+        user_id = payload["user_id"]
+        session_id = body.session_id or "default"
+        
+        logger.info(
+            "Image upload request received",
+            user_id=user_id,
+            session_id=session_id,
+            mime_type=body.mime_type,
+            data_len=len(body.image_data)
+        )
+        
+        # DECODE BASE64
+        try:
+            image_bytes = base64.b64decode(body.image_data)
+            logger.info(
+                "Base64 decoded",
+                size_bytes=len(image_bytes),
+                size_mb=len(image_bytes) / (1024 * 1024)
+            )
+        except Exception as e:
+            logger.error("Failed to decode base64", exc_info=e)
+            return ImageUploadResponse(
+                success=False,
+                error="Invalid base64 data"
+            )
+        
+        # VALIDATE IMAGE SIZE
+        max_size = 10 * 1024 * 1024  # 10 MB
+        if len(image_bytes) > max_size:
+            logger.warning(f"Image too large: {len(image_bytes)} bytes")
+            return ImageUploadResponse(
+                success=False,
+                error="Image too large (max 10 MB)"
+            )
+        
+        # UPLOAD TO CLOUDFLARE
+        logger.info("Uploading to Cloudflare...")
+        
+        success, image_url, error = await upload_to_cloudflare(
+            image_bytes=image_bytes,
+            mime_type=body.mime_type,
+            filename=f"property_{user_id}_{session_id}"
+        )
+        
+        if not success:
+            logger.error("Cloudflare upload failed", error=error)
+            return ImageUploadResponse(
+                success=False,
+                error=f"Upload failed: {error}"
+            )
+        
+        logger.info("Image uploaded to Cloudflare", url=image_url[:50] + "...")
+        
+        # SAVE URL TO STATE (Optional)
+        try:
+            memory = await get_current_memory(user_id, session_id)
+            context = await memory.get_context()
+            
+            # Add image URL to state
+            if "state" not in context:
+                context["state"] = {}
+            if "images" not in context["state"]:
+                context["state"]["images"] = []
+            
+            context["state"]["images"].append(image_url)
+            
+            # Update context
+            context["last_activity"] = datetime.utcnow().isoformat()
+            await memory.update_context(context)
+            
+            logger.info(
+                "Image URL saved to state",
+                total_images=len(context["state"]["images"]),
+                user_id=user_id
+            )
+        except Exception as e:
+            logger.warning(f"Failed to save URL to state: {e}")
+        
+        # RETURN SUCCESS
+        logger.info("Image upload complete", user_id=user_id)
+        
+        return ImageUploadResponse(
+            success=True,
+            image_url=image_url,
+            message="Image uploaded successfully!"
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Image upload endpoint error", exc_info=e)
+        return ImageUploadResponse(
+            success=False,
+            error=f"Server error: {str(e)}"
+        )
+
+
+# HEALTH CHECK
+@router.get("/upload-image/health")
+async def image_upload_health():
+    """Health check for image upload service"""
+    return {
+        "status": "healthy",
+        "service": "Image Upload",
+    }

main.py

@@ -1,7 +1,5 @@
-# app/main.py - FastAPI Application (FIXED - No circular imports)
-"""
-Lojiz Platform with Aida AI - Modular Architecture
-"""
+# app/main.py
+# Lojiz Platform with Aida AI - Modular Architecture
 
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
@@ -14,13 +12,13 @@ import os
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# ========== CORE IMPORTS ==========
+# CORE IMPORTS
 try:
     from app.config import settings
     from app.database import connect_db, disconnect_db, ensure_indexes as ensure_auth_indexes
     from app.routes import auth
 except ImportError as e:
-    logger.error(f"❌ Core import error: {e}")
+    logger.error(f"Core import error: {e}")
     raise
 
 try:
@@ -28,8 +26,9 @@ try:
 except ImportError:
     AuthException = Exception
 
-# ========== AI IMPORTS (DIRECT - NO CIRCULAR DEPENDENCY) ==========
+# AI IMPORTS
 from app.ai.routes.chat import router as ai_chat_router
+from app.ai.routes.image_upload_routes import router as image_upload_router
 from app.ai.config import (
     validate_ai_startup,
     check_redis_health,
@@ -43,104 +42,104 @@ from app.models.listing import ensure_listing_indexes
 
 logger = logging.getLogger(__name__)
 
-# ========== ENVIRONMENT ==========
+# ENVIRONMENT
 environment = os.getenv("ENVIRONMENT", "development")
 is_production = environment == "production"
 
-# ========== LIFESPAN ==========
+# LIFESPAN
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Application lifespan - startup and shutdown"""
     
     logger.info("=" * 70)
-    logger.info("🚀 Starting Lojiz Platform + Aida AI (Modular Architecture)")
+    logger.info("Starting Lojiz Platform + Aida AI (Modular Architecture)")
     logger.info("=" * 70)
     
-    # ========== STARTUP ==========
+    # STARTUP
     try:
-        logger.info("📦 Connecting to MongoDB...")
+        logger.info("Connecting to MongoDB...")
         await connect_db()
         await ensure_auth_indexes()
         await ensure_listing_indexes()
-        logger.info("✅ MongoDB connected & indexed")
+        logger.info("MongoDB connected and indexed")
     except Exception as e:
-        logger.critical(f"❌ MongoDB connection failed - aborting startup: {e}")
+        logger.critical(f"MongoDB connection failed - aborting startup: {e}")
         raise
     
     try:
-        logger.info("🔴 Connecting to Redis...")
+        logger.info("Connecting to Redis...")
         if redis_client:
             await redis_client.ping()
-            logger.info("✅ Redis connected")
+            logger.info("Redis connected")
         else:
-            logger.warning("⚠️ Redis not available (optional)")
+            logger.warning("Redis not available (optional)")
     except Exception as e:
-        logger.warning(f"⚠️ Redis connection failed (continuing without): {e}")
+        logger.warning(f"Redis connection failed (continuing without): {e}")
     
     try:
-        logger.info("🟦 Connecting to Qdrant...")
+        logger.info("Connecting to Qdrant...")
         if qdrant_client:
             await qdrant_client.get_collections()
-            logger.info("✅ Qdrant connected")
+            logger.info("Qdrant connected")
         else:
-            logger.warning("⚠️ Qdrant not available (optional)")
+            logger.warning("Qdrant not available (optional)")
     except Exception as e:
-        logger.warning(f"⚠️ Qdrant connection failed (continuing without): {e}")
+        logger.warning(f"Qdrant connection failed (continuing without): {e}")
     
     try:
-        logger.info("🧠 Validating AI components...")
+        logger.info("Validating AI components...")
         ai_checks = await validate_ai_startup()
-        logger.info("✅ AI components validated")
+        logger.info("AI components validated")
     except Exception as e:
-        logger.warning(f"⚠️ AI validation failed: {e}")
+        logger.warning(f"AI validation failed: {e}")
     
     try:
-        logger.info("🤖 Initializing ML Extractor...")
+        logger.info("Initializing ML Extractor...")
         ml = get_ml_extractor()
-        logger.info("✅ ML Extractor ready")
+        logger.info("ML Extractor ready")
     except Exception as e:
-        logger.warning(f"⚠️ ML Extractor initialization failed: {e}")
+        logger.warning(f"ML Extractor initialization failed: {e}")
     
     try:
-        logger.info("💾 Initializing Memory Manager...")
+        logger.info("Initializing Memory Manager...")
         manager = get_memory_manager()
-        logger.info("✅ Memory Manager ready")
+        logger.info("Memory Manager ready")
     except Exception as e:
-        logger.warning(f"⚠️ Memory Manager initialization failed: {e}")
+        logger.warning(f"Memory Manager initialization failed: {e}")
     
     logger.info("=" * 70)
-    logger.info("✅ APPLICATION READY - All systems operational!")
+    logger.info("APPLICATION READY - All systems operational!")
     logger.info("=" * 70)
     
     yield
     
-    # ========== SHUTDOWN ==========
+    # SHUTDOWN
     logger.info("=" * 70)
-    logger.info("🛑 Shutting down Lojiz Platform + Aida AI")
+    logger.info("Shutting down Lojiz Platform + Aida AI")
     logger.info("=" * 70)
     
     try:
         try:
             ml = get_ml_extractor()
             ml.currency_mgr.clear_cache()
-            logger.info("✅ ML caches cleared")
+            logger.info("ML caches cleared")
         except:
             pass
         
         from app.database import disconnect_db
         await disconnect_db()
-        logger.info("✅ MongoDB disconnected")
+        logger.info("MongoDB disconnected")
         
         if redis_client:
             await redis_client.close()
-            logger.info("✅ Redis closed")
+            logger.info("Redis closed")
         
-        logger.info("✅ Shutdown complete")
+        logger.info("Shutdown complete")
     except Exception as e:
-        logger.warning(f"⚠️ Shutdown warning: {e}")
+        logger.warning(f"Shutdown warning: {e}")
 
 
-# ========== FASTAPI SETUP ==========
+# FASTAPI SETUP
 app = FastAPI(
     title="Lojiz Platform + Aida AI",
     description="Real-estate platform with conversational AI assistant",
@@ -148,7 +147,7 @@ app = FastAPI(
     lifespan=lifespan,
 )
 
-# ========== CORS ==========
+# CORS
 cors_origins = [
     "https://lojiz.onrender.com",
     "https://lojiz.com",
@@ -173,10 +172,10 @@ app.add_middleware(
     max_age=600,
 )
 
-# ========== 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:])
@@ -194,23 +193,24 @@ async def validation_exception_handler(request: Request, exc: RequestValidationE
 
 @app.exception_handler(AuthException)
 async def auth_exception_handler(request: Request, exc: AuthException): # type: ignore
-    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)
 
 
-# ========== ROUTERS ==========
-logger.info("📡 Registering routers...")
+# ROUTERS
+logger.info("Registering routers...")
 
 app.include_router(auth.router, prefix="/api/auth", tags=["Authentication"])
 app.include_router(ai_chat_router, prefix="/ai", tags=["Aida AI Chat"])
+app.include_router(image_upload_router, prefix="/ai", tags=["Image Upload"])
 
-logger.info("✅ All routers registered")
+logger.info("All routers registered")
 
 
-# ========== ENDPOINTS ==========
+# ENDPOINTS
 
 @app.get("/health", tags=["Health"])
 async def health_check():
@@ -252,7 +252,7 @@ async def health_check():
             }
         }
     except Exception as e:
-        logger.error(f"❌ Health check failed: {e}")
+        logger.error(f"Health check failed: {e}")
         return {
             "status": "unhealthy",
             "error": str(e),
@@ -278,16 +278,8 @@ async def options_handler(full_path: str):
     return JSONResponse(status_code=200, content={})
 
 
-# ========== 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
-"""
+# 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