tozo

app/ai/nodes/intent_node.py

@@ -1,4 +1,4 @@
-# app/ai/nodes/intent_node.py – FINAL: Multi-LLM routing + context mgmt + observability
+# app/ai/nodes/intent_node.py - WITH DYNAMIC ROLE SYSTEM
 import json
 import re
 from typing import Dict, List
@@ -15,6 +15,7 @@ from app.core.error_handling import (
 )
 from app.core.observability import get_token_tracker
 from app.ml.models.ml_listing_extractor import get_ml_extractor
+from app.ai.services.dynamic_role_manager import get_dynamic_role_manager
 from app.ai.nodes.draft_node import (
     _generate_title,
     _generate_description,
@@ -27,6 +28,22 @@ MAX_TOKENS = 600
 TEMP = 0
 
 ml_extractor = get_ml_extractor()
+role_manager = get_dynamic_role_manager()
+
+# Import Role-Based Inference Engine
+try:
+    from app.ml.models.user_role_context_handler import (
+        RoleBasedInferenceEngine,
+        UserRoleDetector,
+    )
+    role_engine = RoleBasedInferenceEngine()
+    role_detector = UserRoleDetector()
+    logger.info("Role-based inference engine loaded")
+except Exception as e:
+    logger.warning(f"Role-based inference not available: {e}")
+    role_engine = None
+    role_detector = None
+
 
 # ============================================================
 # Helpers
@@ -38,7 +55,7 @@ def _load_system() -> str:
         with open("app/ai/prompts/system_prompt.txt", encoding="utf-8") as f:
             return f.read()
     except FileNotFoundError:
-        logger.error("❌ System prompt file not found")
+        logger.error("System prompt file not found")
         return "You are Aida, a helpful AI assistant."
 
 SYSTEM_PROMPT = _load_system()
@@ -160,90 +177,105 @@ def _build_draft_preview(data: dict) -> dict:
         "field_confidences": data.get("field_validations", {}),
     }
 
+def infer_listing_type(state: Dict, user_role: str = None, user_message: str = None) -> tuple:
+    """Intelligently infer listing_type"""
+    
+    explicit_type = state.get("listing_type")
+    price_type = state.get("price_type")
+    
+    # 1. If explicitly stated, use it
+    if explicit_type and explicit_type in ["rent", "short-stay", "sale", "roommate"]:
+        logger.info(f"Listing type explicit: {explicit_type}")
+        return explicit_type, 0.99
+    
+    # 2. Infer from price_type
+    if price_type:
+        price_type_lower = price_type.lower().strip()
+        
+        # Short-stay indicators
+        if price_type_lower in ["nightly", "daily", "weekly", "night", "day", "week"]:
+            logger.info(f"Inferred short-stay from price_type: {price_type}")
+            return "short-stay", 0.95
+        
+        # Monthly/Yearly = RENT
+        elif price_type_lower in ["monthly", "yearly", "month", "year", "mth", "yr"]:
+            logger.info(f"Inferred rent from price_type: {price_type}")
+            return "rent", 0.95
+    
+    # 3. Default to rent
+    logger.warning("Could not infer listing_type, defaulting to rent")
+    return "rent", 0.5
+
+
 # ============================================================
-# Intent Node
+# Intent Node with Dynamic Role
 # ============================================================
 
 @async_retry(strategy=RetryStrategy.MODERATE, operation_name="intent_node")
 async def intent_node(state: Dict) -> Dict:
-    """
-    LangGraph node: Extract and route user intent
-    
-    Features:
-    - Command detection when preview active
-    - Smart LLM routing with auto-fallback
-    - Context window management
-    - ML validation and inference
-    - Full error handling and observability
-    """
+    """LangGraph node: Extract intent with DYNAMIC ROLE ASSIGNMENT"""
     
     current_msg = _get_current_message(state).lower()
     status = state.get("status")
+    base_user_role = state.get("user_role", "renter")  # Original signup role
     
     with trace_operation(
         "intent_node",
         {
             "status": status,
+            "base_role": base_user_role,
             "has_draft": state.get("draft_preview") is not None,
         }
     ):
-        # ===== CRITICAL: Handle commands FIRST when preview is active =====
+        # Handle commands FIRST when preview is active
         if status in {"preview_shown", "waiting_for_images"} and state.get("draft_preview"):
-            logger.info(f"🎯 COMMAND DETECTION MODE: status={status}")
+            logger.info(f"COMMAND DETECTION MODE: status={status}")
             
-            # PUBLISH command
             if any(w in current_msg for w in {"publish", "go live", "confirm", "yes", "ok"}):
-                logger.info("📤 COMMAND: publish")
+                logger.info("COMMAND: publish")
                 state["intent"] = "publish"
                 state["ai_reply"] = ""
                 return state
             
-            # EDIT command
             if "edit" in current_msg or "change" in current_msg or "update" in current_msg:
                 field = current_msg.replace("edit", "").replace("change", "").replace("update", "").strip()
-                logger.info(f"✏️ COMMAND: edit field='{field}'")
+                logger.info(f"COMMAND: edit field='{field}'")
                 state["status"] = "collecting"
                 state["missing_fields"] = [field] if field else ["location"]
                 state["ai_reply"] = f"Sure! What would you like to change for **{field}**?"
                 return state
             
-            # DISCARD command
             if any(w in current_msg for w in {"discard", "cancel", "delete", "no"}):
-                logger.info("🗑️ COMMAND: discard")
+                logger.info("COMMAND: discard")
                 state["status"] = None
                 state["draft_preview"] = None
                 state["intent"] = None
                 state["ai_reply"] = "Draft discarded. Let me know if you want to list another property!"
                 return state
             
-            # CASUAL CHAT
-            logger.info("💬 COMMAND: casual chat")
+            logger.info("COMMAND: casual chat")
             state["ai_reply"] = "Say **publish** to list, **edit** to change, or **discard** to start over."
             return state
         
-        # ===== End command detection =====
-        
+        # Skip if status is published or error
         if state.get("status") in ["published", "error"]:
-            logger.info(f"⭐ Skipping intent_node, status={state.get('status')}")
+            logger.info(f"Skipping intent_node, status={state.get('status')}")
             return state
         
-        user_role = state["user_role"]
         user_id = state.get("user_id")
         human_msg = state["messages"][-1]["content"]
         
-        # ===== LLM CALL WITH SMART ROUTING =====
+        # LLM CALL
         with trace_operation("llm_call_with_routing"):
             try:
-                # Manage context
                 context_mgr = get_context_manager()
                 messages = await context_mgr.manage_context([
-                    {"role": "system", "content": SYSTEM_PROMPT.replace("{user_role}", user_role)},
+                    {"role": "system", "content": SYSTEM_PROMPT.replace("{user_role}", base_user_role)},
                     {"role": "user", "content": human_msg},
                 ])
                 
-                logger.info(f"🤖 Calling LLM with smart routing")
+                logger.info("Calling LLM with smart routing")
                 
-                # Call LLM with smart routing
                 text, model_used, usage = await call_llm_smart(
                     messages,
                     intent=state.get("intent"),
@@ -251,7 +283,6 @@ async def intent_node(state: Dict) -> Dict:
                     max_tokens=MAX_TOKENS,
                 )
                 
-                # Track tokens
                 tracker = get_token_tracker()
                 tracker.record_tokens(
                     model_used,
@@ -260,7 +291,7 @@ async def intent_node(state: Dict) -> Dict:
                 )
                 
                 logger.info(
-                    f"✅ LLM response from {model_used}",
+                    f"LLM response from {model_used}",
                     extra={
                         "tokens": usage.get("total_tokens", 0),
                         "duration_ms": usage.get("duration_ms", 0),
@@ -270,26 +301,50 @@ async def intent_node(state: Dict) -> Dict:
                 raw = text
             
             except LLMError as e:
-                logger.error(f"❌ LLM error: {e.message}")
+                logger.error(f"LLM error: {e.message}")
                 state["ai_reply"] = "Sorry, I'm having trouble. Please try again."
                 state["status"] = "error"
                 return state
             
             except Exception as e:
-                logger.error(f"❌ Unexpected LLM error: {e}", exc_info=True)
+                logger.error(f"Unexpected LLM error: {e}", exc_info=True)
                 raise
         
-        # ===== Parse JSON response =====
+        # Parse JSON
         try:
             cleaned = _clean_json(raw)
             data = json.loads(cleaned)
         except json.JSONDecodeError as e:
-            logger.error(f"❌ Invalid JSON response: {raw[:100]}")
+            logger.error(f"Invalid JSON response: {raw[:100]}")
             data = {"allowed": False, "ai_reply": "Sorry, I didn't understand that. Could you rephrase?"}
         
-        # ===== Handle LISTING INTENT =====
+        # Handle LISTING INTENT with DYNAMIC ROLE
         if data.get("intent") == "list":
             data["allowed"] = True
+            listing_type = _normalize_listing_type(data.get("listing_type"))
+            
+            # NEW: Get dynamic role based on listing type
+            dynamic_role, role_desc, role_conf = role_manager.get_dynamic_role_for_listing(
+                base_user_role, 
+                listing_type
+            )
+            
+            if dynamic_role is None:
+                # User not allowed to create this type of listing
+                logger.warning(f"User {base_user_role} cannot create {listing_type} listing")
+                data["allowed"] = False
+                data["ai_reply"] = role_desc
+                state.update(
+                    allowed=False,
+                    ai_reply=data["ai_reply"],
+                    status="error"
+                )
+                return state
+            
+            # Store dynamic role in state
+            state["dynamic_role"] = dynamic_role
+            logger.info(f"Dynamic role assigned: {dynamic_role} ({role_desc})")
+            
             missing = _get_missing_fields(data)
             
             if missing:
@@ -301,56 +356,63 @@ async def intent_node(state: Dict) -> Dict:
                 data["missing_fields"] = []
                 data["draft_preview"] = _build_draft_preview(data)
                 data["ai_reply"] = "Perfect! Let me prepare your listing draft..."
-                logger.info("✅ All required fields complete")
+                logger.info("All required fields complete")
         
-        # ===== Handle SEARCH INTENT =====
+        # Handle SEARCH INTENT with DYNAMIC ROLE
         if data.get("intent") == "search":
             data["allowed"] = True
+            
+            # NEW: Get dynamic role for search
+            dynamic_role, role_desc, role_conf = role_manager.get_dynamic_role_for_search(
+                base_user_role,
+                data.get("listing_type")
+            )
+            
+            # Store dynamic role
+            state["dynamic_role"] = dynamic_role
+            logger.info(f"Dynamic role assigned: {dynamic_role} ({role_desc})")
         
-        # ===== Normalize values =====
+        # 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"))
         
-        # ===== ML INFERENCE & VALIDATION =====
+        # ML INFERENCE
         if data.get("intent") == "list":
             with trace_operation("ml_processing"):
-                # Extract location
                 if data.get("location"):
                     try:
                         city, loc_info = await ml_extractor.extract_location_from_address(data["location"])
                         if city:
                             data["location"] = city
                             data["location_details"] = loc_info
-                            logger.info(f"✅ Location extracted: {data['location']}")
+                            logger.info(f"Location extracted: {data['location']}")
                     except Exception as e:
-                        logger.warning(f"⚠️ Location extraction failed: {e}")
+                        logger.warning(f"Location extraction failed: {e}")
                 
-                # Infer listing type
                 try:
-                    lt, conf = ml_extractor.infer_listing_type(
-                        data, user_role=user_role, user_message=human_msg
+                    lt, conf = infer_listing_type(
+                        data, user_role=state.get("dynamic_role"), user_message=human_msg
                     )
                     if lt:
                         data["listing_type"] = lt
                         data["listing_confidence"] = conf
-                        logger.info(f"✅ Listing type inferred: {lt}")
+                        logger.info(f"Listing type inferred: {lt}")
                 except Exception as e:
-                    logger.warning(f"⚠️ Listing type inference failed: {e}")
+                    logger.warning(f"Listing type inference failed: {e}")
                 
-                # Infer currency
                 try:
                     currency, city, conf = await ml_extractor.infer_currency(data)
                     if currency:
                         data["currency"] = currency
                         data["currency_confidence"] = conf
-                        logger.info(f"✅ Currency inferred: {currency}")
+                        logger.info(f"Currency inferred: {currency}")
                 except Exception as e:
-                    logger.warning(f"⚠️ Currency inference failed: {e}")
+                    logger.warning(f"Currency inference failed: {e}")
                     data["currency"] = data.get("currency", "XOF")
         
-        # ===== Update state =====
+        # Update state
         state.update(
             allowed=data.get("allowed", False),
             status=data.get("status"),
@@ -372,9 +434,11 @@ async def intent_node(state: Dict) -> Dict:
         )
         
         logger.info(
-            f"👤 Intent node processed",
+            f"Intent node processed",
             extra={
                 "intent": data.get("intent"),
+                "base_role": base_user_role,
+                "dynamic_role": state.get("dynamic_role"),
                 "status": state.get("status"),
             }
         )

app/ai/prompts/system_prompt.txt

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

app/ai/routes/chat.py

@@ -1,4 +1,4 @@
-# app/ai/routes/chat.py - Enhanced with Observability & Rate Limiting
+# app/ai/routes/chat.py - Enhanced with Role Detection
 from fastapi import APIRouter, Depends, HTTPException, Request
 from fastapi.security import HTTPBearer
 from pydantic import BaseModel
@@ -34,6 +34,25 @@ class AskBody(BaseModel):
     user_role: Optional[str] = None
     history: Optional[List[MessageHistory]] = None
 
+# ============================================================
+# User Role Detection Helper
+# ============================================================
+
+async def detect_user_role_and_model(user_message: str):
+    """Detect user role and rental model from message"""
+    try:
+        from app.ml.models.user_role_context_handler import UserRoleDetector
+        
+        role_detector = UserRoleDetector()
+        detected_role, role_confidence = role_detector.detect_user_role(user_message.lower())
+        detected_model = role_detector.detect_rental_model(user_message.lower(), None)
+        
+        return detected_role, role_confidence, detected_model
+    except Exception as e:
+        logger.warning(f"Role detection failed: {e}")
+        return None, 0.0, None
+
+
 # ============================================================
 # Enhanced Chat Endpoint
 # ============================================================
@@ -45,14 +64,7 @@ async def ask_ai(
     request: Request,
     token: str = Depends(security),
 ):
-    """
-    Enhanced chat endpoint with:
-    - Rate limiting (token bucket)
-    - Distributed tracing
-    - Token tracking
-    - Error handling with observability
-    - Context management
-    """
+    """Enhanced chat endpoint with rate limiting and role detection"""
     
     start_time = time.time()
     request_id = request.headers.get("x-request-id", "unknown")
@@ -67,7 +79,7 @@ async def ask_ai(
         }
     ) as root_span:
         try:
-            # ===== Step 1: Validate Token =====
+            # Step 1: Validate Token
             with trace_operation("token_validation"):
                 payload = decode_access_token(token.credentials)
                 if not payload:
@@ -76,7 +88,7 @@ async def ask_ai(
             user_id = payload["user_id"]
             user_role = payload.get("role", "renter")
             
-            # ===== Step 2: Rate Limiting =====
+            # Step 2: Rate Limiting
             with trace_operation(
                 "rate_limit_check",
                 {"user_id": user_id, "operation": "chat"}
@@ -91,20 +103,46 @@ async def ask_ai(
                 
                 if not is_allowed:
                     logger.warning(
-                        f"🚫 Rate limit exceeded for user: {user_id}",
+                        f"Rate limit exceeded for user: {user_id}",
                         extra={"rate_info": rate_info}
                     )
                     raise RateLimitExceeded(retry_after=60)
                 
-                # Add rate limit headers
                 root_span.set_attribute("rate_limit.remaining", rate_info["user"]["remaining"])
                 root_span.set_attribute("rate_limit.capacity", rate_info["user"]["capacity"])
             
-            # ===== Step 3: Context Management =====
+            # Step 2b: User Role Detection (NEW)
+            with trace_operation("user_role_detection"):
+                try:
+                    detected_role, role_confidence, detected_model = await detect_user_role_and_model(
+                        body.message
+                    )
+                    
+                    if detected_role and role_confidence > 0.7:
+                        logger.info(
+                            f"User role detected",
+                            extra={
+                                "detected_role": detected_role,
+                                "confidence": role_confidence,
+                                "rental_model": detected_model.value if detected_model else None,
+                                "original_role": user_role,
+                            }
+                        )
+                        user_role = detected_role
+                        root_span.set_attribute("detected_role", detected_role)
+                        root_span.set_attribute("rental_model", detected_model.value if detected_model else None)
+                    else:
+                        logger.debug(f"Role detection inconclusive (confidence: {role_confidence:.0%})")
+                        root_span.set_attribute("role_confidence", role_confidence)
+                
+                except Exception as e:
+                    logger.warning(f"Role detection failed: {e}")
+            
+            # Step 3: Context Management
             with trace_operation("context_management", {"user_id": user_id}):
                 window = get_message_window(user_id)
                 
-                # Build conversation context from history (if provided)
+                # Build conversation context from history
                 conversation_context = ""
                 if body.history:
                     for msg in body.history:
@@ -122,7 +160,7 @@ async def ask_ai(
                 # Add to message window
                 window.add_message("user", full_message)
             
-            # ===== Step 4: AI Chat Processing =====
+            # Step 4: AI Chat Processing
             with trace_operation(
                 "aida_chat_sync",
                 {
@@ -137,9 +175,8 @@ async def ask_ai(
                     full_message,
                 )
             
-            # ===== Step 5: Token Tracking =====
+            # Step 5: Token Tracking
             with trace_operation("token_tracking"):
-                # Track tokens if available
                 usage = final_state.get("token_usage", {})
                 if usage:
                     tracker = get_token_tracker()
@@ -151,7 +188,7 @@ async def ask_ai(
                         usage.get("cost", 0.0),
                     )
             
-            # ===== Step 6: Build Response =====
+            # Step 6: Build Response
             response = {
                 "success": True,
                 "text": final_state.get("ai_reply", ""),
@@ -162,11 +199,12 @@ async def ask_ai(
                     "request_id": request_id,
                     "processing_time_ms": int((time.time() - start_time) * 1000),
                     "user_id": user_id,
+                    "user_role": user_role,
                     "status": final_state.get("status"),
                 },
             }
             
-            # ===== Step 7: Add Message to Window =====
+            # Step 7: Add Message to Window
             with trace_operation("window_update"):
                 window.add_message("assistant", final_state.get("ai_reply", ""))
             
@@ -179,9 +217,10 @@ async def ask_ai(
             })
             
             logger.info(
-                f"✅ Chat processed successfully",
+                f"Chat processed successfully",
                 extra={
                     "user_id": user_id,
+                    "user_role": user_role,
                     "request_id": request_id,
                     "processing_time_ms": response["metadata"]["processing_time_ms"],
                     "has_cards": len(response["cards"]) > 0,
@@ -192,7 +231,7 @@ async def ask_ai(
         
         except RateLimitExceeded as e:
             root_span.set_attribute("error.type", "rate_limit_exceeded")
-            logger.error(f"🚫 Rate limit: {str(e)}")
+            logger.error(f"Rate limit: {str(e)}")
             raise HTTPException(
                 status_code=429,
                 detail=e.message,
@@ -206,7 +245,7 @@ async def ask_ai(
             root_span.record_exception(e)
             root_span.set_attribute("error.type", type(e).__name__)
             logger.error(
-                f"❌ Chat endpoint error: {str(e)}",
+                f"Chat endpoint error: {str(e)}",
                 exc_info=True,
                 extra={"user_id": user_id if 'user_id' in locals() else "unknown"}
             )
@@ -248,7 +287,7 @@ async def get_rate_limit_status(
         }
 
 # ============================================================
-# Health Check with Rate Limiter
+# Health Check
 # ============================================================
 
 @router.get("/health")
@@ -264,5 +303,6 @@ async def chat_health() -> dict:
             "token_tracking": True,
             "context_management": True,
             "error_resilience": True,
+            "user_role_detection": True,
         },
     }

app/ai/services/dynamic_role_manager.py

@@ -0,0 +1,299 @@
+# app/ai/services/dynamic_role_manager.py - NEW
+"""
+Dynamic Role Management System
+Maps user's base role (landlord/renter) to specific roles based on listing/search type
+"""
+
+import logging
+from typing import Tuple
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class BaseRole(Enum):
+    """User's base role at signup"""
+    LANDLORD = "landlord"
+    RENTER = "renter"
+
+
+class DynamicRole(Enum):
+    """Dynamic roles based on action/listing type"""
+    # Landlord-derived roles
+    LANDLORD = "landlord"           # Creating rent listings
+    HOST = "host"                   # Creating short-stay listings
+    SELLER = "seller"               # Creating sale listings
+    
+    # Renter-derived roles
+    RENTER = "renter"               # Searching for rentals
+    GUEST = "guest"                 # Searching for short-stay
+    BUYER = "buyer"                 # Searching for properties to buy
+    ROOMMATE_SEEKER = "roommate_seeker"  # Searching for rooms
+    ROOMMATE_LISTER = "roommate_lister"  # Listing rooms (only renters)
+
+
+class DynamicRoleManager:
+    """Manage dynamic role assignment based on user action"""
+    
+    def __init__(self):
+        logger.info("Dynamic Role Manager initialized")
+    
+    def get_dynamic_role_for_listing(
+        self, 
+        base_role: str, 
+        listing_type: str
+    ) -> Tuple[str, str, float]:
+        """
+        Get dynamic role when user creates a LISTING
+        
+        Args:
+            base_role: User's base role at signup (landlord or renter)
+            listing_type: Type of listing (rent, short-stay, sale, roommate)
+        
+        Returns:
+            (dynamic_role, description, confidence)
+        """
+        
+        base_role_lower = base_role.lower().strip()
+        listing_type_lower = listing_type.lower().strip() if listing_type else None
+        
+        logger.info(f"Getting listing role: base={base_role_lower}, type={listing_type_lower}")
+        
+        # LANDLORD creating listings
+        if base_role_lower == "landlord":
+            
+            # Landlord + short-stay = HOST
+            if listing_type_lower == "short-stay":
+                logger.info("Landlord creating short-stay -> HOST role")
+                return DynamicRole.HOST.value, "Short-stay property host", 0.99
+            
+            # Landlord + sale = SELLER
+            elif listing_type_lower == "sale":
+                logger.info("Landlord creating sale -> SELLER role")
+                return DynamicRole.SELLER.value, "Property seller", 0.99
+            
+            # Landlord + rent = LANDLORD (standard)
+            elif listing_type_lower == "rent":
+                logger.info("Landlord creating rent -> LANDLORD role")
+                return DynamicRole.LANDLORD.value, "Rental property landlord", 0.99
+            
+            # Landlord cannot create roommate listings
+            elif listing_type_lower == "roommate":
+                logger.warning("Landlord cannot create roommate listings")
+                return None, "Landlords cannot list for roommate matching", 0.0
+        
+        # RENTER creating listings
+        elif base_role_lower == "renter":
+            
+            # Only renters can create roommate listings
+            if listing_type_lower == "roommate":
+                logger.info("Renter creating roommate -> ROOMMATE_LISTER role")
+                return DynamicRole.ROOMMATE_LISTER.value, "Room share lister", 0.99
+            
+            # Renters cannot create rent/short-stay/sale listings
+            else:
+                logger.warning(f"Renter cannot create {listing_type_lower} listings")
+                return None, "Renters can only list rooms for roommate matching", 0.0
+        
+        logger.warning(f"Unknown base role: {base_role_lower}")
+        return None, "Unknown role", 0.0
+    
+    def get_dynamic_role_for_search(
+        self, 
+        base_role: str, 
+        search_for: str = None
+    ) -> Tuple[str, str, float]:
+        """
+        Get dynamic role when user SEARCHES for properties
+        
+        Args:
+            base_role: User's base role at signup (landlord or renter)
+            search_for: What they're searching for (rent, short-stay, sale, roommate)
+        
+        Returns:
+            (dynamic_role, description, confidence)
+        """
+        
+        base_role_lower = base_role.lower().strip()
+        search_for_lower = search_for.lower().strip() if search_for else None
+        
+        logger.info(f"Getting search role: base={base_role_lower}, search_for={search_for_lower}")
+        
+        # LANDLORD searching
+        if base_role_lower == "landlord":
+            logger.warning("Landlords searching for properties - unusual but allowed")
+            
+            if search_for_lower == "short-stay":
+                return DynamicRole.GUEST.value, "Short-stay guest (unusual)", 0.5
+            elif search_for_lower == "sale":
+                return DynamicRole.BUYER.value, "Property buyer (unusual)", 0.5
+            else:
+                return DynamicRole.RENTER.value, "Searching for rentals (unusual)", 0.5
+        
+        # RENTER searching
+        elif base_role_lower == "renter":
+            
+            # Searching for rentals = RENTER
+            if search_for_lower == "rent":
+                logger.info("Renter searching for rent -> RENTER role")
+                return DynamicRole.RENTER.value, "Rental searcher", 0.99
+            
+            # Searching for short-stay = GUEST
+            elif search_for_lower == "short-stay":
+                logger.info("Renter searching for short-stay -> GUEST role")
+                return DynamicRole.GUEST.value, "Short-stay guest", 0.99
+            
+            # Searching for sale = BUYER
+            elif search_for_lower == "sale":
+                logger.info("Renter searching for sale -> BUYER role")
+                return DynamicRole.BUYER.value, "Property buyer", 0.99
+            
+            # Searching for roommate = ROOMMATE_SEEKER
+            elif search_for_lower == "roommate":
+                logger.info("Renter searching for roommate -> ROOMMATE_SEEKER role")
+                return DynamicRole.ROOMMATE_SEEKER.value, "Roommate seeker", 0.99
+            
+            # Default search = RENTER
+            else:
+                logger.info("Renter searching (unspecified) -> RENTER role")
+                return DynamicRole.RENTER.value, "Property searcher", 0.95
+        
+        logger.warning(f"Unknown base role: {base_role_lower}")
+        return None, "Unknown role", 0.0
+    
+    def get_ai_prompt_for_role(self, dynamic_role: str) -> str:
+        """
+        Get AI prompt context for specific dynamic role
+        
+        Args:
+            dynamic_role: The dynamic role (e.g., "host", "seller", "guest")
+        
+        Returns:
+            Prompt context string for AI
+        """
+        
+        prompts = {
+            "landlord": """
+You are helping a landlord list a rental property.
+Focus on: location, monthly/yearly price, bedrooms, bathrooms, furnished/unfurnished, utilities
+Help collect: location, price (monthly), bedrooms, bathrooms, amenities, requirements for tenants
+Pricing context: Monthly or yearly rental rates
+""",
+            
+            "host": """
+You are helping a short-stay property host (Airbnb-style).
+Focus on: location, nightly/daily price, guest amenities, cleanliness, WiFi, kitchen, parking
+Help collect: location, price (nightly), bedrooms, bathrooms, amenities, house rules
+Pricing context: Nightly, daily, or weekly rates
+Emphasize: Guest experience, cleanliness, quick check-in/out, amenities
+""",
+            
+            "seller": """
+You are helping someone sell a property.
+Focus on: location, total sale price, property condition, bedrooms, bathrooms, unique features
+Help collect: location, price (fixed), bedrooms, bathrooms, property type, amenities
+Pricing context: Total sale price (not per month/night)
+Emphasize: Investment potential, property condition, neighborhood, documentation status
+""",
+            
+            "renter": """
+You are helping a renter find a rental property.
+Focus on: budget, location, bedrooms, bathrooms, move-in date, lease terms
+Ask questions about: Budget range, location preference, must-have amenities
+Show filters for: Monthly price range, bedrooms, bathrooms, furnished/unfurnished
+Emphasize: Affordability, proximity to work/school, security, utilities included
+""",
+            
+            "guest": """
+You are helping someone find a short-stay property (Airbnb-style).
+Focus on: budget, location, dates, guest amenities, proximity to attractions
+Ask questions about: Check-in date, check-out date, budget per night, location preference
+Show filters for: Nightly price range, bedrooms, host reviews, amenities
+Emphasize: Guest reviews, cleanliness, host responsiveness, location convenience
+""",
+            
+            "buyer": """
+You are helping someone buy a property.
+Focus on: budget, location, property type, bedrooms, bathrooms, investment potential
+Ask questions about: Total budget, location preference, property type, timeline
+Show filters for: Price range, bedrooms, bathrooms, neighborhood, property type
+Emphasize: Investment returns, property condition, financing options, neighborhood potential
+""",
+            
+            "roommate_seeker": """
+You are helping someone find a room to share with a roommate.
+Focus on: budget, location, roommate compatibility, house rules, utilities included
+Ask questions about: Budget, location, move-in date, roommate preferences
+Show filters for: Monthly budget, bedrooms available, location, utilities included
+Emphasize: Affordable housing, roommate compatibility, house rules, community
+""",
+            
+            "roommate_lister": """
+You are helping a renter list a room for roommate matching.
+Focus on: location, monthly price, available rooms, house rules, utilities included
+Help collect: location, price (monthly), rooms available, bathrooms, house rules, amenities
+Pricing context: Monthly rates split between roommates
+Emphasize: Roommate compatibility, house culture, shared amenities, community
+""",
+        }
+        
+        return prompts.get(dynamic_role, prompts["renter"])
+    
+    def validate_role_action(
+        self, 
+        base_role: str, 
+        action: str, 
+        listing_or_search_type: str
+    ) -> Tuple[bool, str]:
+        """
+        Validate if user (base role) can perform action with given type
+        
+        Args:
+            base_role: User's base role (landlord or renter)
+            action: What user wants to do (list, search)
+            listing_or_search_type: Type (rent, short-stay, sale, roommate)
+        
+        Returns:
+            (is_allowed, reason)
+        """
+        
+        base_role_lower = base_role.lower().strip()
+        action_lower = action.lower().strip()
+        type_lower = listing_or_search_type.lower().strip()
+        
+        logger.info(f"Validating: {base_role_lower} {action_lower} {type_lower}")
+        
+        # LANDLORD rules for LISTING
+        if base_role_lower == "landlord" and action_lower == "list":
+            if type_lower in ["rent", "short-stay", "sale"]:
+                return True, f"Landlord can list {type_lower}"
+            elif type_lower == "roommate":
+                return False, "Landlords cannot list for roommate matching. Only renters can share rooms."
+            else:
+                return False, f"Unknown listing type: {type_lower}"
+        
+        # RENTER rules for LISTING
+        if base_role_lower == "renter" and action_lower == "list":
+            if type_lower == "roommate":
+                return True, "Renters can list rooms for roommate matching"
+            elif type_lower in ["rent", "short-stay", "sale"]:
+                return False, "Renters can only list rooms for roommate matching"
+            else:
+                return False, f"Unknown listing type: {type_lower}"
+        
+        # SEARCH rules (both can search anything)
+        if action_lower == "search":
+            return True, f"Can search for {type_lower}"
+        
+        return False, f"Invalid action: {action_lower}"
+
+
+# Singleton
+_manager = None
+
+def get_dynamic_role_manager() -> DynamicRoleManager:
+    """Get or create singleton"""
+    global _manager
+    if _manager is None:
+        _manager = DynamicRoleManager()
+    return _manager

app/ml/models/combined_training_data.csv

@@ -0,0 +1,4 @@
+price,bedrooms,bathrooms,location,dataset_source,price_per_bedroom,price_per_bathroom,total_rooms,price_range
+250000,2,1,Unknown,dummy,125000.0,250000.0,3,mid
+350000,3,2,Unknown,dummy,116666.66666666667,175000.0,5,mid
+450000,4,3,Unknown,dummy,112500.0,150000.0,7,mid

app/ml/models/combined_training_data.jsonl

@@ -0,0 +1,3 @@
+{"price": 250000, "bedrooms": 2, "bathrooms": 1, "location": "Unknown", "dataset_source": "dummy", "price_per_bedroom": 125000.0, "price_per_bathroom": 250000.0, "total_rooms": 3, "price_range": "mid"}
+{"price": 350000, "bedrooms": 3, "bathrooms": 2, "location": "Unknown", "dataset_source": "dummy", "price_per_bedroom": 116666.66666666667, "price_per_bathroom": 175000.0, "total_rooms": 5, "price_range": "mid"}
+{"price": 450000, "bedrooms": 4, "bathrooms": 3, "location": "Unknown", "dataset_source": "dummy", "price_per_bedroom": 112500.0, "price_per_bathroom": 150000.0, "total_rooms": 7, "price_range": "mid"}

app/ml/models/combined_training_data.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b21dc388814014d2ac5628bc908cd8d1eb26b796b80e32d085602570bb37e457
+size 6104

app/ml/models/dataset_info.json

@@ -0,0 +1,31 @@
+{
+  "rows": 3,
+  "cols": [
+    "price",
+    "bedrooms",
+    "bathrooms",
+    "location",
+    "dataset_source",
+    "price_per_bedroom",
+    "price_per_bathroom",
+    "total_rooms",
+    "price_range"
+  ],
+  "price": {
+    "mean": 350000.0,
+    "median": 350000.0,
+    "min": 250000.0,
+    "max": 450000.0
+  },
+  "bedrooms": {
+    "mean": 3.0,
+    "min": 2,
+    "max": 4
+  },
+  "bathrooms": {
+    "mean": 2.0,
+    "min": 1,
+    "max": 3
+  },
+  "locations": 1
+}

app/ml/models/field_models.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02ac017f49114480a299778b1190bcd6a30a30f723abcfae85e34b2331e73c7f
+size 91689397

app/ml/models/ml_listing_extractor.py

@@ -1,4 +1,4 @@
-# app/ml/ml_listing_extractor.py - Complete ML Extractor with Smart Inference
+# app/ml/models/ml_listing_extractor.py - Complete ML Extractor
 import json
 import numpy as np
 from typing import Dict, List, Tuple, Optional
@@ -6,8 +6,6 @@ import logging
 import os
 import re
 from datetime import datetime, timedelta
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.preprocessing import LabelEncoder
 import joblib
 from sentence_transformers import SentenceTransformer
 import aiohttp
@@ -28,7 +26,7 @@ class CurrencyManager:
         self.cache_expiry = {}
         self.cache_ttl = 86400  # 24 hours
         
-        logger.info("💱 Currency Manager initialized")
+        logger.info("Currency Manager initialized")
     
     async def get_currency_for_location(self, location: str) -> Tuple[str, str, str, float]:
         """Get currency for a location using geolocation API"""
@@ -39,7 +37,7 @@ class CurrencyManager:
         if location_lower in self.location_cache:
             cached = self.location_cache[location_lower]
             if self._is_cache_valid(f"location_{location_lower}"):
-                logger.info(f"✅ Location cache hit: {location} → {cached['city']} → {cached['currency']}")
+                logger.info(f"Location cache hit: {location} -> {cached['city']} -> {cached['currency']}")
                 return cached['currency'], cached['country'], cached['city'], 0.95
         
         try:
@@ -85,13 +83,13 @@ class CurrencyManager:
                                 }
                                 self._set_cache_expiry(f"location_{location_lower}")
                                 
-                                logger.info(f"✅ Found: {location} → {city}, {country} → {currency}")
+                                logger.info(f"Found: {location} -> {city}, {country} -> {currency}")
                                 return currency, country, city, 0.93
         
         except Exception as e:
-            logger.warning(f"⚠️ Failed to get currency for location {location}: {e}")
+            logger.warning(f"Failed to get currency for location {location}: {e}")
         
-        logger.warning(f"❌ Could not determine currency for {location}")
+        logger.warning(f"Could not determine currency for {location}")
         return None, None, location, 0.0
     
     async def _get_currency_for_country(self, country_name: str, country_code: str = None) -> Optional[str]:
@@ -111,7 +109,7 @@ class CurrencyManager:
                             currencies = data[0].get('currencies', {})
                             if currencies:
                                 currency_code = list(currencies.keys())[0]
-                                logger.info(f"✅ Country {country_name} ({country_code}) → {currency_code}")
+                                logger.info(f"Country {country_name} ({country_code}) -> {currency_code}")
                                 return currency_code
         
         except Exception as e:
@@ -131,7 +129,7 @@ class CurrencyManager:
         cache_key = f"{from_currency}_rates"
         if cache_key in self.exchange_rate_cache:
             if self._is_cache_valid(cache_key):
-                logger.info(f"✅ Exchange rate cache hit for {from_currency}")
+                logger.info(f"Exchange rate cache hit for {from_currency}")
                 return self.exchange_rate_cache[cache_key]
         
         try:
@@ -152,11 +150,11 @@ class CurrencyManager:
                         self.exchange_rate_cache[cache_key] = filtered_rates
                         self._set_cache_expiry(cache_key)
                         
-                        logger.info(f"✅ Fetched exchange rates for {from_currency}")
+                        logger.info(f"Fetched exchange rates for {from_currency}")
                         return filtered_rates
         
         except Exception as e:
-            logger.error(f"❌ Failed to fetch exchange rates: {e}")
+            logger.error(f"Failed to fetch exchange rates: {e}")
         
         return {}
     
@@ -176,17 +174,17 @@ class CurrencyManager:
         self.location_cache.clear()
         self.exchange_rate_cache.clear()
         self.cache_expiry.clear()
-        logger.info("🗑️ Currency caches cleared")
+        logger.info("Currency caches cleared")
 
 
 class MLListingExtractor:
-    """ML-powered field extractor with SMART INFERENCE"""
+    """ML-powered field extractor with SMART INFERENCE + TRAINED MODELS"""
     
     def __init__(self, model_dir: str = "app/ml/models"):
-        self.model_dir = model_dir  # This will be "app/ml/models" by default
+        self.model_dir = model_dir
         os.makedirs(model_dir, exist_ok=True)
         
-        logger.info("🚀 Loading ML Listing Extractor...")
+        logger.info("Loading ML Listing Extractor...")
         
         # Embedder for semantic similarity
         try:
@@ -201,7 +199,7 @@ class MLListingExtractor:
         # Currency manager with live APIs
         self.currency_mgr = CurrencyManager()
         
-        # Field validators & confidence models
+        # Load trained field models
         self.field_models = self._load_field_models()
         
         # Learning history
@@ -209,11 +207,11 @@ class MLListingExtractor:
         self.field_patterns = {}
         self.user_corrections = {}
         
-        logger.info("✅ ML Extractor loaded with live currency APIs")
+        logger.info("ML Extractor loaded with live currency APIs & trained models")
     
     def _load_field_models(self) -> Dict:
-        """Load or create field ML models"""
-        # Try multiple possible paths
+        """Load trained field ML models from enhanced training"""
+        
         possible_paths = [
             f"{self.model_dir}/field_models.pkl",
             "app/ml/models/field_models.pkl",
@@ -224,13 +222,20 @@ class MLListingExtractor:
             if os.path.exists(models_file):
                 try:
                     models = joblib.load(models_file)
-                    logger.info(f"✅ Loaded field models from {models_file}")
+                    
+                    logger.info(f"Loaded trained field models from {models_file}")
+                    logger.info(f"   - location_classifier: {models.get('location_classifier') is not None}")
+                    logger.info(f"   - price_model: {models.get('price_model') is not None}")
+                    logger.info(f"   - price_patterns: {len(models.get('price_patterns', {}))} locations")
+                    
                     return models
+                
                 except Exception as e:
                     logger.warning(f"Failed to load models from {models_file}: {e}")
         
-        logger.info("⚠️ No field models found. Training is required.")
-        logger.info("Run: python app/ml/trainning/train_complete_model.py")
+        logger.info("No trained field models found.")
+        logger.info("   To train: python scripts/download_training_data.py")
+        logger.info("   Then: python scripts/train_models.py")
         
         # Return empty models dict as fallback
         return {
@@ -239,59 +244,57 @@ class MLListingExtractor:
             "price_patterns": {},
             "amenity_frequencies": {},
             "embedder": None,
+            "scaler": None,
         }
     
-    # ==================== SMART LISTING TYPE INFERENCE ====================
     def infer_listing_type(self, state: Dict, user_role: str = None, user_message: str = None) -> Tuple[str, float]:
-        """Intelligently infer listing_type from price_type, user role, and message keywords"""
+        """Intelligently infer listing_type"""
         
         explicit_type = state.get("listing_type")
         price_type = state.get("price_type")
         
-        # 1️⃣ If explicitly stated, use it
+        # 1. If explicitly stated, use it
         if explicit_type and explicit_type in ["rent", "short-stay", "sale", "roommate"]:
-            logger.info(f"✅ Listing type explicit: {explicit_type}")
+            logger.info(f"Listing type explicit: {explicit_type}")
             return explicit_type, 0.99
         
-        # 2️⃣ User role matters FIRST
+        # 2. User role matters FIRST
         if user_role:
             user_role_lower = user_role.lower().strip()
             
             # If user is renter, ALWAYS roommate
             if user_role_lower == "renter":
-                logger.info(f"✅ User is renter → roommate listing")
+                logger.info("User is renter -> roommate listing")
                 return "roommate", 0.98
             
             # If user is landlord, check other signals
             if user_role_lower == "landlord":
-                # Check user message for sale keywords
                 if user_message:
                     msg_lower = user_message.lower()
                     sale_keywords = ["sell", "sale", "selling", "for sale", "purchase", "buy"]
                     
                     if any(keyword in msg_lower for keyword in sale_keywords):
-                        logger.info(f"✅ Detected sale keywords → sale")
+                        logger.info("Detected sale keywords -> sale")
                         return "sale", 0.95
         
-        # 3️⃣ Infer from price_type (short-stay only indicator)
+        # 3. Infer from price_type
         if price_type:
             price_type_lower = price_type.lower().strip()
             
             # Short-stay indicators
             if price_type_lower in ["nightly", "daily", "weekly", "night", "day", "week"]:
-                logger.info(f"✅ Inferred short-stay from price_type: {price_type}")
+                logger.info(f"Inferred short-stay from price_type: {price_type}")
                 return "short-stay", 0.95
             
-            # Monthly/Yearly = RENT (not sale!)
+            # Monthly/Yearly = RENT
             elif price_type_lower in ["monthly", "yearly", "month", "year", "mth", "yr"]:
-                logger.info(f"✅ Inferred rent from price_type: {price_type}")
+                logger.info(f"Inferred rent from price_type: {price_type}")
                 return "rent", 0.95
         
-        # 4️⃣ Default to rent
-        logger.warning("⚠️ Could not infer listing_type, defaulting to rent")
+        # 4. Default to rent
+        logger.warning("Could not infer listing_type, defaulting to rent")
         return "rent", 0.5
     
-    # ==================== SMART CURRENCY INFERENCE ====================
     async def infer_currency(self, state: Dict) -> Tuple[str, str, float]:
         """Intelligently infer currency from location"""
         
@@ -299,29 +302,28 @@ class MLListingExtractor:
         location = state.get("location")
         listing_type = state.get("listing_type")
         
-        # 1️⃣ If explicitly stated
+        # 1. If explicitly stated
         if explicit_currency and len(explicit_currency) == 3:
-            logger.info(f"✅ Currency explicit: {explicit_currency}")
+            logger.info(f"Currency explicit: {explicit_currency}")
             return explicit_currency, location, 0.99
         
-        # 2️⃣ Short-stay always in USD
+        # 2. Short-stay always in USD
         if listing_type == "short-stay":
-            logger.info(f"✅ Short-stay detected, using USD")
+            logger.info("Short-stay detected, using USD")
             return "USD", location, 0.98
         
-        # 3️⃣ Infer from location using Nominatim + REST Countries
+        # 3. Infer from location
         if location:
             currency, country, city, confidence = await self.currency_mgr.get_currency_for_location(location)
             
             if currency:
-                logger.info(f"✅ Extracted city: {location} → {city}, {country} → {currency}")
+                logger.info(f"Extracted city: {location} -> {city}, {country} -> {currency}")
                 state["location"] = city
                 return currency, city, confidence
         
-        logger.warning("⚠️ Could not infer currency, will ask user")
+        logger.warning("Could not infer currency, will ask user")
         return None, location, 0.0
     
-    # ==================== PRICE CONVERSION FOR DISPLAY ====================
     async def convert_price_for_display(self, price: float, from_currency: str, to_currency: str = "USD") -> Dict:
         """Convert price using LIVE exchange rates"""
         
@@ -346,7 +348,7 @@ class MLListingExtractor:
                 from_symbol = symbols.get(from_currency, from_currency)
                 to_symbol = symbols.get(to_currency, to_currency)
                 
-                formatted = f"{from_symbol}{price:,} (≈{to_symbol}{display_price:,.2f})"
+                formatted = f"{from_symbol}{price:,} (approx {to_symbol}{display_price:,.2f})"
                 
                 return {
                     "original_price": price,
@@ -358,7 +360,7 @@ class MLListingExtractor:
                 }
         
         except Exception as e:
-            logger.error(f"❌ Failed to convert price: {e}")
+            logger.error(f"Failed to convert price: {e}")
         
         return {
             "original_price": price,
@@ -375,14 +377,14 @@ class MLListingExtractor:
         
         symbol_map = {
             "USD": "$",
-            "EUR": "€",
-            "GBP": "£",
-            "NGN": "₦",
-            "XOF": "Fr",
-            "KES": "Ks",
-            "GHS": "₵",
-            "ZAR": "R",
-            "AED": "د.إ",
+            "EUR": "EUR",
+            "GBP": "GBP",
+            "NGN": "NGN",
+            "XOF": "XOF",
+            "KES": "KES",
+            "GHS": "GHS",
+            "ZAR": "ZAR",
+            "AED": "AED",
         }
         
         for currency in currencies:
@@ -446,15 +448,14 @@ class MLListingExtractor:
                                 "confidence": 0.93
                             }
                             
-                            logger.info(f"✅ Extracted location: {address} → {city}")
+                            logger.info(f"Extracted location: {address} -> {city}")
                             return city, location_info
         
         except Exception as e:
-            logger.error(f"❌ Failed to extract location from address: {e}")
+            logger.error(f"Failed to extract location from address: {e}")
         
         return None, {}
     
-    # ==================== FIELD VALIDATION ====================
     def validate_field(self, field_name: str, value: any, user_input: str, user_id: str = None) -> Dict:
         """Validate a single field"""
         

app/ml/models/user_role_context_handler.py

@@ -0,0 +1,607 @@
+#!/usr/bin/env python3
+"""
+user_role_context_handler.py - Handle different user roles and rental models
+Supports: Airbnb (host/guest), African rentals (landlord/renter/tenant)
+"""
+
+import logging
+from typing import Dict, Tuple, Optional
+from enum import Enum
+import re
+
+logger = logging.getLogger(__name__)
+
+
+class RentalModel(Enum):
+    """Different rental models"""
+    AIRBNB = "airbnb"           # Short-stay, host/guest model
+    AFRICAN_RENTAL = "african"  # Long-term rent, landlord/tenant model
+    ROOMMATE = "roommate"       # Room sharing in existing space
+    MIXED = "mixed"             # Both types possible
+    UNKNOWN = "unknown"
+
+
+class UserRole:
+    """Handle different user roles across rental models"""
+    
+    # Airbnb roles
+    AIRBNB_HOST = "airbnb_host"
+    AIRBNB_GUEST = "airbnb_guest"
+    
+    # African rental roles
+    LANDLORD = "landlord"
+    RENTER = "renter"
+    TENANT = "tenant"  # Alias for renter
+    
+    # Roommate roles
+    HOMEOWNER_SEEKING_ROOMMATE = "homeowner_seeking_roommate"  # Has space, looking for roommate
+    ROOMMATE_SEEKER = "roommate_seeker"  # Looking for a room to share
+    
+    # Generic
+    OWNER = "owner"
+    BUYER = "buyer"
+    SELLER = "seller"
+
+
+class UserRoleDetector:
+    """Intelligently detect user role from context"""
+    
+    def __init__(self):
+        # Keywords for role detection
+        self.host_keywords = {
+            "airbnb": ["host", "hosting", "list my property", "list my place", "rent out", "share"],
+            "african": ["landlord", "owner", "property owner", "im renting out", "im listing"]
+        }
+        
+        self.guest_keywords = {
+            "airbnb": ["guest", "book", "looking for place", "need accommodation", "airbnb"],
+            "african": ["renter", "tenant", "looking to rent", "seeking", "want to rent", "im looking for"]
+        }
+        
+        self.buyer_keywords = ["buy", "purchase", "for sale", "selling", "acquire"]
+        self.seller_keywords = ["sell", "selling", "sale", "list for sale"]
+        
+        # Roommate keywords
+        self.homeowner_seeking_roommate_keywords = [
+            "looking for a roommate", "need a roommate", "seeking roommate", 
+            "want to share my", "have a spare room", "room available",
+            "looking to share", "share my apartment", "share my house",
+            "my place is too big", "extra room", "can share"
+        ]
+        
+        self.roommate_seeker_keywords = [
+            "looking for a room", "seeking a room", "need a room",
+            "looking for roommate", "want to share a place", "room for rent",
+            "share accommodation", "shared apartment", "shared house",
+            "need accommodation", "looking for a place to share"
+        ]
+        
+        logger.info("🔍 User Role Detector initialized")
+    
+    def detect_rental_model(self, user_message: str, location: str = None) -> RentalModel:
+        """Detect which rental model user is in"""
+        
+        msg_lower = user_message.lower().strip()
+        
+        # Keywords indicating Airbnb model
+        airbnb_indicators = ["airbnb", "short stay", "nightly", "daily", "vacation rental", "host"]
+        
+        # Keywords indicating African rental model
+        african_indicators = ["landlord", "tenant", "renter", "monthly rent", "long term", "furnished room"]
+        
+        # Keywords indicating roommate model
+        roommate_indicators = ["roommate", "share my", "spare room", "share apartment", "shared house", "share a place"]
+        
+        # Check for explicit indicators
+        for indicator in roommate_indicators:
+            if indicator in msg_lower:
+                logger.info(f"🏘️ Detected roommate model: '{indicator}'")
+                return RentalModel.ROOMMATE
+        
+        for indicator in airbnb_indicators:
+            if indicator in msg_lower:
+                logger.info(f"🏨 Detected Airbnb model: '{indicator}'")
+                return RentalModel.AIRBNB
+        
+        for indicator in african_indicators:
+            if indicator in msg_lower:
+                logger.info(f"🏢 Detected African rental model: '{indicator}'")
+                return RentalModel.AFRICAN_RENTAL
+        
+        # Location-based inference (African locations more likely = African model)
+        if location:
+            african_countries = ["benin", "nigeria", "kenya", "ghana", "south africa", "uganda", "senegal"]
+            if any(country in location.lower() for country in african_countries):
+                logger.info(f"📍 African location detected: {location}")
+                return RentalModel.AFRICAN_RENTAL
+        
+        # Default to mixed
+        return RentalModel.MIXED
+    
+    def detect_user_role(self, user_message: str, rental_model: RentalModel = None) -> Tuple[str, float]:
+        """
+        Detect user role from message
+        Returns: (role, confidence)
+        """
+        
+        msg_lower = user_message.lower().strip()
+        
+        if rental_model is None:
+            rental_model = self.detect_rental_model(user_message)
+        
+        # ==================== SELLER / LANDLORD ====================
+        
+        # Check for explicit landlord/owner language
+        landlord_explicit = ["im a landlord", "im the landlord", "i own", "i own this", "as a landlord"]
+        for phrase in landlord_explicit:
+            if phrase in msg_lower:
+                logger.info(f"✅ Explicit landlord detected: '{phrase}'")
+                return UserRole.LANDLORD, 0.99
+        
+        # Check for listing/rental language
+        if rental_model == RentalModel.AFRICAN_RENTAL:
+            landlord_signals = [
+                "im listing", "list my", "im renting out", "property for rent",
+                "available for rent", "i have a", "i own a"
+            ]
+            for signal in landlord_signals:
+                if signal in msg_lower:
+                    logger.info(f"🏠 African landlord signal: '{signal}'")
+                    return UserRole.LANDLORD, 0.90
+        
+        if rental_model == RentalModel.AIRBNB:
+            host_signals = ["im hosting", "im a host", "list on airbnb", "airbnb host", "share my place"]
+            for signal in host_signals:
+                if signal in msg_lower:
+                    logger.info(f"🏨 Airbnb host signal: '{signal}'")
+                    return UserRole.AIRBNB_HOST, 0.90
+        
+        # ==================== BUYER / SELLER (SALE) ====================
+        
+        # Explicit sale language
+        seller_signals = ["im selling", "for sale", "sell my", "selling property", "list for sale"]
+        for signal in seller_signals:
+            if signal in msg_lower:
+                logger.info(f"💰 Seller detected: '{signal}'")
+                return UserRole.SELLER, 0.95
+        
+        buyer_signals = ["want to buy", "looking to purchase", "im buying", "purchase property"]
+        for signal in buyer_signals:
+            if signal in msg_lower:
+                logger.info(f"💳 Buyer detected: '{signal}'")
+                return UserRole.BUYER, 0.95
+        
+        # ==================== RENTER / GUEST ====================
+        
+        # Check for explicit renter language
+        renter_explicit = ["im a tenant", "im a renter", "im looking to rent", "looking for a place to rent"]
+        for phrase in renter_explicit:
+            if phrase in msg_lower:
+                logger.info(f"✅ Explicit renter/tenant detected: '{phrase}'")
+                
+                if rental_model == RentalModel.AFRICAN_RENTAL:
+                    return UserRole.TENANT, 0.99
+                else:
+                    return UserRole.AIRBNB_GUEST, 0.99
+        
+        # ==================== ROOMMATE ROLES ====================
+        
+        # Homeowner seeking roommate
+        for keyword in self.homeowner_seeking_roommate_keywords:
+            if keyword in msg_lower:
+                logger.info(f"✅ Homeowner seeking roommate detected: '{keyword}'")
+                return UserRole.HOMEOWNER_SEEKING_ROOMMATE, 0.90
+        
+        # Roommate seeker
+        for keyword in self.roommate_seeker_keywords:
+            if keyword in msg_lower:
+                logger.info(f"✅ Roommate seeker detected: '{keyword}'")
+                return UserRole.ROOMMATE_SEEKER, 0.90
+        
+        # Guest/renter signals
+        if rental_model == RentalModel.AFRICAN_RENTAL:
+            renter_signals = [
+                "looking for a", "need a", "seeking", "want to rent",
+                "im looking for", "show me", "what do you have", "available rooms"
+            ]
+            for signal in renter_signals:
+                if signal in msg_lower:
+                    logger.info(f"🔍 African renter signal: '{signal}'")
+                    return UserRole.RENTER, 0.80
+        
+        if rental_model == RentalModel.AIRBNB:
+            guest_signals = [
+                "looking for accommodation", "need a place", "book",
+                "where can i stay", "available places", "show me listings"
+            ]
+            for signal in guest_signals:
+                if signal in msg_lower:
+                    logger.info(f"🔍 Airbnb guest signal: '{signal}'")
+                    return UserRole.AIRBNB_GUEST, 0.80
+        
+        logger.warning(f"⚠️ Could not determine user role from: {user_message}")
+        return None, 0.0
+    
+    def validate_role_consistency(self, user_role: str, rental_model: RentalModel) -> bool:
+        """Validate that role matches rental model"""
+        
+        valid_combinations = {
+            RentalModel.AIRBNB: [UserRole.AIRBNB_HOST, UserRole.AIRBNB_GUEST],
+            RentalModel.AFRICAN_RENTAL: [UserRole.LANDLORD, UserRole.RENTER, UserRole.TENANT],
+            RentalModel.ROOMMATE: [UserRole.HOMEOWNER_SEEKING_ROOMMATE, UserRole.ROOMMATE_SEEKER],
+            RentalModel.MIXED: [UserRole.LANDLORD, UserRole.RENTER, UserRole.TENANT, 
+                               UserRole.AIRBNB_HOST, UserRole.AIRBNB_GUEST,
+                               UserRole.HOMEOWNER_SEEKING_ROOMMATE, UserRole.ROOMMATE_SEEKER],
+        }
+        
+        valid = valid_combinations.get(rental_model, [])
+        
+        if user_role in valid:
+            logger.info(f"✅ Role {user_role} valid for {rental_model.value}")
+            return True
+        
+        logger.warning(f"⚠️ Role {user_role} may not match {rental_model.value}")
+        return False
+
+
+class RoleBasedInferenceEngine:
+    """Adapt inference based on user role and rental model"""
+    
+    def __init__(self):
+        self.role_detector = UserRoleDetector()
+        logger.info("🧠 Role-based Inference Engine initialized")
+    
+    def infer_listing_type(self, state: Dict, user_message: str, rental_model: RentalModel = None) -> Tuple[str, float]:
+        """
+        Infer listing type based on user role and rental model
+        
+        Returns: (listing_type, confidence)
+        """
+        
+        # Detect rental model
+        if rental_model is None:
+            rental_model = self.role_detector.detect_rental_model(user_message, state.get("location"))
+        
+        # Detect user role
+        user_role, role_confidence = self.role_detector.detect_user_role(user_message, rental_model)
+        
+        logger.info(f"🔍 Rental Model: {rental_model.value}")
+        logger.info(f"👤 User Role: {user_role} (confidence: {role_confidence:.0%})")
+        
+        # Store in state for later use
+        state["rental_model"] = rental_model.value
+        state["user_role"] = user_role
+        
+        # ==================== AIRBNB MODEL ====================
+        
+        if rental_model == RentalModel.AIRBNB:
+            
+            # Host listing = short-stay
+            if user_role == UserRole.AIRBNB_HOST:
+                logger.info("📍 Host → short-stay listing")
+                return "short-stay", 0.98
+            
+            # Guest searching = just needs to search
+            if user_role == UserRole.AIRBNB_GUEST:
+                logger.info("📍 Guest → searching for short-stay")
+                return "short-stay", 0.95
+        
+        # ==================== AFRICAN RENTAL MODEL ====================
+        
+        elif rental_model == RentalModel.AFRICAN_RENTAL:
+            
+            # Landlord listing = rent listing
+            if user_role in [UserRole.LANDLORD, UserRole.OWNER]:
+                logger.info("📍 Landlord → rent listing")
+                return "rent", 0.98
+            
+            # Renter/tenant searching = rent listing
+            if user_role in [UserRole.RENTER, UserRole.TENANT]:
+                logger.info("📍 Tenant/Renter → searching for rent")
+                return "rent", 0.95
+        
+        # ==================== ROOMMATE MODEL ====================
+        
+        elif rental_model == RentalModel.ROOMMATE:
+            
+            # Homeowner seeking roommate = roommate listing
+            if user_role == UserRole.HOMEOWNER_SEEKING_ROOMMATE:
+                logger.info("📍 Homeowner → roommate listing")
+                return "roommate", 0.98
+            
+            # Roommate seeker = searching roommate
+            if user_role == UserRole.ROOMMATE_SEEKER:
+                logger.info("📍 Roommate seeker → searching for roommate")
+                return "roommate", 0.95
+        
+        # ==================== SALE MODEL (both) ====================
+        
+        if user_role == UserRole.SELLER:
+            logger.info("📍 Seller → sale listing")
+            return "sale", 0.98
+        
+        if user_role == UserRole.BUYER:
+            logger.info("📍 Buyer → searching for sale")
+            return "sale", 0.95
+        
+        # Fallback: check explicit listing_type
+        explicit_type = state.get("listing_type")
+        if explicit_type:
+            logger.info(f"📍 Using explicit listing_type: {explicit_type}")
+            return explicit_type, 0.85
+        
+        logger.warning("⚠️ Could not infer listing_type, defaulting to rent")
+        return "rent", 0.5
+    
+    def adapt_field_extraction(self, state: Dict, user_message: str) -> Dict:
+        """
+        Adapt field extraction based on user role and rental model
+        """
+        
+        rental_model = self.role_detector.detect_rental_model(user_message, state.get("location"))
+        user_role, _ = self.role_detector.detect_user_role(user_message, rental_model)
+        
+        extraction_config = {
+            "rental_model": rental_model.value,
+            "user_role": user_role,
+            "required_fields": [],
+            "price_type_suggestions": [],
+            "amenity_focus": [],
+            "validation_rules": []
+        }
+        
+        # ==================== AIRBNB HOST ====================
+        if user_role == UserRole.AIRBNB_HOST:
+            extraction_config["required_fields"] = [
+                "location", "bedrooms", "bathrooms", "price", "amenities"
+            ]
+            extraction_config["price_type_suggestions"] = ["nightly", "daily", "weekly"]
+            extraction_config["amenity_focus"] = ["wifi", "parking", "pool", "kitchen", "ac"]
+            extraction_config["validation_rules"] = [
+                "price must be per night (nightly/daily)",
+                "bedrooms minimum 1",
+                "bathrooms can be shared"
+            ]
+        
+        # ==================== AIRBNB GUEST ====================
+        elif user_role == UserRole.AIRBNB_GUEST:
+            extraction_config["required_fields"] = ["location", "check_in", "check_out"]
+            extraction_config["price_type_suggestions"] = ["nightly"]
+            extraction_config["amenity_focus"] = ["wifi", "kitchen", "parking"]
+            extraction_config["validation_rules"] = [
+                "check dates for availability",
+                "show prices in nightly rates"
+            ]
+        
+        # ==================== LANDLORD (African) ====================
+        elif user_role == UserRole.LANDLORD:
+            extraction_config["required_fields"] = [
+                "location", "bedrooms", "bathrooms", "price", "price_type", "furnished"
+            ]
+            extraction_config["price_type_suggestions"] = ["monthly", "yearly"]
+            extraction_config["amenity_focus"] = [
+                "furnished", "kitchen", "water", "electricity", "security"
+            ]
+            extraction_config["validation_rules"] = [
+                "price must be monthly or yearly",
+                "specify if furnished/unfurnished",
+                "include utility info if available",
+                "bedrooms and bathrooms required"
+            ]
+        
+        # ==================== RENTER/TENANT (African) ====================
+        elif user_role in [UserRole.RENTER, UserRole.TENANT]:
+            extraction_config["required_fields"] = [
+                "location", "budget", "bedrooms", "price_type"
+            ]
+            extraction_config["price_type_suggestions"] = ["monthly", "yearly"]
+            extraction_config["amenity_focus"] = [
+                "furnished", "security", "water", "electricity", "parking"
+            ]
+            extraction_config["validation_rules"] = [
+                "show monthly/yearly prices",
+                "filter by budget",
+                "highlight furnished options",
+                "show security features"
+            ]
+        
+        # ==================== HOMEOWNER SEEKING ROOMMATE ====================
+        elif user_role == UserRole.HOMEOWNER_SEEKING_ROOMMATE:
+            extraction_config["required_fields"] = [
+                "location", "bedrooms_available", "bathrooms_available", "price", "price_type"
+            ]
+            extraction_config["price_type_suggestions"] = ["monthly", "yearly"]
+            extraction_config["amenity_focus"] = [
+                "furnished", "utilities_included", "kitchen_access", "laundry",
+                "internet", "parking", "living_room_access"
+            ]
+            extraction_config["validation_rules"] = [
+                "price must be monthly or yearly",
+                "specify which rooms are available",
+                "describe house/apartment condition",
+                "list utilities included",
+                "mention house rules"
+            ]
+        
+        # ==================== ROOMMATE SEEKER ====================
+        elif user_role == UserRole.ROOMMATE_SEEKER:
+            extraction_config["required_fields"] = [
+                "location", "budget", "move_in_date"
+            ]
+            extraction_config["price_type_suggestions"] = ["monthly", "yearly"]
+            extraction_config["amenity_focus"] = [
+                "furnished", "utilities_included", "kitchen_access", "internet",
+                "parking", "proximity_to_work"
+            ]
+            extraction_config["validation_rules"] = [
+                "show monthly/yearly prices",
+                "filter by budget",
+                "check roommate compatibility",
+                "show lease terms"
+            ]
+        
+        # ==================== SELLER ====================
+        elif user_role == UserRole.SELLER:
+            extraction_config["required_fields"] = [
+                "location", "bedrooms", "bathrooms", "price", "property_type"
+            ]
+            extraction_config["price_type_suggestions"] = ["fixed"]
+            extraction_config["amenity_focus"] = ["land size", "property type", "condition"]
+            extraction_config["validation_rules"] = [
+                "price is total sale price",
+                "property type required (apartment, house, etc)",
+                "include land/property size if known"
+            ]
+        
+        # ==================== BUYER ====================
+        elif user_role == UserRole.BUYER:
+            extraction_config["required_fields"] = [
+                "location", "budget", "bedrooms", "property_type"
+            ]
+            extraction_config["price_type_suggestions"] = []
+            extraction_config["amenity_focus"] = ["property type", "land size", "condition"]
+            extraction_config["validation_rules"] = [
+                "show total sale prices",
+                "filter by budget range",
+                "group by property type"
+            ]
+        
+        logger.info(f"✅ Extraction config adapted for {user_role}")
+        
+        return extraction_config
+    
+    def get_role_context_prompt(self, user_role: str, rental_model: str) -> str:
+        """Get AI prompt context based on role"""
+        
+        prompts = {
+            UserRole.AIRBNB_HOST: """
+You are helping an Airbnb host list their property.
+- Focus on: short-stay rental features, nightly rates, guest amenities
+- Price type: nightly/daily/weekly
+- Emphasize: WiFi, kitchen, parking, cleanliness
+""",
+            
+            UserRole.AIRBNB_GUEST: """
+You are helping someone find an Airbnb accommodation.
+- Focus on: guest experience, amenities, location convenience
+- Price type: show nightly rates
+- Emphasize: cleanliness, safety, host responsiveness
+""",
+            
+            UserRole.LANDLORD: """
+You are helping an African landlord/property owner list a rental.
+- Focus on: long-term rental (monthly/yearly), tenant features, property durability
+- Price type: monthly or yearly
+- Emphasize: furnished/unfurnished, utilities, security, maintenance
+- Include: lease terms, deposit requirements
+""",
+            
+            UserRole.RENTER: """
+You are helping a tenant/renter find an apartment or room.
+- Focus on: long-term rental suitability, affordability, amenities for living
+- Price type: monthly or yearly budget
+- Emphasize: security, utilities included, furnished options, commute
+- Ask about: move-in date, lease length, budget
+""",
+            
+            UserRole.TENANT: """
+You are helping a tenant/renter find an apartment or room.
+- Focus on: long-term rental suitability, affordability, amenities for living
+- Price type: monthly or yearly budget
+- Emphasize: security, utilities included, furnished options, commute
+- Ask about: move-in date, lease length, budget
+""",
+            
+            UserRole.SELLER: """
+You are helping someone sell a property.
+- Focus on: property value, unique features, condition, potential
+- Price type: total sale price
+- Emphasize: location, size, renovations, investment potential
+- Include: property history, legal documents status
+""",
+            
+            UserRole.BUYER: """
+You are helping someone find and purchase a property.
+- Focus on: property value, investment potential, location
+- Price type: show total purchase price
+- Emphasize: property condition, neighborhood, future value
+- Include: financing options, inspection recommendations
+""",
+            
+            UserRole.HOMEOWNER_SEEKING_ROOMMATE: """
+You are helping someone find a roommate to share their home with.
+- Focus on: compatibility, house/apartment details, shared spaces
+- Price type: monthly or yearly
+- Emphasize: house rules, utilities included, available rooms, amenities
+- Include: lease terms, deposit, move-in date, roommate preferences
+- Ask about: their lifestyle, work schedule, cleanliness standards
+""",
+            
+            UserRole.ROOMMATE_SEEKER: """
+You are helping someone find a room to share with a roommate.
+- Focus on: affordability, roommate compatibility, location, utilities
+- Price type: monthly or yearly budget
+- Emphasize: house rules, amenities, commute, lifestyle fit
+- Include: move-in date, lease length, deposit requirements
+- Ask about: budget, preferred location, work/study location, lifestyle
+"""
+        }
+        
+        return prompts.get(user_role, "")
+
+
+# ==================== EXAMPLE USAGE ====================
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+    
+    engine = RoleBasedInferenceEngine()
+    
+    # Test cases
+    test_cases = [
+        # Airbnb host
+        ("I'm a host on Airbnb and want to list my apartment in Lagos", "Lagos"),
+        
+        # Airbnb guest
+        ("I'm looking for accommodation on Airbnb in Accra next week", "Accra"),
+        
+        # African landlord
+        ("I'm a landlord in Cotonou with a 2-bedroom apartment for monthly rent", "Cotonou"),
+        
+        # African tenant
+        ("I'm looking to rent a furnished room in Nairobi, my budget is 30000 KES per month", "Nairobi"),
+        
+        # Homeowner seeking roommate
+        ("My house in Lagos is too big for just me. I have 2 extra bedrooms and want to share", "Lagos"),
+        
+        # Roommate seeker
+        ("I'm looking for a room to share in Accra, somewhere near my workplace", "Accra"),
+        
+        # Seller
+        ("I want to sell my house in Lagos for 50 million NGN", "Lagos"),
+        
+        # Buyer
+        ("I'm looking to buy a 3-bedroom apartment in Cape Town", "Cape Town"),
+    ]
+    
+    print("\n" + "="*70)
+    print("🧠 ROLE-BASED INFERENCE ENGINE TEST")
+    print("="*70 + "\n")
+    
+    for message, location in test_cases:
+        print(f"📝 Message: {message}")
+        print(f"📍 Location: {location}\n")
+        
+        state = {"location": location}
+        listing_type, confidence = engine.infer_listing_type(state, message)
+        
+        print(f"✅ Listing Type: {listing_type} (confidence: {confidence:.0%})")
+        
+        config = engine.adapt_field_extraction(state, message)
+        print(f"📋 Required fields: {', '.join(config['required_fields'])}")
+        print(f"💰 Price types: {', '.join(config['price_type_suggestions'])}")
+        
+        prompt = engine.get_role_context_prompt(config['user_role'], config['rental_model'])
+        print(f"🎯 AI Context:\n{prompt}")
+        
+        print("-" * 70 + "\n")

app/ml/trainning/__init__.py

@@ -0,0 +1 @@
+"""ML training module"""

app/ml/trainning/hf_dataset_downloader.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+hf_dataset_downloader.py  –  bullet-proof, real-tabular real-estate data
+Run:  python scripts/download_training_data.py
+"""
+
+import os, json, logging, pandas as pd, numpy as np
+from typing import List, Tuple, Optional
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(message)s")
+log = logging.getLogger(__name__)
+
+CACHE = "./hf_datasets"
+OUT = "app/ml/models"
+
+# ------------------------------------------------ one working source ---
+SOURCES: List[Tuple[str, str, str]] = [
+    ("california_housing", "csv", "https://raw.githubusercontent.com/ageron/handson-ml2/master/datasets/housing/housing.csv"),
+]
+
+COL_MAP = {
+    "price":     ["price", "median_house_value", "sale_price", "cost"],
+    "bedrooms":  ["bedrooms", "total_bedrooms", "beds"],
+    "bathrooms": ["bathrooms", "total_bathrooms", "baths"],
+    "location":  ["location", "ocean_proximity", "city", "address", "region"],
+}
+
+# -----------------------------------------------------------------------
+class HuggingFaceDatasetDownloader:
+    def __init__(self, cache_dir: str = CACHE, output_dir: str = OUT):
+        self.cache_dir  = cache_dir
+        self.output_dir = output_dir
+        os.makedirs(cache_dir, exist_ok=True)
+        os.makedirs(output_dir, exist_ok=True)
+
+    # ------------ fetch -------------------------------------------------
+    def _get_csv(self, url: str) -> Optional[pd.DataFrame]:
+        try:
+            df = pd.read_csv(url)
+            log.info("CSV rows=%d  url=%.60s", len(df), url)
+            return df
+        except Exception as e:
+            log.error("CSV fail: %s", e)
+            return None
+
+    # ------------ normalise ---------------------------------------------
+    def _normalise(self, df: pd.DataFrame, name: str) -> Optional[pd.DataFrame]:
+        log.info("Normalising %s …", name)
+        print(f"\n=== {name}  COLUMNS ===\n{list(df.columns)}\n{df.head(2)}")
+
+        out = pd.DataFrame()
+        for std, variants in COL_MAP.items():
+            for v in variants:
+                if v in df.columns:
+                    out[std] = df[v]
+                    log.info("  mapped %s → %s", v, std)
+                    break
+
+        # price is mandatory
+        if out.get("price") is None:
+            log.warning("No price column in %s", name)
+            return None
+        out["price"] = pd.to_numeric(out["price"], errors="coerce").dropna()
+        if out["price"].empty:
+            log.warning("Price column empty after coerce")
+            return None
+
+        # safe fall-backs (Series, not scalars)
+        if "location" not in out.columns:
+            out["location"] = "Unknown"
+        out["location"] = out["location"].fillna("Unknown")
+
+        # bedrooms / bathrooms – create Series first, then fillna
+        bedrooms_series  = pd.to_numeric(out.get("bedrooms", 2),  errors="coerce")
+        bathrooms_series = pd.to_numeric(out.get("bathrooms", 1), errors="coerce")
+
+        out["bedrooms"]  = bedrooms_series.fillna(2).astype(int)
+        out["bathrooms"] = bathrooms_series.fillna(1).astype(int)
+
+        out["dataset_source"] = name
+        out = out.dropna(subset=["price"])
+        log.info("Normalised → %d rows", len(out))
+        return out
+
+    # ------------ combine ----------------------------------------------
+    def _combine(self, frames: List[Tuple[str, pd.DataFrame]]) -> pd.DataFrame:
+        cleaned = [self._normalise(df, name) for name, df in frames if df is not None]
+        cleaned = [c for c in cleaned if c is not None and len(c)]
+        if not cleaned:
+            log.warning("No valid frames – creating minimal dummy so training can run")
+            dummy = pd.DataFrame({
+                "price": [250_000, 350_000, 450_000],
+                "bedrooms": [2, 3, 4],
+                "bathrooms": [1, 2, 3],
+                "location": ["Unknown", "Unknown", "Unknown"],
+                "dataset_source": ["dummy"] * 3,
+            })
+            return dummy
+        final = pd.concat(cleaned, ignore_index=True)
+        log.info("Combined → %d rows", len(final))
+        return final
+
+    # ------------ augment ----------------------------------------------
+    def _augment(self, df: pd.DataFrame) -> pd.DataFrame:
+        log.info("Augmenting …")
+        df["price_per_bedroom"]  = df["price"] / df["bedrooms"].clip(1)
+        df["price_per_bathroom"] = df["price"] / df["bathrooms"].clip(1)
+        df["total_rooms"]        = df["bedrooms"] + df["bathrooms"]
+        df["price_range"] = pd.cut(
+            df["price"],
+            bins=[0, 200_000, 500_000, 1_000_000, np.inf],
+            labels=["low", "mid", "high", "luxury"],
+        )
+        return df
+
+    # ------------ save --------------------------------------------------
+    def _save(self, df: pd.DataFrame, basename: str = "combined_training_data"):
+        csv  = f"{self.output_dir}/{basename}.csv"
+        parq = f"{self.output_dir}/{basename}.parquet"
+        jsnl = f"{self.output_dir}/{basename}.jsonl"
+
+        df.to_csv(csv, index=False)
+        df.to_parquet(parq, index=False)
+        with open(jsnl, "w", encoding="utf-8") as f:
+            for rec in df.to_dict(orient="records"):
+                f.write(json.dumps(rec, default=str) + "\n")
+
+        log.info("Saved CSV  : %s", csv)
+        log.info("Saved Parq : %s", parq)
+        log.info("Saved JSONL: %s", jsnl)
+        return {"csv": csv, "parquet": parq, "jsonl": jsnl}
+
+    # ------------ stats -------------------------------------------------
+    def _save_info(self, df: pd.DataFrame):
+        info = {
+            "rows": len(df),
+            "cols": list(df.columns),
+            "price": {"mean": float(df["price"].mean()), "median": float(df["price"].median()),
+                      "min": float(df["price"].min()), "max": float(df["price"].max())},
+            "bedrooms":  {"mean": float(df["bedrooms"].mean()),  "min": int(df["bedrooms"].min()),  "max": int(df["bedrooms"].max())},
+            "bathrooms": {"mean": float(df["bathrooms"].mean()), "min": int(df["bathrooms"].min()), "max": int(df["bathrooms"].max())},
+            "locations": df["location"].nunique(),
+        }
+        path = f"{self.output_dir}/dataset_info.json"
+        with open(path, "w") as f:
+            json.dump(info, f, indent=2)
+        log.info("Stats → %s", path)
+
+    # ------------ main --------------------------------------------------
+    def download_and_prepare(self) -> pd.DataFrame:
+        print("\n" + "=" * 80)
+        print("REAL-ESTATE TABULAR DOWNLOADER  (BULLET-PROOF)")
+        print("=" * 80 + "\n")
+
+        raw: List[Tuple[str, pd.DataFrame]] = []
+        for name, typ, src in SOURCES:
+            log.info("Getting %s …", name)
+            if typ == "csv":
+                raw.append((name, self._get_csv(src)))
+            else:
+                log.warning("Unknown type %s", typ)
+
+        raw = [(n, d) for n, d in raw if d is not None]
+        combined = self._combine(raw)
+        combined = self._augment(combined)
+        paths = self._save(combined)
+        self._save_info(combined)
+
+        print("\n" + "=" * 80)
+        print("DOWNLOAD COMPLETE")
+        print("=" * 80)
+        print(f"Rows : {len(combined):,}")
+        print(f"Files: {paths}")
+        print("\nNext → python scripts/train_models.py\n")
+        return combined
+
+
+if __name__ == "__main__":
+    HuggingFaceDatasetDownloader().download_and_prepare()

app/ml/trainning/train_enhanced_model.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+train_enhanced_model.py  –  train on real tabular data
+Run:  python scripts/train_models.py
+"""
+
+import json, os, joblib, logging, pandas as pd, numpy as np
+from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import r2_score, mean_absolute_error, accuracy_score
+from sentence_transformers import SentenceTransformer
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(message)s")
+log = logging.getLogger(__name__)
+
+MODEL_DIR = "app/ml/models"
+DATA_FILE = f"{MODEL_DIR}/combined_training_data.parquet"
+MODEL_PATH = f"{MODEL_DIR}/field_models.pkl"
+
+class EnhancedModelTrainer:
+    def __init__(self, model_dir: str = MODEL_DIR, data_file: str = DATA_FILE):
+        self.model_dir = model_dir
+        self.data_file = data_file
+        os.makedirs(model_dir, exist_ok=True)
+
+    # ------------ load ----------------------------------------------
+    def _load(self) -> pd.DataFrame | None:
+        if not os.path.exists(self.data_file):
+            log.error("Data not found → run download_training_data.py first")
+            return None
+        df = pd.read_parquet(self.data_file)
+        log.info("Loaded %d rows", len(df))
+        return df
+
+    # ------------ prep ----------------------------------------------
+    def _prep(self, df: pd.DataFrame):
+        log.info("Preparing features …")
+        X_num = df[["bedrooms", "bathrooms", "price_per_bedroom", "total_rooms"]].fillna(0)
+        self.scaler = StandardScaler().fit(X_num)
+
+        # embeddings from location string
+        self.embedder = SentenceTransformer("all-MiniLM-L6-v2", cache_folder="./models")
+        X_text = self.embedder.encode(df["location"].astype(str).tolist())
+
+        X = np.hstack([self.scaler.transform(X_num), X_text])
+        y_price = df["price"].values
+        y_loc   = LabelEncoder().fit_transform(df["location"])
+        return X, y_price, y_loc
+
+    # ------------ train ---------------------------------------------
+    def _train(self, X, y_price, y_loc, df: pd.DataFrame):
+        log.info("Training models …")
+        X_train, X_test, yp_train, yp_test, yl_train, yl_test = train_test_split(
+            X, y_price, y_loc, test_size=0.2, random_state=42
+        )
+
+        # 1. price regressor
+        price_model = RandomForestRegressor(
+            n_estimators=300, max_depth=20, random_state=42, n_jobs=-1
+        )
+        price_model.fit(X_train, yp_train)
+        y_pred = price_model.predict(X_test)
+        log.info("Price R² = %.3f   MAE = $%.0f", r2_score(yp_test, y_pred), mean_absolute_error(yp_test, y_pred))
+
+        # 2. location classifier
+        loc_model = RandomForestClassifier(
+            n_estimators=300, max_depth=None, random_state=42, n_jobs=-1
+        )
+        loc_model.fit(X_train, yl_train)
+        log.info("Location accuracy = %.2f%%", 100 * accuracy_score(yl_test, loc_model.predict(X_test)))
+
+        # 3. price patterns
+        patterns = (
+            df.groupby("location")["price"]
+            .agg(["mean", "median", "std", "min", "max", "count"])
+            .round(0)
+            .to_dict(orient="index")
+        )
+
+        location_encoder = LabelEncoder().fit(df["location"])
+        return {
+            "price_model": price_model,
+            "location_model": loc_model,
+            "location_encoder": location_encoder,
+            "price_patterns": patterns,
+            "scaler": self.scaler,
+            "embedder": self.embedder,
+        }
+
+    # ------------ save ----------------------------------------------
+    def _save(self, bundle):
+        joblib.dump(bundle, MODEL_PATH)
+        log.info("Saved model bundle → %s", MODEL_PATH)
+
+    # ------------ report --------------------------------------------
+    def _report(self, df: pd.DataFrame):
+        print("\n📊  TRAINING REPORT")
+        print(f"Rows trained : {len(df):,}")
+        print(f"Locations    : {df['location'].nunique()}")
+        print(f"Avg price    : ${df['price'].mean():,.0f}")
+        print(f"Price range  : ${df['price'].min():,.0f} – ${df['price'].max():,.0f}")
+        print(f"Models saved : {MODEL_PATH}\n")
+
+    # ------------ pipeline ------------------------------------------
+    def train(self):
+        print("\n" + "=" * 70)
+        print("🚀  ENHANCED MODEL TRAINING (REAL DATA)")
+        print("=" * 70 + "\n")
+
+        df = self._load()
+        if df is None:
+            return
+        X, y_price, y_loc = self._prep(df)
+        bundle = self._train(X, y_price, y_loc, df)
+        self._save(bundle)
+        self._report(df)
+
+        print("✅  Training complete – run test_ml_model.py to verify\n")
+
+
+if __name__ == "__main__":
+    EnhancedModelTrainer().train()

models/models--sentence-transformers--all-MiniLM-L6-v2/blobs/53aa51172d142c89d9012cce15ae4d6cc0ca6895895114379cacb4fab128d9db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53aa51172d142c89d9012cce15ae4d6cc0ca6895895114379cacb4fab128d9db
+size 90868376

models/models--sentence-transformers--all-MiniLM-L6-v2/blobs/58d4a9a45664eb9e12de9549c548c09b6134c17f

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7dfc82496ec33f906b5b0d6750c1e2397da6530c74d1ae3568c55bc2739125e7
+size 10454

models/models--sentence-transformers--all-MiniLM-L6-v2/blobs/59d594003bf59880a884c574bf88ef7555bb0202

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fc1993fde0a95c24ec6c022539d41cf6e2f7c9721e5415d6fb6897472a9cd4b7
+size 53

models/models--sentence-transformers--all-MiniLM-L6-v2/blobs/72b987fd805cfa2b58c4c8c952b274a11bfd5a00

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:953f9c0d463486b10a6871cc2fd59f223b2c70184f49815e7efbcab5d8908b41
+size 612

models/models--sentence-transformers--all-MiniLM-L6-v2/blobs/952a9b81c0bfd99800fabf352f69c7ccd46c5e43

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84e40c8e006c9b1d6c122e02cba9b02458120b5fb0c87b746c41e0207cf642cf
+size 349

models/models--sentence-transformers--all-MiniLM-L6-v2/blobs/c79f2b6a0cea6f4b564fed1938984bace9d30ff0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acb92769e8195aabd29b7b2137a9e6d6e25c476a4f15aa4355c233426c61576b
+size 350

models/models--sentence-transformers--all-MiniLM-L6-v2/blobs/cb202bfe2e3c98645018a6d12f182a434c9d3e02

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be50c3628f2bf5bb5e3a7f17b1f74611b2561a3a27eeab05e5aa30f411572037
+size 466247

models/models--sentence-transformers--all-MiniLM-L6-v2/blobs/d1514c3162bbe87b343f565fadc62e6c06f04f03

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4be450dde3b0273bb9787637cfbd28fe04a7ba6ab9d36ac48e92b11e350ffc23
+size 190

models/models--sentence-transformers--all-MiniLM-L6-v2/blobs/e7b0375001f109a6b8873d756ad4f7bbb15fbaa5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:303df45a03609e4ead04bc3dc1536d0ab19b5358db685b6f3da123d05ec200e3
+size 112

models/models--sentence-transformers--all-MiniLM-L6-v2/blobs/fb140275c155a9c7c5a3b3e0e77a9e839594a938

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07eced375cec144d27c900241f3e339478dec958f92fddbc551f295c992038a3
+size 231508

models/models--sentence-transformers--all-MiniLM-L6-v2/blobs/fd1b291129c607e5d49799f87cb219b27f98acdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:061ca9d39661d6c6d6de5ba27f79a1cd5770ea247f8d46412a68a498dc5ac9f3
+size 116

models/models--sentence-transformers--all-MiniLM-L6-v2/refs/main

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:edb692c300dcf5dd2a56116221d7613e9d360b6f0be22bc3e02e040e095b135b
+size 40

models/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/1_Pooling/config.json

@@ -0,0 +1 @@
+../../../blobs/d1514c3162bbe87b343f565fadc62e6c06f04f03

models/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/README.md

@@ -0,0 +1 @@
+../../blobs/58d4a9a45664eb9e12de9549c548c09b6134c17f

models/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/config.json

@@ -0,0 +1 @@
+../../blobs/72b987fd805cfa2b58c4c8c952b274a11bfd5a00

models/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/config_sentence_transformers.json

@@ -0,0 +1 @@
+../../blobs/fd1b291129c607e5d49799f87cb219b27f98acdf

models/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/model.safetensors

@@ -0,0 +1 @@
+../../blobs/53aa51172d142c89d9012cce15ae4d6cc0ca6895895114379cacb4fab128d9db

models/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/modules.json

@@ -0,0 +1 @@
+../../blobs/952a9b81c0bfd99800fabf352f69c7ccd46c5e43

models/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/sentence_bert_config.json

@@ -0,0 +1 @@
+../../blobs/59d594003bf59880a884c574bf88ef7555bb0202

models/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/special_tokens_map.json

@@ -0,0 +1 @@
+../../blobs/e7b0375001f109a6b8873d756ad4f7bbb15fbaa5

models/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/tokenizer.json

@@ -0,0 +1 @@
+../../blobs/cb202bfe2e3c98645018a6d12f182a434c9d3e02

models/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/tokenizer_config.json

@@ -0,0 +1 @@
+../../blobs/c79f2b6a0cea6f4b564fed1938984bace9d30ff0

models/models--sentence-transformers--all-MiniLM-L6-v2/snapshots/c9745ed1d9f207416be6d2e6f8de32d1f16199bf/vocab.txt

@@ -0,0 +1 @@
+../../blobs/fb140275c155a9c7c5a3b3e0e77a9e839594a938

scripts/download_training_data.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+import sys, os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from app.ml.trainning.hf_dataset_downloader import HuggingFaceDatasetDownloader
+HuggingFaceDatasetDownloader().download_and_prepare()

scripts/train_models.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+import sys, os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from app.ml.trainning.train_enhanced_model import EnhancedModelTrainer
+EnhancedModelTrainer().train()