Update AI chat functionality to improve property recommendation responses

- Modified the system message in `chat_with_session_memory` to allow sharing of listing URLs and additional property details, enhancing user interaction.
- Added a `search_status_message` to provide context on search results and fallback responses when specific property details are unavailable.
- Removed debug print statements from various functions to streamline the code and improve readability, ensuring a cleaner implementation.
- Enhanced the property search logic to return relevant status messages, improving communication with users when exact matches are not found.

ai_chat.py

@@ -47,7 +47,7 @@ def chat_with_session_memory(state):
     system_message = (
         f"Hello {user_info.get('name','there')}! You are a helpful and concise property agent. "
         "Always base property recommendations solely on listings in our database. "
-        "Do not suggest or mention any external websites or property portals."
+        "You can share listing URLs and other details that are available in the property data."
     )
     if user_info.get("name") and user_info["name"] != "Unknown":
         system_message += f" The user's name is {user_info['name']}."
@@ -67,9 +67,12 @@ def chat_with_session_memory(state):
     )
     
     props = state.get("properties", [])
-    print(f"DEBUG: Properties in state: {len(props)} properties")
+    search_status = state.get("search_status_message", "")
+    
+    if search_status:
+        system_message += f"\n{search_status}\n"
+    
     if props:
-        print(f"DEBUG: First property: {props[0]}")
         system_message += "\nHere are some listings I found:\n"
         for p in props[:5]:
             title = p.get("title", "[no title]")
@@ -84,12 +87,8 @@ def chat_with_session_memory(state):
                 f"{price} ({ptype}); features: {features}\n"
             )
             url = p.get("listing_url")
-            print(f"DEBUG: Property URL: {url}")
             if url:
                 system_message += f"  Link: {url}\n"
-                print(f"DEBUG: Added URL to system message")
-            else:
-                print(f"DEBUG: No URL found for property")
     
     # After the listings loop, before building messages[]
     extras = set()
@@ -108,6 +107,8 @@ def chat_with_session_memory(state):
             f"\nI can also share {opts} for any listing—just let me know what you'd like."
         )
     
+    system_message += "\n\nIMPORTANT: When users ask about specific details for a listing, check if that information is available in the property data. If not available, respond with 'For this listing, I don't have [specific detail] available right now' instead of saying you can't provide URLs or external information."
+    
     # Build messages array with history
     messages = [{"role": "system", "content": system_message}]
     
@@ -149,6 +150,7 @@ class ChatState(TypedDict):
     persona: dict
     intent: dict
     properties: list
+    search_status_message: str
 
 async def extract_and_update_persona(state):
     # a. Define which persona fields to track
@@ -205,11 +207,6 @@ async def extract_and_update_persona(state):
     return {"response": None}
 
 async def extract_and_update_intent(state):
-    print(f"=== Starting extract_and_update_intent ===")
-    print(f"Session ID: {state.get('session_id')}")
-    print(f"User message: {state.get('user_message')}")
-    print(f"Current intent: {state.get('intent')}")
-    
     intent_fields = ["location_preference", "budget", "size_preference_sqm", "must_have"]
     user_message = state["user_message"]
     session_id = state["session_id"]
@@ -236,48 +233,32 @@ async def extract_and_update_intent(state):
     """
 
     response = await llm.ainvoke([{"role":"user","content":extraction_prompt}])
-    print(f"LLM response for intent extraction: {response.content}")
     
     import json
     try:
         # Clean up the response content (remove markdown formatting if present)
         content = response.content.strip()
-        print(f"Original content: {repr(content)}")
         
         if content.startswith('```json'):
             content = content[7:]  # Remove ```json
-            print(f"After removing ```json: {repr(content)}")
         if content.endswith('```'):
             content = content[:-3]  # Remove ```
-            print(f"After removing ```: {repr(content)}")
         content = content.strip()
-        print(f"Final cleaned content: {repr(content)}")
         
         # Check if cleaned content is JSON
         if not content.startswith("{"):
-            print("Cleaned content is not JSON, treating as explanatory answer")
             state["response"] = response.content
             return state
         
         extracted = json.loads(content)
-        print(f"Successfully parsed intent JSON: {extracted}")
     except Exception as e:
-        print("Failed to parse intent JSON:", response.content)
-        print("Error:", e)
-        print(f"Content that failed to parse: {repr(content)}")
         extracted = {}
 
-    print(f"Starting field update loop. Extracted: {extracted}")
-    print(f"Current intent state: {intent}")
-    
     for field in intent_fields:
         new_val = extracted.get(field)
         old_val = intent.get(field)
-        print(f"Processing field {field}: new_val={new_val}, old_val={old_val}")
         
         if new_val is not None and new_val != old_val:
-            print(f"Updating intent field {field}: {old_val} -> {new_val}")
-            
             # Handle must_have field as array (LLM decides the logic)
             if field == "must_have" and new_val:
                 # Convert to array format for database
@@ -289,16 +270,11 @@ async def extract_and_update_intent(state):
                 else:
                     must_have_array = new_val if isinstance(new_val, list) else [str(new_val)]
                 
-                print(f"LLM decided must_have: {must_have_array}")
                 await update_user_intent(session_id, {field: must_have_array})
                 intent[field] = must_have_array
             else:
                 await update_user_intent(session_id, {field: new_val})
                 intent[field] = new_val
-        elif new_val is not None:
-            print(f"Intent field {field} unchanged: {new_val}")
-        else:
-            print(f"Intent field {field} not extracted")
 
     state["intent"] = intent
 
@@ -319,18 +295,13 @@ async def extract_and_search_properties(state):
     """
     Search for properties based on user intent and store results in state.
     """
-    print(f"=== Starting extract_and_search_properties ===")
     intent = state.get("intent", {})
-    print(f"Intent data: {intent}")
     
     # Check if we have the minimum required field for property search
     location = intent.get("location_preference")
     
-    print(f"Location: {location}")
-    
     if not location:
         # Missing location, skip property search
-        print(f"Missing location - skipping property search")
         return {"response": None}
     
     # Prepare filters for property search
@@ -349,8 +320,6 @@ async def extract_and_search_properties(state):
     if must_have and len(must_have) > 0:
         filters["must_have"] = must_have
     
-    print(f"Searching with filters: {filters}")
-    
     # Search for properties
     properties = await search_properties(filters)
     state["properties"] = properties
@@ -364,36 +333,39 @@ async def extract_and_search_properties(state):
         filters2 = {k: v for k, v in filters.items() if k != "must_have"}
         props2 = await search_properties(filters2)
         if props2:
-            state["properties"] = props2
-            state["response"] = (
-                "I don't have an exact match with those features, "
-                "but here are listings matching your location, budget and size."
-            )
-            return state
+            return {
+                "properties": props2,
+                "search_status_message": (
+                    "I don't have an exact match with those features, "
+                    "but here are listings matching your location, budget and size."
+                )
+            }
 
     # Pass 3: drop size
-    if "size_preference_sqm" in filters2:
-        filters3 = {k: v for k, v in filters2.items() if k != "size_preference_sqm"}
+    if "size_preference_sqm" in filters:
+        filters3 = {k: v for k, v in filters.items() if k not in ["must_have", "size_preference_sqm"]}
         props3 = await search_properties(filters3)
         if props3:
-            state["properties"] = props3
-            state["response"] = (
-                "I don't have that exact size, "
-                "but here are listings matching your location and budget."
-            )
-            return state
+            return {
+                "properties": props3,
+                "search_status_message": (
+                    "I don't have that exact size, "
+                    "but here are listings matching your location and budget."
+                )
+            }
 
     # Pass 4: drop budget
-    if "budget" in filters3:
-        filters4 = {k: v for k, v in filters3.items() if k != "budget"}
+    if "budget" in filters:
+        filters4 = {k: v for k, v in filters.items() if k not in ["must_have", "size_preference_sqm", "budget"]}
         props4 = await search_properties(filters4)
         if props4:
-            state["properties"] = props4
-            state["response"] = (
-                f"I don't have listings within your budget in {filters4['location_preference']}, "
-                "but here are some options in that area."
-            )
-            return state
+            return {
+                "properties": props4,
+                "search_status_message": (
+                    f"I don't have listings within your budget in {filters4['location_preference']}, "
+                    "but here are some options in that area."
+                )
+            }
 
     # Final fallback: no listings at all
     state["response"] = (

database.py

@@ -273,87 +273,61 @@ async def update_user_intent(session_id: str, updates: dict):
     Patch the intent record with any changed fields.
     """
     if not supabase or session_id == "local_session":
-        print(f"Skipping intent update for session {session_id} (no supabase or local session)")
         return
     
     try:
         updates_with_ts = { **updates, "updated_at": datetime.utcnow().isoformat() }
-        print(f"Updating user_intents table for session {session_id} with: {updates_with_ts}")
         supabase \
             .table("user_intents") \
             .update(updates_with_ts) \
             .eq("session_id", session_id) \
             .execute()
-        print(f"Successfully updated intent for session {session_id}")
     except Exception as e:
-        print(f"Error updating user intent: {e}")
+        pass
 
 # --- Property Search ---
 async def search_properties(filters: dict) -> list:
     """
     Returns up to 5 active properties matching the user's filters.
     """
-    print(f"=== Starting search_properties ===")
-    print(f"Filters: {filters}")
-    
     if not supabase:
-        print("No supabase client - returning empty list")
         return []
     
     try:
-        # First, let's see if there are any properties at all
-        test_query = supabase.table("properties").select("*").limit(5)
-        test_resp = test_query.execute()
-        print(f"Total properties in database: {len(test_resp.data) if test_resp.data else 0}")
-        if test_resp.data:
-            print(f"Sample properties: {test_resp.data}")
-        
         query = supabase.table("properties").select("*").eq("is_active", True)
-        print("Base query created")
         
         # a. Location: try city first, then location field
         loc = filters.get("location_preference")
         if loc:
-            print(f"Searching for location: {loc}")
             query = query.ilike("city", f"%{loc}%")
-            print(f"After city filter: {query}")
             resp = query.execute()
-            print(f"City search result: {resp.data}")
             if not resp.data:
                 # fallback to suburb/area match
-                print(f"No city matches, trying location field...")
                 query = supabase.table("properties").select("*")\
                     .eq("is_active", True)\
                     .ilike("location", f"%{loc}%")
-                print(f"After location filter: {query}")
         
         # b. Budget cap
         budget = filters.get("budget")
         if budget is not None:
-            print(f"Adding budget filter: <= {budget}")
             query = query.lte("price", budget)
         
         # c. Minimum size
         size = filters.get("size_preference_sqm")
         if size is not None:
-            print(f"Adding size filter: >= {size}")
             query = query.gte("size_sqm", size)
         
         # d. Must-have features
         features = filters.get("must_have") or []
         for feat in features:
-            print(f"Adding feature filter: {feat}")
             query = query.contains("features", [feat])
         
         # e. Order & limit
         query = query.order("is_featured", desc=True).order("price").limit(5)
         
         # f. Execute and return
-        print(f"Executing final query...")
         resp = query.execute()
-        print(f"Query executed. Response: {resp.data}")
         return resp.data or []
         
     except Exception as e:
-        print(f"Error searching properties: {e}")
         return []