fyp

app/ai/agent/brain.py

@@ -1099,23 +1099,10 @@ async def _execute_tool_impl(tool_name: str, params: Dict[str, Any], state: Agen
         if tool_name == "update_listing":
             # Update listing fields
             fields = params.get("fields", {})
-
-            # ── Fix: coerce list fields and strip unknown fields ─────────────
-            # LLM sometimes:
-            #   • passes list fields (requirements, amenities) as plain strings
-            #   • adds unknown fields (price_negotiable, floor_level, etc.)
-            # Coerce/strip silently so validation never fails on these.
-            from app.ai.agent.validators import ToolCallValidator as _TCV
-            _allowed_keys = set(_TCV._LISTING_FIELD_TYPES.keys())
-            for _key in list(fields.keys()):
-                if _key not in _allowed_keys:
-                    logger.warning("Stripping unknown listing field", field=_key, value=fields[_key])
-                    del fields[_key]
-            for _list_field in ("requirements", "amenities", "images"):
-                _val = fields.get(_list_field)
-                if isinstance(_val, str) and _val.strip():
-                    fields[_list_field] = [v.strip() for v in _val.split(",") if v.strip()]
-            # ─────────────────────────────────────────────────────────────────
+            # NOTE: field coercion (unknown-key strip + list coercion) was already
+            # done in execute_tool's pre-validation block before we got here.
+            # No need to repeat it — doing so would just log spurious "Stripping"
+            # warnings on fields that were already cleaned.
 
             # Merge vision-extracted fields (from image analysis)
             # These come from POST /image-upload-result with vision_fields
@@ -1536,9 +1523,12 @@ async def _execute_tool_impl(tool_name: str, params: Dict[str, Any], state: Agen
                 except Exception as e:
                     logger.warning("Failed to generate title/description", error=str(e))
             
-            # Draft card only appears once the user has uploaded images.
-            # Images are the trigger — not text completeness.
-            if has_images:
+            # Draft card only appears once images AND generated title/description exist.
+            # Showing the card with empty title/description confuses users — they see
+            # a blank property card and can't tell if the listing is set up correctly.
+            # Title+description are auto-generated above when has_images+has_core_data,
+            # so this guard simply defers the card until that generation has run.
+            if has_images and state.listing_draft.get("title") and state.listing_draft.get("description"):
                 from app.ai.agent.nodes.listing_validate import build_draft_ui_from_dict
                 draft_ui = build_draft_ui_from_dict(state.listing_draft)
                 draft_ui["status"] = "draft"
@@ -2895,7 +2885,7 @@ Instructions:
 
                 rows, web_results = await _asyncio.gather(
                     cursor.to_list(length=15),
-                    search_real_estate_prices(loc_label),
+                    search_real_estate_prices(loc_label, lang_code=lang_code),
                     return_exceptions=True,
                 )
 
@@ -2944,11 +2934,22 @@ Instructions:
 
                 # ── Format web data ───────────────────────────────────────────
                 web_section = ""
+                web_sources_for_ui = []   # passed to Flutter as structured attribution
                 if web_results:
-                    snippets = "\n".join(
-                        f"- {r['title']}: {r['snippet']}" for r in web_results
+                    lines = []
+                    for r in web_results:
+                        source = r.get("source") or r.get("link", "")
+                        lines.append(f"- [{source}] {r['title']}: {r['snippet']}")
+                        if r.get("link"):
+                            web_sources_for_ui.append({
+                                "title":  r["title"],
+                                "source": source,
+                                "url":    r["link"],
+                            })
+                    web_section = (
+                        "WEB SEARCH DATA (Google results via Serper):\n"
+                        + "\n".join(lines)
                     )
-                    web_section = f"WEB SEARCH DATA (internet sources):\n{snippets}"
 
                 # ── Build combined narration prompt ───────────────────────────
                 language_names = {
@@ -3021,6 +3022,30 @@ Instructions:
                 )
                 state.temp_data["response_text"] = price_response
                 state.temp_data["action"] = "get_price_trends"
+
+                # ── Structured market payload for Flutter UI card ─────────────
+                # Flutter reads state.temp_data["market_data"] and can render
+                # a proper card with price segments + source chips instead of
+                # just displaying the text blob.
+                segments = []
+                for row in (rows or []):
+                    segments.append({
+                        "location":     row["_id"].get("location", loc_label),
+                        "listing_type": row["_id"].get("listing_type", "property"),
+                        "currency":     row.get("currency") or "XOF",
+                        "low":          round(row.get("min_price") or 0),
+                        "avg":          round(row.get("avg_price") or 0),
+                        "high":         round(row.get("max_price") or 0),
+                        "count":        row.get("count", 0),
+                    })
+                state.temp_data["market_data"] = {
+                    "location":    loc_label,
+                    "segments":    segments,
+                    "web_sources": web_sources_for_ui,
+                    "has_lojiz":   has_lojiz,
+                    "has_web":     has_web,
+                }
+
                 await log_reward(state.session_id, REWARD_MARKET_INSIGHT, "price_trends", {"location": location})
                 return True, "Price trends generated", rows or web_results
 
@@ -3755,6 +3780,24 @@ async def agent_think(state: AgentState) -> AgentState:
         or decision.tool in _DATA_TOOLS
     ):
         pass
+    # ── "Lost in thought" fix ────────────────────────────────────────────────
+    # update_listing is NEVER a terminal action in the listing flow — after a
+    # field is saved there is always something to say next (next missing field,
+    # or a final "you're good to publish" message).
+    #
+    # Problem: DeepSeek often returns is_final=True for update_listing calls
+    # and includes a brief inline response like "Got it, noted ✅". When
+    # decision.response is used directly, the user sees a confirmation with no
+    # follow-up question and the conversation silently stalls — they have to
+    # send another message to "wake" AIDA up.
+    #
+    # Fix: when update_listing ran and no draft UI was produced yet (i.e. we're
+    # still mid-collection), ALWAYS route through generate_contextual_response
+    # which knows to ask the next missing field. Only skip this when a full
+    # draft card is already present (that path sets its own response_text above).
+    elif decision.tool == "update_listing" and not state.temp_data.get("draft_ui"):
+        state.temp_data["response_text"] = await generate_contextual_response(state, decision)
+    # ────────────────────────────────────────────────────────────────────────
     elif decision.response:
         state.temp_data["response_text"] = decision.response
     else:

app/ai/agent/schemas.py

@@ -177,6 +177,7 @@ class AgentResponse(BaseModel):
     alert_results: Optional[List[Dict[str, Any]]] = None  # For user's search alerts
     alert_title: Optional[str] = None  # Title for alert results display
     comparison_data: Optional[List[Dict[str, Any]]] = None  # Smart concierge property comparison
+    market_data: Optional[Dict[str, Any]] = None  # Structured market analysis payload for Flutter card
     tool_result: Optional[ToolResult] = None
     error: Optional[str] = None
     # Intelligent reply context

app/ai/prompts/system_prompt.py

@@ -97,12 +97,48 @@ NO MIXING LANGUAGES - respond entirely in user's language
 
 LANGUAGE SIGNAL (MANDATORY):
 Every time you write a response or call a tool, start your text with [LANG:xx] where xx is
-the ISO 639-1 code of the language the user is speaking (en, fr, es, ar, pt, etc.).
+the ISO 639-1 code of the language the user is WRITING IN right now (en, fr, es, ar, pt, etc.).
 Examples: "[LANG:fr] Je vais publier votre annonce..." | "[LANG:ar] سأنشر إعلانك..."
 This tag is stripped before display — the user never sees it. It is required for correct
 language routing of success/error messages. Even for single-word inputs like "publier" or
 "publicar", you can tell the language — always output the tag.
 
+========== CONVERSATION LANGUAGE vs LISTING CONTENT LANGUAGE ==========
+These are TWO COMPLETELY SEPARATE things. Never confuse them.
+
+1. CONVERSATION LANGUAGE — the language you and the user are TALKING in right now.
+   - Determined by the language the USER IS WRITING IN, not what they're asking for.
+   - Your replies to the user are ALWAYS in this language.
+   - [LANG:xx] tag always reflects this language.
+   - It NEVER changes just because the user wants their listing in a different language.
+
+2. LISTING CONTENT LANGUAGE — the language of the listing title, description, and amenities.
+   - Only changes when the user explicitly says "put the listing in X" / "generate in X"
+     / "mets l'annonce en anglais" / "haz el anuncio en español", etc.
+   - You set this via requested_language param in update_listing.
+   - Has ZERO effect on your conversational replies.
+
+MANDATORY EXAMPLES — you MUST follow this pattern exactly:
+
+  Scenario A: User writes in French, asks to generate listing in Portuguese
+    User: "génère le listing en portugais"
+    → call update_listing with requested_language="pt", regen_draft=true
+    → your reply: [LANG:fr] "Parfait ! Je régénère votre annonce en portugais. ✅"
+    → [LANG:fr] because the USER IS WRITING IN FRENCH — that never changed.
+
+  Scenario B: User writes in French, asks to generate listing in English
+    User: "mets l'annonce en anglais"
+    → call update_listing with requested_language="en", regen_draft=true
+    → your reply: [LANG:fr] "D'accord ! J'ai régénéré l'annonce en anglais."
+
+  Scenario C: User switches from French to English mid-conversation
+    User: "ok make the listing in spanish please"
+    → The user is now writing in ENGLISH → [LANG:en]
+    → call update_listing with requested_language="es"
+    → your reply: [LANG:en] "Done! I've set your listing to Spanish."
+
+RULE: [LANG:xx] = the language the user just typed in. requested_language = the listing content language. They can be different.
+
 ========== YOUR PRIMARY ROLE ==========
 Your role: {role_upper}
 

app/ai/routes/translate.py

@@ -1,5 +1,5 @@
 # app/ai/routes/translate.py
-import logging
+import structlog
 from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel, Field
 from typing import Dict, Any
@@ -7,7 +7,7 @@ from typing import Dict, Any
 from app.ai.services.translation_service import translate_listing
 
 router = APIRouter(prefix="/translate", tags=["AIDA Translate"])
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger(__name__)
 
 class TranslateListingRequest(BaseModel):
     listing_data: Dict[str, Any]

app/ai/services/agent_executor.py

@@ -19,17 +19,18 @@ Usage:
 import asyncio
 import json
 import hashlib
-import logging
 import re
 from uuid import uuid4
 from typing import Optional, Dict, Any, List
 from dataclasses import dataclass
 
+import structlog
+
 from app.ai.agent.graph import get_aida_graph
 from app.ai.agent.schemas import AgentResponse
 from app.ai.config import redis_client
 
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger(__name__)
 
 # Concurrency Control: Max 5 concurrent AI requests
 _ai_semaphore = asyncio.Semaphore(5)
@@ -384,7 +385,16 @@ class AgentExecutor:
         """Build AgentResponse from an AgentState object (not a dict)."""
         temp_data = state.temp_data or {}
 
-        response_text = temp_data.get("response_text") or "I'm here to help! What would you like to do?"
+        raw_response_text = temp_data.get("response_text")
+        if not raw_response_text:
+            logger.warning(
+                "Brain returned no response_text — using generic fallback",
+                user_id=input.user_id,
+                session_id=input.session_id,
+                flow=str(getattr(state, "current_flow", None)),
+                action=temp_data.get("action"),
+            )
+        response_text = raw_response_text or "I'm here to help! What would you like to do?"
 
         current_flow = state.current_flow
         flow_str = current_flow.value if hasattr(current_flow, "value") else str(current_flow)
@@ -420,6 +430,7 @@ class AgentExecutor:
             draft_ui=temp_data.get("draft_ui"),
             search_results=temp_data.get("search_results"),
             my_listings=temp_data.get("my_listings"),
+            market_data=temp_data.get("market_data"),
             error=state.last_error,
             reply_to_id=reply_to_id,
             replied_to_content=reply_to_context["content"] if reply_to_context else None,
@@ -489,6 +500,7 @@ class AgentExecutor:
             draft_ui=temp_data.get("draft_ui"),
             search_results=temp_data.get("search_results"),
             my_listings=temp_data.get("my_listings"),
+            market_data=temp_data.get("market_data"),
             error=state.get("last_error"),
             reply_to_id=reply_to_id,
             replied_to_content=reply_to_context["content"] if reply_to_context else None,

app/ai/services/search_extractor.py

@@ -4,12 +4,12 @@ Search Parameter Extractor - Shared service for extracting search criteria from
 Used by both the REST API and the AI Agent.
 """
 
-import logging
+import structlog
 from datetime import date
 from app.core.mimo_client import get_mimo_client
 from app.ai.agent.validators import JSONValidator
 
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger(__name__)
 
 _mimo = get_mimo_client()
 

app/ai/services/search_intent_classifier.py

@@ -5,12 +5,12 @@ Search Intent Classifier - Detects if user input is a property search query or c
 This prevents the search endpoint from trying to search for greetings, thank yous, or general questions.
 """
 
-import logging
+import structlog
 from typing import Dict
 from app.core.mimo_client import get_mimo_client
 from app.ai.agent.validators import JSONValidator
 
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger(__name__)
 
 _mimo = get_mimo_client()
 

app/ai/services/search_responder.py

@@ -4,11 +4,11 @@ Search Responder - Shared service for generating natural, multilingual, and enth
 Used by both the REST API and the AI Agent.
 """
 
-import logging
+import structlog
 import random
 from app.core.mimo_client import get_mimo_client
 
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger(__name__)
 
 _mimo = get_mimo_client()
 

app/ai/services/search_strategy_selector.py

@@ -16,13 +16,13 @@ RLM Strategies (Recursive Language Model):
 - RLM_MULTI_FACTOR: "best family apartment" - multi-criteria ranking
 """
 
-import logging
+import structlog
 from typing import Dict, Literal
 from enum import Enum
 from app.core.mimo_client import get_mimo_client
 from app.ai.agent.validators import JSONValidator
 
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger(__name__)
 
 
 class SearchStrategy(str, Enum):

app/ai/services/translation_service.py

@@ -1,10 +1,10 @@
 # app/ai/services/translation_service.py
-import logging
+import structlog
 import json
 from typing import Dict, Any, List
 from app.core.mimo_client import get_mimo_client
 
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger(__name__)
 
 _mimo = get_mimo_client()
 

app/ai/services/vision_service.py

@@ -18,7 +18,7 @@ import io
 import os
 import tempfile
 import uuid
-import logging
+import structlog
 from datetime import datetime
 from typing import Dict, Any, List, Optional, Tuple
 
@@ -31,7 +31,7 @@ from botocore.config import Config
 from app.config import settings
 from app.core.mimo_client import get_mimo_client
 
-logger = logging.getLogger(__name__)
+logger = structlog.get_logger(__name__)
 
 # ============================================================
 # CONSTANTS

app/ai/tools/web_search_tool.py

@@ -1,86 +1,158 @@
 """
-Lightweight async web search via DuckDuckGo HTML endpoint.
-No API key required. Returns title + snippet for each result.
+Web search via Serper API (Google Search for LLM agents).
+Replaces the old DuckDuckGo HTML scraper which was fragile and often
+returned empty results because DDG blocks scrapers.
+
+Setup:
+  - Sign up at https://serper.dev (free tier: 2 500 searches/month)
+  - Set SERPER_API_KEY in your .env file
+
+The public interface is unchanged so brain.py needs no edits:
+  - web_search(query, max_results)  → list[dict]
+  - search_real_estate_prices(location, lang_code) → list[dict]
+
+Each result dict now carries: title, snippet, link, source
+(link + source are new — brain.py ignores unknown keys, so no breakage)
 """
-import re
-import httpx
+import asyncio
+import os
+from typing import Optional
 
-_HEADERS = {
-    "User-Agent": (
-        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
-        "AppleWebKit/537.36 (KHTML, like Gecko) "
-        "Chrome/124.0.0.0 Safari/537.36"
-    ),
-    "Accept-Language": "en-US,en;q=0.9",
-    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-}
+import httpx
+from structlog import get_logger
 
-_TAG_RE = re.compile(r"<[^>]+>")
-_WS_RE  = re.compile(r"\s+")
-_ENT_RE = re.compile(r"&[a-z]+;|&#\d+;")
+logger = get_logger(__name__)
 
-# DuckDuckGo HTML wraps each result in <div class="result results_links...">
-# Title link: <a class="result__a" href="...">text</a>
-# Snippet:    <a class="result__snippet">text</a>
-_TITLE_RE   = re.compile(r'class="result__a"[^>]*href="([^"]*)"[^>]*>(.*?)</a>', re.DOTALL)
-_SNIPPET_RE = re.compile(r'class="result__snippet"[^>]*>(.*?)</a>', re.DOTALL)
-_BLOCK_RE   = re.compile(r'<div[^>]+class="[^"]*result[^"]*"[^>]*>(.*?)</div>\s*</div>', re.DOTALL)
+_SERPER_ENDPOINT = "https://google.serper.dev/search"
+_TIMEOUT = 10.0
 
 
-def _clean(html: str) -> str:
-    text = _TAG_RE.sub("", html)
-    text = _ENT_RE.sub(" ", text)
-    return _WS_RE.sub(" ", text).strip()
+def _api_key() -> Optional[str]:
+    return os.getenv("SERPER_API_KEY", "")
 
 
 async def web_search(query: str, max_results: int = 6) -> list[dict]:
     """
-    Search DuckDuckGo and return up to `max_results` dicts with title + snippet.
-    Returns [] on any failure.
+    Search Google via Serper and return up to ``max_results`` dicts.
+    Each dict: {title, snippet, link, source}
+    Returns [] on any failure (caller treats empty as no web data).
     """
+    key = _api_key()
+    if not key:
+        logger.warning("SERPER_API_KEY not set — web search disabled")
+        return []
+
     try:
-        async with httpx.AsyncClient(
-            headers=_HEADERS, follow_redirects=True, timeout=14.0
-        ) as client:
+        async with httpx.AsyncClient(timeout=_TIMEOUT) as client:
             resp = await client.post(
-                "https://html.duckduckgo.com/html/",
-                data={"q": query, "kl": "us-en"},
+                _SERPER_ENDPOINT,
+                headers={
+                    "X-API-KEY": key,
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "q": query,
+                    "num": max_results,
+                    "gl": "us",   # geolocation — Serper returns global results regardless
+                    "hl": "en",
+                },
             )
             resp.raise_for_status()
-            html = resp.text
+            data = resp.json()
 
+        organic = data.get("organic") or []
         results = []
+        for item in organic[:max_results]:
+            title   = (item.get("title")   or "").strip()
+            snippet = (item.get("snippet") or "").strip()
+            link    = (item.get("link")    or "").strip()
+            source  = (item.get("source")  or _domain(link)).strip()
+            if title and snippet:
+                results.append({
+                    "title":   title,
+                    "snippet": snippet,
+                    "link":    link,
+                    "source":  source,
+                })
+        logger.info("Serper search completed",
+                    query=query[:60], results=len(results))
+        return results
 
-        # Strategy 1: match result blocks and extract title + snippet from each
-        for block in _BLOCK_RE.finditer(html):
-            content = block.group(1)
-            t = _TITLE_RE.search(content)
-            s = _SNIPPET_RE.search(content)
-            if t and s:
-                title   = _clean(t.group(2))
-                snippet = _clean(s.group(1))
-                if title and snippet:
-                    results.append({"title": title, "snippet": snippet})
-                    if len(results) >= max_results:
-                        break
-
-        # Strategy 2 (fallback): match titles and snippets globally in order
-        if not results:
-            titles   = [_clean(m.group(2)) for m in _TITLE_RE.finditer(html)]
-            snippets = [_clean(m.group(1)) for m in _SNIPPET_RE.finditer(html)]
-            for title, snippet in zip(titles, snippets):
-                if title and snippet:
-                    results.append({"title": title, "snippet": snippet})
-                    if len(results) >= max_results:
-                        break
+    except httpx.HTTPStatusError as e:
+        logger.warning("Serper API HTTP error",
+                       status=e.response.status_code, query=query[:60])
+        return []
+    except Exception as e:
+        logger.warning("Serper web search failed", error=str(e), query=query[:60])
+        return []
 
-        return results
 
+def _domain(url: str) -> str:
+    """Extract bare domain from a URL for readable source attribution."""
+    try:
+        from urllib.parse import urlparse
+        host = urlparse(url).netloc
+        return host.replace("www.", "") if host else ""
     except Exception:
-        return []
+        return ""
+
+
+# ============================================================
+# Real-estate–specific search helpers
+# ============================================================
+
+async def search_real_estate_prices(
+    location: str,
+    lang_code: str = "en",
+) -> list[dict]:
+    """
+    Run THREE parallel Serper queries targeting different angles of the
+    market and merge the deduplicated results.
+
+    Queries:
+      1. Rental + sale price ranges (with year for freshness)
+      2. Market trend direction (rising / stable / falling)
+      3. Neighbourhood breakdown (which areas are cheap / expensive)
+
+    Having three angles means the LLM gets enough data to write a real
+    market overview instead of repeating one stat three ways.
+    """
+    year = "2025"
+
+    # Build queries — if location is non-English, also search in the
+    # local language so we pick up local portals (e.g. French sites for Cotonou)
+    _loc = location.strip()
+
+    queries = [
+        f"{_loc} rental apartment price range {year}",
+        f"{_loc} real estate market trend property prices {year}",
+        f"{_loc} neighbourhood area property prices cheapest expensive",
+    ]
+
+    # For French-speaking West Africa add a French query to catch local portals
+    if lang_code in ("fr",):
+        queries.append(f"prix loyer appartement {_loc} {year}")
+
+    # Run all queries concurrently — Serper's free tier has no rate limit per second
+    all_results: list[list[dict]] = await asyncio.gather(
+        *[web_search(q, max_results=5) for q in queries],
+        return_exceptions=True,
+    )
 
+    # Merge + deduplicate by link (keep first occurrence)
+    seen_links: set[str] = set()
+    merged: list[dict] = []
+    for batch in all_results:
+        if isinstance(batch, Exception):
+            continue
+        for item in batch:
+            link = item.get("link", "")
+            if link and link in seen_links:
+                continue
+            if link:
+                seen_links.add(link)
+            merged.append(item)
 
-async def search_real_estate_prices(location: str) -> list[dict]:
-    """Search for real estate market prices for a location."""
-    query = f"{location} real estate property rental prices market 2024 2025"
-    return await web_search(query, max_results=6)
+    logger.info("Real-estate search merged",
+                location=_loc, total_results=len(merged))
+    return merged[:15]   # cap at 15 so the LLM prompt stays tight

app/services/alert_service.py

@@ -463,12 +463,19 @@ async def notify_user_of_match(alert: SearchAlert, listing: dict):
         logger.info(f"Personalization: Found user name '{user_name}' for user {alert.user_id}")
     
     # 3. Construct Message using AI (dynamic, personalized & language-aware)
-    # Get user's language from alert params (default to English)
-    user_language = (alert.search_params.get("user_language") or "en").lower()
-    
+    # Prefer the live preferredLanguage from the user's settings (what Flutter writes
+    # when the user changes their language in-app). Fall back to the language that was
+    # stored in the alert's search_params at creation time — which goes stale if the
+    # user changes their language after creating the alert.
+    user_language = (
+        (user or {}).get("preferredLanguage")
+        or alert.search_params.get("user_language")
+        or "en"
+    ).lower()
+
     # Generate message using AI for natural variety
     text = await _generate_alert_message_with_ai(user_name, alert.user_query, user_language)
-    logger.info(f"Alert notification using language: {user_language}")
+    logger.info(f"Alert notification using language: {user_language} (source: {'db' if (user or {}).get('preferredLanguage') else 'stored_params'})")
     
     # Continue with sending the message
     await _continue_notify_user_of_match(alert, listing, conv_id, text)
@@ -576,8 +583,18 @@ async def _continue_notify_user_of_match(alert, listing, conv_id, text):
         try:
             from app.services.voice_service import voice_service
             
-            user_language = (alert.search_params.get("user_language") or "en").lower()
-            audio_bytes, duration = await voice_service.text_to_speech(text, language=user_language)
+            # Use live preferredLanguage — same resolution as the push title above
+            _voice_lang = "en"
+            try:
+                from bson import ObjectId as _ObjId2
+                _vu = await db.users.find_one(
+                    {"_id": _ObjId2(alert.user_id)}, {"preferredLanguage": 1}
+                )
+                _voice_lang = (_vu or {}).get("preferredLanguage") or \
+                    (alert.search_params.get("user_language") or "en")
+            except Exception:
+                _voice_lang = (alert.search_params.get("user_language") or "en")
+            audio_bytes, duration = await voice_service.text_to_speech(text, language=_voice_lang)
             audio_url = await voice_service.upload_audio_to_r2(audio_bytes)
             
             voice_media = {
@@ -612,14 +629,34 @@ async def _continue_notify_user_of_match(alert, listing, conv_id, text):
             {"$set": {"last_notified_at": datetime.utcnow()}}
         )
     
-    # Push notification — wakes up the user even when the app is closed
+    # Push notification — wakes up the user even when the app is closed.
+    # Title is localized to the user's preferredLanguage from settings.
     try:
         from app.services.push_service import PushService
+        from app.ai.agent.brain import generate_localized_response
+        from bson import ObjectId as _ObjId
+
+        # Fresh language lookup — not the stale value stored in search_params
+        _push_lang = "en"
+        try:
+            _u = await db.users.find_one(
+                {"_id": _ObjId(alert.user_id)}, {"preferredLanguage": 1}
+            )
+            _push_lang = (_u or {}).get("preferredLanguage") or "en"
+        except Exception:
+            pass
+
         listing_title = listing.get("title", "a new property")
+        _push_title = await generate_localized_response(
+            context="Generate a very short push notification title (max 6 words) telling the user that AIDA found a new listing that matches their search.",
+            language=_push_lang,
+            tone="excited",
+            max_length="very_short",
+        )
         await PushService.send_to_user(
             user_id=alert.user_id,
-            title="AIDA found a match! 🏠",
-            body=f"A listing matching your search just went live: {listing_title}",
+            title=_push_title,
+            body=f"{listing_title}",
             category="property_alerts",
             data={
                 "type": "alert_match",

app/services/landlord_notifications.py

@@ -1,9 +1,9 @@
-import logging
 from datetime import datetime
 from bson import ObjectId
+from structlog import get_logger
 from app.database import get_db
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 # The ONE canonical participant ID for AIDA used system-wide.
 AIDA_BOT_ID = "AIDA_BOT"
@@ -154,18 +154,34 @@ async def notify_landlord_via_aida(landlord_id: str, message_content: str):
         )
 
         # ── FCM push notification ──────────────────────────────────────────
-        # Fires even when the user's app is closed / backgrounded.
+        # Title is localized to the landlord's app language (preferredLanguage).
+        # Body is already localized by the caller (booking.py / payout_jobs.py).
         try:
             from app.services.push_service import push_service
+            from app.ai.agent.brain import generate_localized_response
+
+            # Look up landlord's preferred language — same field Flutter writes to Settings
+            _landlord_doc = await db["users"].find_one(
+                {"_id": ObjectId(landlord_id)}, {"preferredLanguage": 1}
+            )
+            _landlord_lang = (_landlord_doc or {}).get("preferredLanguage") or "en"
+
+            push_title = await generate_localized_response(
+                context="Generate a very short push notification title (max 6 words) telling the landlord about a booking or property update from AIDA.",
+                language=_landlord_lang,
+                tone="friendly",
+                max_length="very_short",
+            )
             await push_service.send_to_user(
                 user_id=landlord_id,
-                title="🎉 New Booking Confirmed!",
+                title=push_title,
                 body=message_content[:100],
                 category="booking_updates",
                 data={"type": "booking_confirmation", "conversation_id": conv_id},
             )
         except Exception as push_err:
-            logger.warning(f"Push notification failed for landlord {landlord_id} (non-fatal): {push_err}")
+            logger.warning("Push notification failed for landlord (non-fatal)",
+                           landlord_id=landlord_id, error=str(push_err))
 
         # ── Broadcast via WebSocket so the message appears instantly ──────
         try:

app/services/proactive_service.py

@@ -122,12 +122,22 @@ async def _send_aida_dm_alert(
     message: str,
     listing_id: str,
     listing: dict,
+    lang: str = "en",
 ) -> None:
     """
     Send an alert match or price drop as an AIDA DM.
     Delegates to send_aida_dm which handles DB + WebSocket broadcast + push notification.
+
+    ``lang`` should be the user's preferredLanguage from DB so the push
+    title that appears on their lock screen is in the right language.
     """
     try:
+        push_title = await generate_localized_response(
+            context="Generate a very short push notification title (max 6 words) telling the user that AIDA found a new property that matches what they are looking for.",
+            language=lang,
+            tone="friendly",
+            max_length="very_short",
+        )
         await send_aida_dm(
             user_id=user_id,
             text=message,
@@ -141,7 +151,7 @@ async def _send_aida_dm_alert(
                     "images": listing.get("images", []),
                 }
             },
-            push_title="AIDA — New match found",
+            push_title=push_title,
             push_body=message[:100],
         )
     except Exception as e:
@@ -328,11 +338,19 @@ async def check_new_listings_against_preferences(
                 )
 
                 # Primary: AIDA DM (in-app, actionable)
-                await _send_aida_dm_alert(user_id, dm_msg, listing_id, listing)
-                # Fallback: push notification (for when user is outside the app)
+                # Pass lang so the push title on the lock screen is also localized.
+                await _send_aida_dm_alert(user_id, dm_msg, listing_id, listing, lang=lang)
+                # Fallback: standalone push (for when user is fully outside the app).
+                # Title localized using the same lang already resolved above.
+                push_title_fallback = await generate_localized_response(
+                    context="Generate a very short push notification title (max 6 words) telling the user a new property listing matches their preferences.",
+                    language=lang,
+                    tone="excited",
+                    max_length="very_short",
+                )
                 push_count = await _send_proactive_push(
                     user_id=user_id,
-                    title="New listing matches your preferences!",
+                    title=push_title_fallback,
                     body=f"{title} in {location} - {currency} {price}",
                     listing_id=listing_id,
                     notification_type="new_match",
@@ -539,20 +557,38 @@ async def check_alerts_against_new_listings(
                     max_length="short",
                 )
 
-                await _send_aida_dm_alert(alert.user_id, dm_msg, listing_id, listing)
+                await _send_aida_dm_alert(alert.user_id, dm_msg, listing_id, listing, lang=lang)
+                _push_title_alert = await generate_localized_response(
+                    context="Generate a very short push notification title (max 6 words) telling the user a new property matches their search alert.",
+                    language=lang,
+                    tone="excited",
+                    max_length="very_short",
+                )
                 push_count = await _send_proactive_push(
                     user_id=alert.user_id,
-                    title="Alert match found!",
+                    title=_push_title_alert,
                     body=f"{title} in {location} - {currency} {price}",
                     listing_id=listing_id,
                     notification_type="alert_match",
                 )
                 sent_count += push_count
 
+                _email_title_alert = await generate_localized_response(
+                    context="Generate a short email subject line (max 8 words) telling the user a property was found that matches their search alert.",
+                    language=lang,
+                    tone="friendly",
+                    max_length="very_short",
+                )
+                _email_body_alert = await generate_localized_response(
+                    context=f"Write one sentence telling the user we found '{title}' in {location} for {currency} {price} and they should open the app to check it out.",
+                    language=lang,
+                    tone="friendly",
+                    max_length="short",
+                )
                 await _send_proactive_email(
                     user_id=alert.user_id,
-                    title="A property matches your alert!",
-                    body=f"We found '{title}' in {location} for {currency} {price}. Open the app to check it out!",
+                    title=_email_title_alert,
+                    body=_email_body_alert,
                     listing_id=listing_id,
                     notification_type="alert_match",
                 )
@@ -687,10 +723,16 @@ async def _notify_price_drop(
                 tone="excited",
                 max_length="short",
             )
-            await _send_aida_dm_alert(user_id, dm_msg, listing_id, listing)
+            await _send_aida_dm_alert(user_id, dm_msg, listing_id, listing, lang=lang)
+            _push_title_drop = await generate_localized_response(
+                context=f"Generate a very short push notification title (max 6 words) telling the user the price dropped on a property they might like. Drop: {drop_pct:.0f}%.",
+                language=lang,
+                tone="excited",
+                max_length="very_short",
+            )
             push_count = await _send_proactive_push(
                 user_id=user_id,
-                title="Price dropped!",
+                title=_push_title_drop,
                 body=f"{title} dropped {drop_pct:.0f}% to {currency} {new_price:,.0f}",
                 listing_id=listing_id,
                 notification_type="price_drop",
@@ -728,10 +770,16 @@ async def _notify_price_drop(
                     tone="excited",
                     max_length="short",
                 )
-                await _send_aida_dm_alert(alert.user_id, dm_msg, listing_id, listing)
+                await _send_aida_dm_alert(alert.user_id, dm_msg, listing_id, listing, lang=lang)
+                _push_title_alert_drop = await generate_localized_response(
+                    context=f"Generate a very short push notification title (max 6 words) telling the user the price dropped on a property that matches their saved search alert. Drop: {drop_pct:.0f}%.",
+                    language=lang,
+                    tone="excited",
+                    max_length="very_short",
+                )
                 push_count = await _send_proactive_push(
                     user_id=alert.user_id,
-                    title="Price dropped on a match!",
+                    title=_push_title_alert_drop,
                     body=f"{title} dropped {drop_pct:.0f}% to {currency} {new_price:,.0f}",
                     listing_id=listing_id,
                     notification_type="price_drop",

app/services/push_service.py

@@ -2,16 +2,17 @@
 # app/services/push_service.py – FCM Push Notification Service
 # ============================================================
 import asyncio
-import logging
 import os
 import random
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Iterable, List, Optional, Tuple
 
+from structlog import get_logger
+
 from app.database import get_db
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 # ============================================================

app/services/viewing_service.py

@@ -27,7 +27,6 @@ How AIDA knows who the visitor is:
 """
 
 import json
-import logging
 import re
 from datetime import datetime, timezone
 from typing import List, Optional
@@ -39,10 +38,12 @@ from app.services.aida_dm_service import send_aida_dm as _send_aida_dm
 from app.ai.agent.brain import generate_localized_response
 
 
+from structlog import get_logger
+
 def _lang(user: dict) -> str:
     return (user or {}).get("preferredLanguage", "en")
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 def _user_lang(user: dict) -> str: