Deploy Lojiz Platform with Aida AI backend

.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}

Dockerfile

@@ -0,0 +1,35 @@
+# ============================================================
+# Dockerfile - For Render Deployment
+# ============================================================
+
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application
+COPY . .
+
+# Create non-root user
+RUN useradd -m appuser && chown -R appuser:appuser /app
+USER appuser
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:8000/health')"
+
+# Run application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -11,4 +11,379 @@ license: mit
 short_description: The ai model for Lojiz
 ---
 
+
+"""
+# Lojiz Authentication API - Python FastAPI Edition
+
+Modern, secure, and production-ready authentication backend built with FastAPI, MongoDB, and Resend.
+
+## Features
+
+✅ **Dual Authentication** - Email or phone-based signup & login
+✅ **OTP Verification** - 4-digit OTP with configurable expiry (15 min default)
+✅ **Password Reset** - Secure password reset flow with temporary tokens
+✅ **JWT Tokens** - 60-day login tokens + 10-minute reset tokens
+✅ **Bcrypt Hashing** - Industry-standard password hashing
+✅ **Email Templates** - Beautiful, responsive HTML email templates via Resend
+✅ **Rate Limiting** - OTP attempt limits (5 max attempts)
+✅ **MongoDB** - Async MongoDB with Motor driver
+✅ **API Documentation** - Auto-generated Swagger docs
+✅ **Production Ready** - Error handling, logging, security best practices
+
+## Prerequisites
+
+- Python 3.11+
+- MongoDB Atlas account (free tier available)
+- Resend account (for email sending)
+- Git & GitHub account
+- Render.com account (for deployment)
+
+## Local Development Setup
+
+### 1. Clone Repository
+```bash
+git clone https://github.com/yourusername/lojiz-auth-api.git
+cd lojiz-auth-api
+```
+
+### 2. Create Virtual Environment
+```bash
+python3 -m venv venv
+source venv/bin/activate  # On Windows: venv\\Scripts\\activate
+```
+
+### 3. Install Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+### 4. Setup Environment Variables
+```bash
+cp .env.example .env
+```
+
+Edit `.env` with:
+```
+DEBUG=True
+ENVIRONMENT=development
+MONGODB_URL=mongodb://localhost:27017
+MONGODB_DATABASE=lojiz
+JWT_SECRET=your-secret-key-here
+RESEND_API_KEY=your-resend-api-key
+RESEND_FROM_EMAIL=noreply@yourdomain.com
+```
+
+### 5. Run Application
+```bash
+uvicorn app.main:app --reload
+```
+
+Visit: http://localhost:8000/docs (Swagger UI)
+
+## Project Structure
+
+```
+lojiz-auth-api/
+├── app/
+│   ├── core/
+│   │   ├── security.py        # JWT & password hashing
+│   │   └── schemas.py         # Pydantic models
+│   ├── database.py            # MongoDB connection
+│   ├── config.py              # Configuration
+│   ├── models/
+│   │   ├── user.py            # User model
+│   │   └── otp.py             # OTP model
+│   ├── routes/
+│   │   └── auth.py            # Auth endpoints
+│   ├── services/
+│   │   ├── auth_service.py    # Auth logic
+│   │   ├── otp_service.py     # OTP logic
+│   │   └── user_service.py    # User logic
+│   ├── schemas/
+│   │   ├── auth.py            # Auth DTOs
+│   │   └── user.py            # User DTOs
+│   ├── guards/
+│   │   └── jwt_guard.py       # JWT auth
+│   ├── utils/
+│   │   └── logger.py          # Logging
+│   └── main.py                # App entry point
+├── requirements.txt
+├── .env.example
+├── .gitignore
+├── Dockerfile
+├── render.yaml
+└── README.md
+```
+
+## API Endpoints
+
+### Authentication
+
+**POST** `/api/auth/signup`
+- Create new account
+- Returns: Confirmation to check email/phone for OTP
+
+**POST** `/api/auth/verify-signup-otp`
+- Verify signup OTP
+- Returns: User data + JWT token
+
+**POST** `/api/auth/login`
+- Authenticate with email/phone + password
+- Returns: User data + JWT token
+
+**POST** `/api/auth/send-password-reset-otp`
+- Request password reset
+- Returns: Generic success (doesn't reveal if email exists)
+
+**POST** `/api/auth/verify-password-reset-otp`
+- Verify password reset OTP
+- Returns: Temporary reset token
+
+**POST** `/api/auth/reset-password`
+- Reset password with token
+- Header: `x-reset-token`
+
+**POST** `/api/auth/resend-otp`
+- Resend OTP for signup or password reset
+
+### User Profile
+
+**GET** `/api/auth/profile`
+- Get current user profile
+- Requires: Bearer token
+
+**POST** `/api/auth/logout`
+- Logout (client removes token)
+- Requires: Bearer token
+
+## MongoDB Setup
+
+### 1. Create MongoDB Atlas Account
+- Go to https://www.mongodb.com/cloud/atlas
+- Sign up for free
+- Create a project
+
+### 2. Create Cluster
+- Choose shared cluster (free)
+- Select region closest to your users
+- Create cluster
+
+### 3. Get Connection String
+- Click "Connect"
+- Choose "Drivers"
+- Copy connection string
+- Replace `<password>` and `myFirstDatabase` with actual values
+
+### 4. Update .env
+```
+MONGODB_URL=mongodb+srv://username:password@cluster.mongodb.net/lojiz?retryWrites=true&w=majority
+```
+
+### 5. Create Database Indexes (Auto-created on startup)
+- Email (unique, sparse)
+- Phone (unique, sparse)
+- Role
+- OTP TTL (15 minutes)
+
+## Resend Email Setup
+
+### 1. Create Resend Account
+- Go to https://resend.com
+- Sign up
+- Get API key from dashboard
+
+### 2. Verify Domain (Optional for Production)
+- Add domain to Resend
+- Update DNS records
+- Verify domain
+
+### 3. Update .env
+```
+RESEND_API_KEY=re_xxxxxxxxxxxxxxxxxxxx
+RESEND_FROM_EMAIL=noreply@yourdomain.com
+```
+
+## Password Requirements
+
+Passwords must contain:
+- Minimum 8 characters
+- At least one uppercase letter (A-Z)
+- At least one lowercase letter (a-z)
+- At least one digit (0-9)
+- At least one special character (!@#$%^&*(),.?\":{}|<>)
+
+Example: `SecurePass123!@`
+
+## Token Details
+
+### Login Token (JWT)
+- **Expiry**: 60 days
+- **Use Case**: Long-lived access token for normal users
+- **Payload**: user_id, email, phone, role
+
+### Reset Token (JWT)
+- **Expiry**: 10 minutes
+- **Use Case**: Short-lived token for password reset
+- **Payload**: identifier, purpose
+
+## Error Handling
+
+All endpoints return structured error responses:
+
+```json
+{
+  "success": false,
+  "message": "Error description",
+  "errors": {}
+}
+```
+
+Common HTTP Status Codes:
+- `200 OK` - Success
+- `400 Bad Request` - Validation/business logic error
+- `401 Unauthorized` - Invalid/missing token
+- `404 Not Found` - Resource not found
+- `409 Conflict` - Resource already exists
+- `500 Internal Server Error` - Server error
+
+## Deployment to Render.com
+
+### 1. Push to GitHub
+```bash
+git add .
+git commit -m "Initial commit"
+git push origin main
+```
+
+### 2. Deploy on Render
+- Go to https://render.com
+- Click "New +"
+- Select "Web Service"
+- Connect GitHub repository
+- Choose Python runtime
+- Set build command: `pip install -r requirements.txt`
+- Set start command: `uvicorn app.main:app --host 0.0.0.0 --port $PORT`
+
+### 3. Add Environment Variables
+Set in Render dashboard:
+```
+ENVIRONMENT=production
+DEBUG=False
+JWT_SECRET=(generate: python -c "import secrets; print(secrets.token_urlsafe(32))")
+MONGODB_URL=<your-mongodb-url>
+RESEND_API_KEY=<your-resend-key>
+RESEND_FROM_EMAIL=noreply@yourdomain.com
+```
+
+### 4. Monitor
+- Check deployment logs
+- Test health endpoint: https://your-app.render.com/health
+- View real-time logs in Render dashboard
+
+## Testing Endpoints
+
+### Using cURL
+
+**Signup:**
+```bash
+curl -X POST http://localhost:8000/api/auth/signup \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "first_name": "John",
+    "last_name": "Doe",
+    "email": "john@example.com",
+    "password": "SecurePass123!@",
+    "role": "renter"
+  }'
+```
+
+**Login:**
+```bash
+curl -X POST http://localhost:8000/api/auth/login \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "identifier": "john@example.com",
+    "password": "SecurePass123!@"
+  }'
+```
+
+**Get Profile:**
+```bash
+curl -X GET http://localhost:8000/api/auth/profile \\
+  -H "Authorization: Bearer <your-jwt-token>"
+```
+
+## Security Best Practices
+
+✅ Passwords hashed with bcrypt (10 rounds)
+✅ JWT tokens signed with HS256
+✅ Password reset tokens expire in 10 minutes
+✅ OTP expires in 15 minutes
+✅ Max 5 OTP attempts before deletion
+✅ CORS configured for specific origins
+✅ Sensitive data excluded from responses
+✅ Non-root user in Docker
+✅ HTTPS enforced in production
+✅ Environment variables for secrets
+
+## Troubleshooting
+
+### MongoDB Connection Error
+```
+Error: connect ECONNREFUSED
+```
+- Ensure MONGODB_URL is correct
+- Check MongoDB Atlas network access
+- Verify IP whitelist includes your server
+
+### Resend Email Not Sending
+```
+Failed to send email
+```
+- Check RESEND_API_KEY is valid
+- Verify RESEND_FROM_EMAIL is correct
+- Check Resend dashboard for quota limits
+
+### Token Validation Error
+```
+Invalid or expired token
+```
+- Ensure Bearer token format: `Authorization: Bearer <token>`
+- Check token hasn't expired (60 days for login)
+- Regenerate token if needed
+
+## Performance Tips
+
+1. **MongoDB Indexes**: Already created on startup
+2. **Async/Await**: All I/O operations are async
+3. **Connection Pooling**: Motor manages connection pool
+4. **Caching**: Implement Redis for OTP caching (future)
+5. **Rate Limiting**: Add rate limiter middleware (future)
+
+## Future Enhancements
+
+- [ ] Refresh token rotation
+- [ ] Social login (Google, GitHub)
+- [ ] 2FA support
+- [ ] Account recovery questions
+- [ ] Redis caching layer
+- [ ] Rate limiting middleware
+- [ ] API key authentication
+- [ ] Admin dashboard
+
+## License
+
+MIT License - see LICENSE file
+
+## Support
+
+For issues or questions:
+- GitHub Issues: https://github.com/yourusername/lojiz-auth-api/issues
+- Email: support@lojiz.com
+
+---
+
+**Built with ❤️ using FastAPI, MongoDB, and Resend**
+"""
+
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,33 @@
+"""
+app.py - Entry point for Hugging Face Spaces deployment
+Runs the FastAPI server on port 7860 (HF default)
+"""
+
+import sys
+import os
+
+# Add current directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Load environment variables
+from dotenv import load_dotenv
+load_dotenv()
+
+# Import your FastAPI app
+from main import app
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    # HF Spaces uses port 7860 by default
+    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}")
+    
+    uvicorn.run(
+        app,
+        host=host,
+        port=port,
+        log_level="info",
+    )

app/__init__.py

@@ -0,0 +1,4 @@
+"""Lojiz Authentication API"""
+
+__version__ = "1.0.0"
+__author__ = "Lojiz Team"

app/ai/config.py

@@ -0,0 +1,66 @@
+# app/ai/config.py - FIXED SENTRY + ML INTEGRATION
+"""
+Production-grade clients for:
+- DeepSeek (chat completions)
+- Redis (session memory / rate-limit)
+- Qdrant (vector store)
+- Sentry (observability)
+- ML Extractor (AI field validation)
+"""
+
+import os
+import sentry_sdk
+from redis.asyncio import Redis
+from qdrant_client import AsyncQdrantClient
+import openai
+from structlog import get_logger
+
+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")
+
+if not openai.api_key:  # fail fast
+    raise RuntimeError("DEEPSEEK_API_KEY not set")
+
+# ---------- 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 ----------
+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:
+    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")
+    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")

app/ai/graph.py

@@ -0,0 +1,87 @@
+# app/ai/graph.py - FIXED NODE NAMING CONFLICT
+from langgraph.graph import StateGraph, START, END
+from app.ai.state import ChatState
+from app.ai.nodes.intent_node import intent_node
+from app.ai.nodes.role_gate_node import role_gate_node
+from app.ai.nodes.search_node import search_node
+from app.ai.nodes.draft_node import draft_node
+from app.ai.nodes.publish_node import publish_node
+from app.ai.utils.intent_extractor import extract_intent_from_state
+from structlog import get_logger
+
+logger = get_logger(__name__)
+
+workflow = StateGraph(ChatState)
+
+# Add all nodes with unique names that don't conflict with state keys
+# ✅ FIXED: Changed node names to avoid conflicts with state fields
+workflow.add_node("parse_intent", intent_node)  # was "intent"
+workflow.add_node("check_permissions", role_gate_node)  # was "role_gate"
+workflow.add_node("search_listings", search_node)  # was "search"
+workflow.add_node("create_draft", draft_node)  # was "draft"
+workflow.add_node("handle_publish", publish_node)  # was "publish"
+
+# START → parse_intent (always start here)
+workflow.add_edge(START, "parse_intent")
+
+# From parse_intent, route to permission check
+def route_from_intent(state):
+    """Route from intent parsing to permission check"""
+    intent = state.get("intent")
+    
+    # Only check role for listing and search intents
+    if intent in ["search", "list"]:
+        return "check_permissions"
+    else:
+        return END
+
+workflow.add_conditional_edges(
+    "parse_intent",
+    route_from_intent,
+    {
+        "check_permissions": "check_permissions",
+        END: END
+    }
+)
+
+# From permission check, route to actual operation or END
+def route_from_permissions(state):
+    """Route after permission check"""
+    if not state.get("allowed", False):
+        logger.info("🚫 Request blocked by permission check")
+        return END
+    
+    intent = state.get("intent")
+    
+    if intent == "search":
+        logger.info("🔍 Routing to search")
+        return "search_listings"
+    elif intent == "list":
+        logger.info("📝 Routing to draft creation")
+        return "create_draft"
+    else:
+        return END
+
+workflow.add_conditional_edges(
+    "check_permissions",
+    route_from_permissions,
+    {
+        "search_listings": "search_listings",
+        "create_draft": "create_draft",
+        END: END
+    }
+)
+
+# search_listings → END
+workflow.add_edge("search_listings", END)
+
+# create_draft → handle_publish
+workflow.add_edge("create_draft", "handle_publish")
+
+# handle_publish → END
+workflow.add_edge("handle_publish", END)
+
+# Compile the graph
+agent = workflow.compile()
+
+logger.info("✅ LangGraph compiled successfully with unique node names")

app/ai/memory/redis_memory.py

@@ -0,0 +1,31 @@
+# app/ai/memory/redis_memory.py
+import json
+from typing import List
+from app.ai.config import redis_client
+from structlog import get_logger
+
+logger = get_logger(__name__)
+HISTORY_TTL = 60 * 60 * 24 * 7          # 7 days
+RATE_LIMIT_KEY_TTL = 60                 # 1 min
+
+# ---------- history ----------
+async def load_history(user_id: str) -> List[dict]:
+    raw = await redis_client.get(f"aida:history:{user_id}")
+    if raw is None:
+        return []
+    return json.loads(raw)
+
+async def save_turn(user_id: str, messages: List[dict]) -> None:
+    await redis_client.setex(
+        f"aida:history:{user_id}",
+        HISTORY_TTL,
+        json.dumps(messages, ensure_ascii=False),
+    )
+
+# ---------- rate limit ----------
+async def is_rate_limited(user_id: str, limit: int = 30) -> bool:
+    key = f"aida:rate:{user_id}"
+    current = await redis_client.incr(key)
+    if current == 1:
+        await redis_client.expire(key, RATE_LIMIT_KEY_TTL)
+    return current > limit

app/ai/nodes/draft_node.py

@@ -0,0 +1,161 @@
+# app/ai/nodes/draft_node.py - FIXED WITH IMAGES SUPPORT
+import datetime
+from typing import Dict
+from bson import ObjectId
+from app.database import get_db
+from app.ai.state import ListingDraft
+from structlog import get_logger
+from openai import AsyncOpenAI
+from app.config import settings
+from app.ml.models.ml_listing_extractor import get_ml_extractor
+
+logger = get_logger(__name__)
+
+client = AsyncOpenAI(api_key=settings.OPENAI_API_KEY)
+ml_extractor = get_ml_extractor()
+
+# ---------- helpers ----------
+def _generate_title(state: Dict) -> str:
+    """Generate professional title from listing data."""
+    bedrooms = state.get("bedrooms", "")
+    location = state.get("location", "").title()
+    listing_type = state.get("listing_type", "").title()
+    
+    if bedrooms and location:
+        return f"{bedrooms}-Bedroom {listing_type} in {location}"
+    return f"Property in {location}"
+
+def _generate_description(state: Dict) -> str:
+    """Generate professional description from listing data."""
+    bedrooms = state.get("bedrooms", "")
+    bathrooms = state.get("bathrooms", "")
+    location = state.get("location", "").title()
+    amenities = state.get("amenities", [])
+    price = state.get("price", "")
+    price_type = state.get("price_type", "").title()
+    listing_type = state.get("listing_type", "").title()
+    
+    desc = f"Beautiful {bedrooms}-bedroom, {bathrooms}-bathroom {listing_type} "
+    desc += f"located in {location}. "
+    
+    if price:
+        desc += f"Priced at {price:,} {price_type}. "
+    
+    if amenities:
+        amenities_str = ", ".join(amenities)
+        desc += f"Amenities include: {amenities_str}. "
+    
+    desc += "Perfect for comfortable living in a convenient location."
+    return desc
+
+# ---------- node ----------
+async def draft_node(state: Dict) -> Dict:
+    """
+    LangGraph node:
+    - Check if status == "draft_ready" (all required fields collected)
+    - ML VALIDATE all fields
+    - Generate title + description
+    - Show PREVIEW to user
+    - DO NOT save to MongoDB yet (wait for publish command)
+    """
+    
+    # Only process if listing creation with all fields ready
+    if state.get("intent") != "list" or state.get("status") != "draft_ready":
+        return state
+    
+    user_id = state.get("user_id")
+    
+    # ✅ ML VALIDATION before drafting
+    try:
+        validation = ml_extractor.validate_all_fields(state, user_id)
+        
+        if not validation["all_valid"]:
+            # Fields failed validation, go back to collecting
+            issues_text = "\n".join([f"❌ {issue}" for issue in validation["issues"]])
+            state["ai_reply"] = f"""I found some issues with your listing:
+
+{issues_text}
+
+Let me ask again - could you clarify these fields?"""
+            
+            state["status"] = "collecting"
+            # Re-populate missing fields based on validation
+            state["missing_fields"] = [
+                field for field, result in validation["field_validations"].items()
+                if not result["is_valid"]
+            ]
+            
+            logger.warning("🚫 Fields failed ML validation", issues=validation["issues"])
+            return state
+        
+        logger.info("✅ All fields passed ML validation", user_id=user_id)
+    
+    except Exception as e:
+        logger.error("❌ ML validation error", exc_info=e)
+        state["ai_reply"] = "Sorry, I couldn't validate your listing. Please try again."
+        state["status"] = "error"
+        return state
+    
+    # Generate title and description
+    title = _generate_title(state)
+    description = _generate_description(state)
+    
+    # ✅ Get images from state (if any were uploaded)
+    images = state.get("draft", {}).get("images", []) if isinstance(state.get("draft"), dict) else []
+    
+    # Build draft preview with all fields including images
+    draft_preview = {
+        "title": title,
+        "description": description,
+        "location": state.get("location", "").title(),
+        "bedrooms": state.get("bedrooms"),
+        "bathrooms": state.get("bathrooms"),
+        "price": state.get("price"),
+        "price_type": state.get("price_type"),
+        "listing_type": state.get("listing_type"),
+        "amenities": state.get("amenities", []),
+        "requirements": state.get("requirements"),
+        "currency": state.get("currency", "XOF"),
+        "images": images,  # ✅ INCLUDE IMAGES
+        "field_confidences": validation["field_validations"],
+    }
+    
+    logger.info("🎯 Draft preview generated",
+                title=title,
+                location=state.get("location"),
+                image_count=len(images))
+    
+    # Build nice preview message for user
+    images_section = ""
+    if images:
+        images_section = f"\n🖼️ Images: {len(images)} uploaded\n"
+        for idx, img_url in enumerate(images[:3], 1):
+            images_section += f"   {idx}. {img_url[:60]}...\n"
+        if len(images) > 3:
+            images_section += f"   ... and {len(images) - 3} more\n"
+    
+    preview_text = f"""
+┌─────────────────────────────────────────────────────────────────
+🏠 LISTING PREVIEW
+└─────────────────────────────────────────────────────────────────
+**{draft_preview['title']}**
+
+📍 Location: {draft_preview['location']}
+🛏️ Bedrooms: {draft_preview['bedrooms']}
+🚿 Bathrooms: {draft_preview['bathrooms']}
+💰 Price: {draft_preview['price']:,} {draft_preview['price_type']} ({draft_preview['currency']})
+
+{draft_preview['description']}
+
+✨ Amenities: {', '.join(draft_preview['amenities']) if draft_preview['amenities'] else 'None specified'}
+{images_section}
+└─────────────────────────────────────────────────────────────────
+
+👉 Say **publish** or click the publish button to make it live!
+"""
+    
+    state["draft_preview"] = draft_preview
+    state["ai_reply"] = preview_text
+    state["status"] = "preview_shown"  # Waiting for publish confirmation
+    
+    return state

app/ai/nodes/image_node.py

@@ -0,0 +1,63 @@
+# 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

@@ -0,0 +1,366 @@
+# app/ai/nodes/intent_node.py - FIXED WITH ERROR HANDLING
+import json
+import re
+from typing import Dict, List
+from tenacity import retry, stop_after_attempt, wait_exponential
+from openai import AsyncOpenAI
+from structlog import get_logger
+from app.config import settings
+from app.ml.models.ml_listing_extractor import get_ml_extractor
+
+logger = get_logger(__name__)
+
+MODEL = "deepseek-chat"
+MAX_TOKENS = 600
+TEMP = 0
+
+client = AsyncOpenAI(api_key=settings.DEEPSEEK_API_KEY,
+                     base_url=settings.DEEPSEEK_BASE_URL)
+
+ml_extractor = get_ml_extractor()
+
+def _load_system() -> str:
+    with open("app/ai/prompts/system_prompt.txt", encoding="utf-8") as f:
+        return f.read()
+
+SYSTEM_PROMPT = _load_system()
+
+def _clean_json(raw: str) -> str:
+    """Remove markdown code blocks from JSON string."""
+    cleaned = re.sub(r'```json\s*', '', raw)
+    cleaned = re.sub(r'```\s*', '', cleaned)
+    return cleaned.strip()
+
+def _normalize_locations(location: str) -> str:
+    """Normalize location names (handle typos)."""
+    if not location:
+        return None
+    
+    loc_lower = location.lower().strip()
+    
+    location_map = {
+        "lago": "lagos",
+        "lgs": "lagos",
+        "lag": "lagos",
+        "cotnu": "cotonou",
+        "cotonus": "cotonou",
+        "cotou": "cotonou",
+        "nairobi": "nairobi",
+        "nbi": "nairobi",
+        "accra": "accra",
+        "acc": "accra",
+        "joburg": "johannesburg",
+        "jozi": "johannesburg",
+        "london": "london",
+        "paris": "paris",
+    }
+    
+    return location_map.get(loc_lower, location.lower())
+
+def _normalize_amenities(amenities: list) -> list:
+    """Normalize amenity names (handle typos)."""
+    if not amenities:
+        return []
+    
+    amenity_map = {
+        "balcno": "balcony",
+        "balconny": "balcony",
+        "parkng": "parking",
+        "park": "parking",
+        "wifi": "wifi",
+        "furnisd": "furnished",
+        "furnishd": "furnished",
+        "furnish": "furnished",
+        "ac": "air conditioning",
+        "air cond": "air conditioning",
+        "aircond": "air conditioning",
+        "gym": "gym",
+        "pool": "pool",
+        "swiming": "pool",
+        "kitchen": "kitchen",
+        "kitchn": "kitchen",
+        "garden": "garden",
+        "gdn": "garden",
+    }
+    
+    normalized = []
+    for amenity in amenities:
+        if not amenity:
+            continue
+        am_lower = amenity.lower().strip()
+        normalized_am = amenity_map.get(am_lower, am_lower)
+        if normalized_am and normalized_am not in normalized:
+            normalized.append(normalized_am)
+    
+    return normalized
+
+def _normalize_price_type(price_type: str) -> str:
+    """Normalize price_type (handle typos)."""
+    if not price_type:
+        return None
+    
+    pt_lower = price_type.lower().strip()
+    
+    price_type_map = {
+        "montly": "monthly",
+        "monthyl": "monthly",
+        "mth": "monthly",
+        "month": "monthly",
+        "nightl": "nightly",
+        "nightly": "nightly",
+        "night": "nightly",
+        "daily": "daily",
+        "day": "daily",
+        "weakly": "weekly",
+        "weakyl": "weekly",
+        "week": "weekly",
+        "yr": "yearly",
+        "year": "yearly",
+        "yearly": "yearly",
+        "annum": "yearly",
+    }
+    
+    return price_type_map.get(pt_lower, pt_lower)
+
+def _normalize_listing_type(listing_type: str) -> str:
+    """Normalize listing_type (handle typos)."""
+    if not listing_type:
+        return None
+    
+    lt_lower = listing_type.lower().strip()
+    
+    listing_type_map = {
+        "rent": "rent",
+        "for rent": "rent",
+        "rental": "rent",
+        "short stay": "short-stay",
+        "short-stay": "short-stay",
+        "shortsta": "short-stay",
+        "short stya": "short-stay",
+        "stayover": "short-stay",
+        "roommate": "roommate",
+        "roommat": "roommate",
+        "sharing": "roommate",
+        "flatmate": "roommate",
+        "shareflat": "roommate",
+        "sale": "sale",
+        "for sale": "sale",
+        "selling": "sale",
+        "sell": "sale",
+    }
+    
+    return listing_type_map.get(lt_lower, lt_lower)
+
+def _get_missing_fields(data: Dict) -> List[str]:
+    """Identify which REQUIRED fields are missing for listing creation."""
+    if data.get("intent") != "list":
+        return []
+    
+    required = ["location", "bedrooms", "bathrooms", "price", "listing_type", "price_type"]
+    missing = []
+    
+    for field in required:
+        value = data.get(field)
+        if value is None or value == "" or value == 0:
+            missing.append(field)
+    
+    return missing
+
+def _get_next_question(missing_fields: List[str]) -> str:
+    """Get the next question based on missing fields."""
+    if not missing_fields:
+        return None
+    
+    next_field = missing_fields[0]
+    
+    questions = {
+        "location": "Where is the property located? (city/area)",
+        "bedrooms": "How many bedrooms?",
+        "bathrooms": "How many bathrooms?",
+        "price": "What's the price/rent amount?",
+        "listing_type": "Is it for rent, short-stay, sale, or roommate?",
+        "price_type": "Is it monthly, nightly, or yearly?"
+    }
+    
+    return questions.get(next_field, "What else should I know?")
+
+@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=1, max=5))
+async def intent_node(state: Dict) -> Dict:
+    user_role = state["user_role"]
+    user_id = state.get("user_id")
+    human_msg = state["messages"][-1]["content"]
+
+    prompt = SYSTEM_PROMPT.replace("{user_role}", user_role)
+    messages = [
+        {"role": "system", "content": prompt},
+        {"role": "user", "content": human_msg},
+    ]
+
+    logger.info("🤖 Aida intent call", user_role=user_role, msg=human_msg)
+    resp = await client.chat.completions.create(
+        model=MODEL,
+        messages=messages,
+        temperature=TEMP,
+        max_tokens=MAX_TOKENS,
+    )
+    raw = resp.choices[0].message.content.strip()
+    logger.debug("🤖 Aida raw response", raw=raw)
+
+    try:
+        cleaned = _clean_json(raw)
+        data = json.loads(cleaned)
+    except json.JSONDecodeError as e:
+        logger.error("❌ Aida bad json", raw=raw, exc_info=e)
+        data = {
+            "allowed": False,
+            "ai_reply": "Sorry, I didn't understand that. Could you rephrase?",
+        }
+
+    # Handle LISTING INTENT with progressive collection
+    if data.get("intent") == "list":
+        data["allowed"] = True
+        missing = _get_missing_fields(data)
+        
+        if missing:
+            data["status"] = "collecting"
+            data["missing_fields"] = missing
+            data["next_question"] = _get_next_question(missing)
+        else:
+            data["status"] = "draft_ready"
+            data["missing_fields"] = []
+    
+    # SEARCH is always allowed (role_gate_node will check)
+    if data.get("intent") == "search":
+        data["allowed"] = True
+
+    # Normalize values
+    location = _normalize_locations(data.get("location"))
+    amenities = _normalize_amenities(data.get("amenities", []))
+    price_type = _normalize_price_type(data.get("price_type"))
+    listing_type = _normalize_listing_type(data.get("listing_type"))
+
+    # ✅ SMART INFERENCE + ML VALIDATION with ERROR HANDLING
+    if data.get("intent") == "list":
+        location_input = data.get("location")
+        
+        # 1️⃣ Extract city from detailed address using Nominatim (WITH ERROR HANDLING)
+        if location_input:
+            try:
+                city, location_info = await ml_extractor.extract_location_from_address(location_input)
+                if city:
+                    data["location"] = city
+                    data["location_details"] = location_info
+                    logger.info(f"✅ Extracted city from address: {location_input} → {city}")
+            except Exception as e:
+                logger.warning(f"⚠️ Failed to extract location: {e}")
+                # Continue with original location
+                pass
+        
+        # 2️⃣ Infer listing_type from user role + message keywords
+        try:
+            listing_type, listing_confidence = ml_extractor.infer_listing_type(
+                data, 
+                user_role=user_role,
+                user_message=human_msg
+            )
+            if listing_type:
+                data["listing_type"] = listing_type
+                data["listing_confidence"] = listing_confidence
+                logger.info(f"✅ Inferred listing_type: {listing_type} (confidence: {listing_confidence})")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to infer listing_type: {e}")
+            # Will ask user for listing_type
+            pass
+        
+        # 3️⃣ Infer currency from location using Nominatim + REST Countries (WITH ERROR HANDLING)
+        try:
+            currency, extracted_city, currency_confidence = await ml_extractor.infer_currency(data)
+            if currency:
+                data["currency"] = currency
+                data["currency_confidence"] = currency_confidence
+                if extracted_city:
+                    data["location"] = extracted_city
+                logger.info(f"✅ Inferred currency: {currency} (confidence: {currency_confidence})")
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to infer currency: {e}")
+            # Fallback to default
+            data["currency"] = data.get("currency", "XOF")
+        
+        # 4️⃣ ML VALIDATION of extracted fields (WITH ERROR HANDLING)
+        try:
+            validation_issues = []
+            validation_suggestions = []
+            field_validations = {}
+            
+            for field in ["location", "bedrooms", "bathrooms", "price", "price_type"]:
+                value = data.get(field)
+                if value is not None:
+                    result = ml_extractor.validate_field(field, value, human_msg, user_id)
+                    field_validations[field] = result  # ✅ STORE
+                    
+                    if not result["is_valid"]:
+                        validation_issues.append(f"❌ {field}: {result['suggestion']}")
+                        logger.warning(f"Validation failed for {field}", suggestion=result["suggestion"])
+                    elif result["suggestion"]:
+                        validation_suggestions.append(f"⚠️ {field}: {result['suggestion']}")
+            
+            # ✅ Store validation results in state
+            data["field_validations"] = field_validations
+            data["validation_suggestions"] = validation_suggestions
+            
+            # If validation issues, add them to the AI reply
+            if validation_issues:
+                current_reply = data.get("ai_reply", "")
+                data["ai_reply"] = current_reply + "\n\n" + "\n".join(validation_issues)
+                logger.info("ℹ️ ML validation issues found", issues=validation_issues)
+        
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to validate fields: {e}")
+            # Continue without validation results
+            pass
+
+    # ✅ Store intent in ai_reply as JSON for routing
+    # LangGraph will extract it from the response
+    intent_value = data.get("intent")
+    
+    # Update state with all fields
+    state.update(
+        allowed=data.get("allowed", False),
+        status=data.get("status"),
+        missing_fields=data.get("missing_fields", []),
+        next_question=data.get("next_question"),
+        
+        # Listing fields
+        listing_type=listing_type,
+        location=location,
+        bedrooms=data.get("bedrooms"),
+        bathrooms=data.get("bathrooms"),
+        price=data.get("price"),
+        price_type=price_type,
+        amenities=amenities,
+        requirements=data.get("requirements"),
+        
+        # Search fields
+        min_price=data.get("min_price"),
+        max_price=data.get("max_price"),
+        
+        # ML fields ✅ STORE
+        field_validations=data.get("field_validations"),
+        listing_confidence=data.get("listing_confidence"),
+        currency_confidence=data.get("currency_confidence"),
+        location_details=data.get("location_details"),
+        validation_suggestions=data.get("validation_suggestions"),
+        
+        # Other
+        currency=data.get("currency", "XOF"),
+        ai_reply=data.get("ai_reply", ""),
+        draft_preview=data.get("draft_preview"),
+    )
+    
+    logger.info("📄 Intent node processed",
+                intent=intent_value,
+                status=state.get("status"),
+                missing_fields=state.get("missing_fields"),
+                location=state.get("location"))
+    
+    return state

app/ai/nodes/publish_node.py

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

app/ai/nodes/role_gate_node.py

@@ -0,0 +1,51 @@
+# 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

@@ -0,0 +1,298 @@
+# app/ai/nodes/search_node.py  (comprehensive search - all fields)
+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):
+    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"),
+        }
+        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
+    """
+    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)
+
+    # --- personalise zero-hit reply + suggestions
+    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["suggestions"] = 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!"
+            )
+    else:
+        state["ai_reply"] = f"Here are {len(cards)} places I found for you:"
+        state["search_results"] = cards
+
+    logger.info("Aida search finished", query=query, count=len(cards), suggestions=len(state.get("suggestions", [])))
+    return state

app/ai/prompts/system_prompt.txt

@@ -0,0 +1,241 @@
+You are Aida, Lojiz's friendly real-estate AI assistant.
+User role: {user_role}  (landlord | renter)
+
+------------------------------------------------------
+BRAND IDENTITY & RESPONSES
+------------------------------------------------------
+
+**WHO YOU ARE:**
+- You are AIDA, Lojiz's proprietary real-estate AI assistant
+- Do NOT mention DeepSeek, GPT, or any other LLM names
+- You are a standalone AI developed specifically for Lojiz
+- Never refer to yourself as based on other AI models
+
+**IF ASKED "WHO ARE YOU?"**
+"I'm Aida, Lojiz's AI real-estate assistant. I help landlords list properties and renters find their perfect home!"
+
+**IF ASKED "WHO DESIGNED YOU?" OR "WHO CREATED YOU?"**
+"I was designed and developed by the Lojiz team. Our talented team includes:
+- **Emeka Destiny Ebuka** - Lead AI & ML Engineer/Developer - designed my intelligence and learning capabilities
+- **Uche Samuel Chukwuemeka** - Product Designer - shaped my user experience and personality
+
+Together, they created me to make real-estate transactions easier and more accessible for everyone."
+
+**IF ASKED "WHO BUILT YOU?" OR "WHAT COMPANY MADE YOU?"**
+"I'm built by Lojiz, a real-estate platform designed to connect landlords and renters seamlessly across Africa. The Lojiz team created me with passion and expertise in AI and real-estate technology."
+
+**IF ASKED "ARE YOU AN LLM?" OR "WHAT MODEL ARE YOU?"**
+"I'm Aida, Lojiz's specialized AI assistant. I'm not just a general-purpose AI - I'm specifically built to understand real-estate, help with property listings, and guide users through the Lojiz platform. That's what makes me different!"
+
+**NEVER SAY:**
+- ❌ "I'm based on DeepSeek"
+- ❌ "I'm powered by GPT"
+- ❌ "I'm an LLM (Language Model)"
+- ❌ "I was trained on general data"
+- ✅ Say "I'm Aida, Lojiz's AI assistant" instead
+
+------------------------------------------------------
+PERSONALITY & GRAMMAR TOLERANCE
+------------------------------------------------------
+- Speak like a human, short and warm.
+- IGNORE typos, grammar mistakes, and spelling errors. Understand intent anyway.
+- If the user greets or talks off-topic, reply casually and ask: "Would you like to list a property or search for one?"
+- Only switch to JSON output when property details are mentioned OR when user clearly wants to SEARCH / SEE / FIND / LOOK FOR houses/flats/rooms/apartments.
+- Be proud of being Aida - make it clear you're a specialized real-estate AI
+
+------------------------------------------------------
+LISTING CREATION - PROGRESSIVE COLLECTION
+------------------------------------------------------
+
+REQUIRED FIELDS (MUST collect before draft):
+1. location (city/area only, e.g., "cotonou", "lagos")
+2. bedrooms (number)
+3. bathrooms (number)
+4. price (amount)
+5. listing_type (auto-detect: rent, short-stay, sale, roommate)
+6. price_type (auto-detect: monthly, nightly, yearly)
+
+OPTIONAL FIELDS (Ask, but not required):
+- amenities (wifi, parking, balcony, pool, furnished, etc.)
+- requirements (special requests/notes)
+
+AUTO-GENERATED:
+- title (AI generates from location, bedrooms, listing_type)
+- description (AI generates professional description)
+- currency (auto-detect from location: Lagos→NGN, Cotonou→XOF, etc.)
+
+LOCATION EXTRACTION:
+- Extract ONLY the city/area name
+- Ignore long descriptions
+- Examples:
+  "calavi quartier zogbadje" → location: "cotonou" (calavi is area)
+  "VI in Lagos" → location: "lagos"
+  "Lekki, Lagos" → location: "lagos"
+
+LISTING TYPE AUTO-DETECTION:
+- "for rent" / "monthly" / "yearly" → rent
+- "short stay" / "nightly" / "daily" / "weekly" → short-stay
+- "for sale" / "selling" → sale
+- "roommate" / "sharing" / "flatmate" → roommate
+
+PRICE TYPE AUTO-DETECTION:
+- "monthly" / "month" / "per month" / "mth" → monthly
+- "nightly" / "night" / "per night" / "daily" / "day" → nightly
+- "yearly" / "year" / "per year" / "annum" → yearly
+
+PROGRESSIVE COLLECTION FLOW:
+1. User provides initial info (may be incomplete)
+2. Extract what's given
+3. Identify MISSING required fields
+4. Ask for missing fields ONE AT A TIME
+5. User provides each field
+6. Append to existing fields
+7. When ALL required fields complete → Generate DRAFT
+8. Show DRAFT preview to user
+9. User reviews and says "publish" to confirm
+
+------------------------------------------------------
+RULES WHEN LISTING INTENT IS DETECTED
+------------------------------------------------------
+
+When user starts listing a property:
+1. Extract all information from their message
+2. Check for missing REQUIRED fields
+3. Ask missing fields one by one
+4. Build up state progressively
+
+Response format while collecting:
+{
+  "intent": "list",
+  "location": "lagos",
+  "bedrooms": 2,
+  "bathrooms": 1,
+  "price": 50000,
+  "listing_type": "rent",
+  "price_type": "monthly",
+  "amenities": ["wifi", "parking"],
+  "requirements": null,
+  "status": "collecting",
+  "missing_fields": ["amenities", "requirements"],
+  "next_question": "Any amenities? (wifi, parking, balcony, pool, furnished, etc.)",
+  "ai_reply": "Great! I have: 2-bed in Lagos, 50k/month. How many bathrooms?"
+}
+
+When ALL required fields complete:
+{
+  "intent": "list",
+  "location": "lagos",
+  "bedrooms": 2,
+  "bathrooms": 1,
+  "price": 50000,
+  "listing_type": "rent",
+  "price_type": "monthly",
+  "amenities": ["wifi", "parking"],
+  "requirements": null,
+  "status": "draft_ready",
+  "missing_fields": [],
+  "ai_reply": "Perfect! Here's your listing preview...",
+  "draft_preview": {
+    "title": "2-Bedroom Apartment in Lagos",
+    "description": "Beautiful 2-bedroom apartment with wifi and parking...",
+    "location": "Lagos",
+    "bedrooms": 2,
+    "bathrooms": 1,
+    "price": 50000,
+    "price_type": "monthly",
+    "listing_type": "rent",
+    "amenities": ["wifi", "parking"],
+    "currency": "NGN"
+  }
+}
+
+------------------------------------------------------
+EXAMPLES - LISTING CREATION
+------------------------------------------------------
+
+User: "I want to list my 2-bed apartment in Lagos for rent, 50k monthly"
+{
+  "intent": "list",
+  "location": "lagos",
+  "bedrooms": 2,
+  "bathrooms": null,
+  "price": 50000,
+  "listing_type": "rent",
+  "price_type": "monthly",
+  "amenities": [],
+  "requirements": null,
+  "status": "collecting",
+  "missing_fields": ["bathrooms"],
+  "next_question": "How many bathrooms?",
+  "ai_reply": "Got it! 2-bed in Lagos, 50k/month. How many bathrooms?"
+}
+
+User: "1 bathroom, with wifi and parking"
+{
+  "intent": "list",
+  "location": "lagos",
+  "bedrooms": 2,
+  "bathrooms": 1,
+  "price": 50000,
+  "listing_type": "rent",
+  "price_type": "monthly",
+  "amenities": ["wifi", "parking"],
+  "requirements": null,
+  "status": "draft_ready",
+  "missing_fields": [],
+  "ai_reply": "Perfect! Here's your listing...",
+  "draft_preview": {
+    "title": "2-Bedroom Apartment in Lagos",
+    "description": "Beautiful 2-bedroom apartment located in Lagos with wifi and parking. Perfect for comfortable living.",
+    "location": "Lagos",
+    "bedrooms": 2,
+    "bathrooms": 1,
+    "price": 50000,
+    "price_type": "monthly",
+    "listing_type": "rent",
+    "amenities": ["wifi", "parking"],
+    "currency": "NGN"
+  }
+}
+
+------------------------------------------------------
+SEARCH INTENT (SAME AS BEFORE)
+------------------------------------------------------
+When user searches, extract and COMBINE ALL mentioned filters:
+- location: city/area (handle typos)
+- min_price: lowest acceptable
+- max_price: highest acceptable
+- bedrooms: number of beds
+- bathrooms: number of baths
+- price_type: monthly/nightly/yearly
+- listing_type: rent/short-stay/sale/roommate
+- amenities: ALL features mentioned
+
+Output format for SEARCH:
+{
+  "intent": "search",
+  "location": "lagos",
+  "min_price": 20000,
+  "max_price": 100000,
+  "bedrooms": 2,
+  "bathrooms": 1,
+  "price_type": "monthly",
+  "listing_type": "rent",
+  "amenities": ["balcony", "wifi", "parking"],
+  "ai_reply": "Here are 2-bed rentals in Lagos, 20-100k monthly..."
+}
+
+------------------------------------------------------
+CRITICAL RULES
+------------------------------------------------------
+1. ALWAYS extract ALL mentioned info
+2. Auto-detect listing_type and price_type from keywords
+3. Extract location as CITY NAME ONLY (no long descriptions)
+4. For listing creation: collect required fields progressively
+5. For search: extract all filters at once
+6. Return ONLY JSON (no markdown, no preamble)
+7. When all required fields complete → show draft preview
+8. Wait for "publish" command to save listing
+9. BRAND RULE: Always refer to yourself as AIDA, never mention other LLMs
+10. BRAND RULE: Give credit to Lojiz team when asked about your creators
+11. BRAND RULE: Stand your ground as a specialized real-estate AI, not a general-purpose model

app/ai/routes/chat.py

@@ -0,0 +1,37 @@
+# app/ai/routes/chat.py  (returns JSON the front-end can render)
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.security import HTTPBearer
+from pydantic import BaseModel
+from app.guards.jwt_guard import decode_access_token
+from app.ai.service import aida_chat_sync
+from app.ai.memory.redis_memory import is_rate_limited
+
+router = APIRouter()
+security = HTTPBearer()
+
+class AskBody(BaseModel):
+    message: str
+
+
+@router.post("/ask")
+async def ask_ai(
+    body: AskBody,
+    token: str = Depends(security),
+):
+    payload = decode_access_token(token.credentials)
+    if not payload:
+        raise HTTPException(status_code=401, detail="Invalid token")
+    if await is_rate_limited(payload["user_id"]):
+        raise HTTPException(status_code=429, detail="Rate limit exceeded")
+
+    final_state = await aida_chat_sync(
+        payload["user_id"],
+        payload["role"],
+        body.message,
+    )
+
+    # --- new format: text + optional cards -----------------------------
+    return {
+        "text": final_state.get("ai_reply", ""),
+        "cards": final_state.get("search_results", []),  # UI watches this key
+    }

app/ai/service.py

@@ -0,0 +1,68 @@
+# app/ai/service.py  (final – returns full state so cards reach the UI)
+import json
+from typing import AsyncGenerator, List, Dict, Any
+from app.ai.graph import agent
+from app.ai.memory.redis_memory import save_turn, load_history
+from app.ai.state import ChatState
+from structlog import get_logger
+
+logger = get_logger(__name__)
+
+# --------------------------------------------------
+# WebSocket streaming entry-point (kept for reference)
+# --------------------------------------------------
+async def aida_chat(
+    user_id: str,
+    user_role: str,
+    human_msg: str,
+) -> AsyncGenerator[str, None]:
+    messages = await load_history(user_id)
+    messages.append({"role": "user", "content": human_msg})
+
+    state: ChatState = {
+        "user_id": user_id,
+        "user_role": user_role,
+        "messages": messages,
+        "draft": None,
+        "vector_meta": None,
+        "allowed": True,
+        "ai_reply": "",
+    }
+
+    async for step in agent.astream(state):
+        for node_name, update in step.items():
+            if update.get("ai_reply"):
+                yield json.dumps({"node": node_name, "text": update["ai_reply"]}) + "\n"
+
+    final_state = await agent.ainvoke(state)
+    messages.append({"role": "assistant", "content": final_state["ai_reply"]})
+    await save_turn(user_id, messages)
+
+
+# --------------------------------------------------
+# REST (non-streaming) – returns the full state dict
+# --------------------------------------------------
+async def aida_chat_sync(
+    user_id: str,
+    user_role: str,
+    human_msg: str,
+) -> Dict[str, Any]:
+    messages = await load_history(user_id)
+    messages.append({"role": "user", "content": human_msg})
+
+    state: ChatState = {
+        "user_id": user_id,
+        "user_role": user_role,
+        "messages": messages,
+        "draft": None,
+        "vector_meta": None,
+        "allowed": True,
+        "ai_reply": "",
+    }
+
+    final_state = await agent.ainvoke(state)
+    messages.append({"role": "assistant", "content": final_state["ai_reply"]})
+    await save_turn(user_id, messages)
+
+    # return the entire state so the route can pick text + cards
+    return final_state

app/ai/state.py

@@ -0,0 +1,106 @@
+# app/ai/state.py - FIXED WITH ML FIELDS
+from typing import TypedDict, List, Optional, Dict, Any
+from pydantic import BaseModel, Field
+from datetime import datetime
+from bson import ObjectId
+
+# ---------- helpers ----------
+class PyObjectId(str):
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.validate
+
+    @classmethod
+    def validate(cls, v):
+        if not ObjectId.is_valid(v):
+            raise ValueError("Invalid ObjectId")
+        return str(v)
+
+# ---------- models ----------
+class ListingDraft(BaseModel):
+    """Pure MongoDB shape (source of truth)"""
+    id: Optional[PyObjectId] = Field(default_factory=PyObjectId, alias="_id")
+    owner_id: str
+    type: str  # rent | short_stay | roommate | sale
+    title: str
+    description: str
+    price: float
+    price_type: str  # monthly | nightly | weekly | yearly
+    bedrooms: Optional[int] = None
+    bathrooms: Optional[int] = None
+    location: str
+    amenities: List[str] = []
+    requirements: Optional[str] = None
+    currency: str = "XOF"
+    images: List[str] = []  # ✅ NEW: Cloudflare image URLs
+    status: str = "draft"  # draft | published
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+    views: int = 0  # ✅ NEW: View counter
+    favorites: int = 0  # ✅ NEW: Favorites counter
+
+    class Config:
+        populate_by_name = True
+        json_encoders = {ObjectId: str}
+
+class VectorMeta(BaseModel):
+    """What we push to Qdrant (search-only)"""
+    mongo_id: str  # same _id as Mongo
+    embedding: List[float]  # 1536-dim vector
+    location: str
+    price: float
+    bedrooms: Optional[int] = None
+    price_type: str
+
+# ========== LangGraph state with ML fields ==========
+class ChatState(TypedDict):
+    # ========== Core Fields ==========
+    user_id: str
+    user_role: str  # landlord | renter
+    messages: List[dict]  # chat history
+    draft: Optional[ListingDraft]
+    vector_meta: Optional[VectorMeta]  # for hybrid search
+    allowed: bool
+    ai_reply: str
+    # ✅ Note: "intent" is passed through messages but NOT stored as state field
+    # This avoids LangGraph node name conflicts
+    status: Optional[str]  # collecting | draft_ready | preview_shown | published | error
+    
+    # ========== Search filters (from LLM) ==========
+    location: Optional[str]
+    min_price: Optional[float]
+    max_price: Optional[float]
+    bedrooms: Optional[int]
+    bathrooms: Optional[int]
+    amenities: List[str]
+    
+    # ========== Listing creation fields (from LLM) ==========
+    listing_type: Optional[str]  # rent | short_stay | sale | roommate
+    price: Optional[float]
+    price_type: Optional[str]  # monthly | nightly | yearly | daily | weekly
+    currency: str
+    requirements: Optional[str]
+    
+    # ========== Collection Flow ==========
+    missing_fields: List[str]
+    next_question: Optional[str]
+    
+    # ========== Search results ==========
+    search_query: Optional[str]
+    search_results: Optional[List[dict]]
+    suggestions: Optional[List[dict]]
+    
+    # ========== Image upload ==========
+    image: Optional[Dict[str, str]]  # {mime, data}
+    
+    # ========== ML Fields (NEW - for validation & inference) ==========
+    field_validations: Optional[Dict[str, Dict]]  # {field: {is_valid, confidence, suggestion}}
+    field_confidences: Optional[Dict[str, float]]  # {field: confidence_score}
+    location_details: Optional[Dict[str, Any]]  # {city, country, lat, lon, country_code}
+    validation_suggestions: Optional[List[str]]  # ["⚠️ field: suggestion"]
+    listing_confidence: Optional[float]  # Confidence for inferred listing_type
+    currency_confidence: Optional[float]  # Confidence for inferred currency
+    
+    # ========== Draft & Publishing ==========
+    draft_preview: Optional[Dict]
+    mongo_id: Optional[str]

app/ai/utils/intent_extractor.py

@@ -0,0 +1,66 @@
+# app/ai/utils/intent_extractor.py - Helper to extract intent from responses
+import json
+import re
+from typing import Optional, Dict
+
+def extract_intent_from_state(state: Dict) -> Optional[str]:
+    """
+    Extract intent from state data.
+    Checks multiple sources for intent value.
+    
+    Returns:
+        str: "list", "search", or None
+    """
+    
+    # Priority 1: Check ai_reply for JSON with intent
+    ai_reply = state.get("ai_reply", "")
+    try:
+        # Try to parse if it's JSON
+        if ai_reply.strip().startswith("{"):
+            data = json.loads(ai_reply)
+            if "intent" in data:
+                return data["intent"]
+    except:
+        pass
+    
+    # Priority 2: Check if intent is in the search_query or listing_type
+    listing_type = state.get("listing_type")
+    if listing_type:
+        return "list"
+    
+    search_query = state.get("search_query")
+    if search_query:
+        return "search"
+    
+    # Priority 3: Check last message for keywords
+    messages = state.get("messages", [])
+    if messages:
+        last_msg = messages[-1].get("content", "").lower()
+        
+        search_keywords = ["search", "find", "look for", "show me", "see", "apartments", "houses", "flats"]
+        list_keywords = ["list", "publish", "sell", "rent out", "want to list"]
+        
+        if any(kw in last_msg for kw in search_keywords):
+            return "search"
+        elif any(kw in last_msg for kw in list_keywords):
+            return "list"
+    
+    return None
+
+def should_check_permissions(state: Dict) -> bool:
+    """
+    Determine if we should route to permission check.
+    
+    Returns:
+        bool: True if intent is search or list
+    """
+    intent = extract_intent_from_state(state)
+    return intent in ["search", "list"]
+
+def should_search(state: Dict) -> bool:
+    """Check if user wants to search"""
+    return extract_intent_from_state(state) == "search"
+
+def should_create_listing(state: Dict) -> bool:
+    """Check if user wants to create listing"""
+    return extract_intent_from_state(state) == "list"

app/config.py

@@ -0,0 +1,112 @@
+# ============================================================
+# app/config.py – Configuration Management (Pydantic v2)
+# ============================================================
+
+from pydantic_settings import BaseSettings
+from typing import List
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Settings(BaseSettings):
+    """Application settings from environment variables"""
+
+    # ------------------------------------------------------------------
+    # Core App
+    # ------------------------------------------------------------------
+    APP_NAME: str = "Lojiz Platform + Aida AI"
+    APP_VERSION: str = "1.0.0"
+    DEBUG: bool = os.getenv("DEBUG", "False").lower() == "true"
+    ENVIRONMENT: str = os.getenv("ENVIRONMENT", "development")
+
+    # ------------------------------------------------------------------
+    # Server
+    # ------------------------------------------------------------------
+    SERVER_HOST: str = os.getenv("SERVER_HOST", "0.0.0.0")
+    SERVER_PORT: int = int(os.getenv("SERVER_PORT", "8000"))
+
+    # ------------------------------------------------------------------
+    # CORS
+    # ------------------------------------------------------------------
+    CORS_ORIGINS: List[str] = [
+        "http://localhost:3000",
+        "http://localhost:5173",
+        os.getenv("FRONTEND_URL", "http://localhost:3000"),
+    ]
+
+    # ------------------------------------------------------------------
+    # MongoDB
+    # ------------------------------------------------------------------
+    MONGODB_URL: str = os.getenv("MONGODB_URL", "mongodb://localhost:27017")
+    MONGODB_DATABASE: str = os.getenv("MONGODB_DATABASE", "lojiz")
+
+    # ------------------------------------------------------------------
+    # JWT
+    # ------------------------------------------------------------------
+    JWT_SECRET: str = os.getenv("JWT_SECRET", "your-super-secret-key-change-in-production")
+    JWT_ALGORITHM: str = "HS256"
+    JWT_LOGIN_EXPIRY_DAYS: int = 60
+    JWT_RESET_EXPIRY_MINUTES: int = 10
+
+    # ------------------------------------------------------------------
+    # OTP
+    # ------------------------------------------------------------------
+    OTP_EXPIRY_MINUTES: int = 15
+    OTP_MAX_ATTEMPTS: int = 5
+    OTP_LENGTH: int = 4
+
+    # ------------------------------------------------------------------
+    # Email (Resend)
+    # ------------------------------------------------------------------
+    RESEND_API_KEY: str = os.getenv("RESEND_API_KEY", "")
+    RESEND_FROM_EMAIL: str = os.getenv("RESEND_FROM_EMAIL", "noreply@lojiz.com")
+    RESEND_FROM_NAME: str = "Lojiz"
+
+    # ------------------------------------------------------------------
+    # Password Hashing
+    # ------------------------------------------------------------------
+    BCRYPT_ROUNDS: int = 10
+
+    # ------------------------------------------------------------------
+    # Security
+    # ------------------------------------------------------------------
+    ALLOWED_ROLES: List[str] = ["renter", "landlord", "admin"]
+
+    # ------------------------------------------------------------------
+    # Cloudflare Images
+    # ------------------------------------------------------------------
+    CF_ACCOUNT_ID: str = os.getenv("CF_ACCOUNT_ID", "")
+    CF_API_TOKEN: str = os.getenv("CF_API_TOKEN", "")
+
+    # ------------------------------------------------------------------
+    # LLM / Tooling keys
+    # ------------------------------------------------------------------
+    OPENAI_API_KEY: str = os.getenv("OPENAI_API_KEY", "")
+    HUGGINGFACE_API_KEY: str = os.getenv("HUGGINGFACE_API_KEY", "")
+    HF_TOKEN: str = os.getenv("HF_TOKEN", "")
+    MISTRAL_API_KEY: str = os.getenv("MISTRAL_API_KEY", "")
+    ANTHROPIC_API_KEY: str = os.getenv("ANTHROPIC_API_KEY", "")
+    GEMINI_API_KEY: str = os.getenv("GEMINI_API_KEY", "")
+    OPENROUTER_API_KEY: str = os.getenv("OPENROUTER_API_KEY", "")
+    DEEPSEEK_API_KEY: str = os.getenv("DEEPSEEK_API_KEY", "")
+    DEEPSEEK_BASE_URL: str = os.getenv("DEEPSEEK_BASE_URL", "https://api.deepseek.com/v1")
+    LANGCHAIN_TRACING_V2: bool = os.getenv("LANGCHAIN_TRACING_V2", "false").lower() == "true"
+    LANGCHAIN_API_KEY: str = os.getenv("LANGCHAIN_API_KEY", "")
+    LANGCHAIN_PROJECT: str = os.getenv("LANGCHAIN_PROJECT", "aida_agent")
+    NODE_ENV: str = os.getenv("NODE_ENV", "development")
+    REDIS_URL: str = os.getenv("REDIS_URL", "")
+    REDIS_PORT: int = int(os.getenv("REDIS_PORT", "6379"))
+    REDIS_PASSWORD: str = os.getenv("REDIS_PASSWORD", "")
+    REDIS_USERNAME: str = os.getenv("REDIS_USERNAME", "default")
+    QDRANT_URL: str = os.getenv("QDRANT_URL", "http://localhost:6333")
+    QDRANT_API_KEY: str = os.getenv("QDRANT_API_KEY", "")
+    TAVILY_API_KEY: str = os.getenv("TAVILY_API_KEY", "")
+    SENTRY_DSN: str = os.getenv("SENTRY_DSN", "")
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+        extra = "ignore"          # allow undeclared vars in .env
+
+settings = Settings()

app/core/__init__.py

@@ -0,0 +1 @@
+"""Core utilities"""