propety search

ai_chat.py

@@ -2,7 +2,7 @@ from langgraph.graph import StateGraph, END
 from langchain_core.runnables import RunnableLambda
 from typing import TypedDict
 from config import llm, OPENAI_API_KEY
-from database import get_session_messages, save_message, update_user_persona, update_user_intent
+from database import get_session_messages, save_message, update_user_persona, update_user_intent, search_properties
 
 def chat_with_session_memory(state):
     """Chat function with session-based memory"""
@@ -37,6 +37,22 @@ def chat_with_session_memory(state):
         f"and must-haves: {', '.join(must_have_list) if must_have_list else '[none]'}. "
     )
     
+    props = state.get("properties", [])
+    if props:
+        system_message += "\nHere are some listings I found:\n"
+        for p in props[:5]:
+            title = p.get("title", "[no title]")
+            loc = p.get("location", "")
+            city = p.get("city", "")
+            size = p.get("size_sqm", "")
+            price = p.get("price", "")
+            ptype = p.get("price_type", "")
+            features = ", ".join(p.get("features", [])) or "[no features]"
+            system_message += (
+                f"- {title} in {loc}, {city}: {size} sqm, "
+                f"{price} ({ptype}); features: {features}\n"
+            )
+    
     # Build messages array with history
     messages = [{"role": "system", "content": system_message}]
     
@@ -77,6 +93,7 @@ class ChatState(TypedDict):
     session_messages: list
     persona: dict
     intent: dict
+    properties: list
 
 async def extract_and_update_persona(state):
     # a. Define which persona fields to track
@@ -243,18 +260,55 @@ async def extract_and_update_intent(state):
 
     return {"response": None}
 
+async def extract_and_search_properties(state):
+    """
+    Search for properties based on user intent and store results in state.
+    """
+    intent = state.get("intent", {})
+    
+    # Check if we have the minimum required fields for property search
+    location = intent.get("location_preference")
+    budget = intent.get("budget")
+    size = intent.get("size_preference_sqm")
+    
+    if not location or budget is None or size is None:
+        # Missing required fields, skip property search
+        return {"response": None}
+    
+    # Prepare filters for property search
+    filters = {
+        "location_preference": location,
+        "budget": budget,
+        "size_preference_sqm": size,
+        "must_have": intent.get("must_have", [])
+    }
+    
+    # Search for properties
+    properties = await search_properties(filters)
+    state["properties"] = properties
+    
+    if not properties:
+        # No properties found, provide fallback suggestion
+        state["response"] = f"I don't see any listings in {location} that match your criteria. Would you like to look in Johannesburg instead, or adjust your requirements?"
+        return state
+    
+    # Properties found, continue to chat
+    return {"response": None}
+
 # --- Build LangGraph ---
 graph = StateGraph(ChatState)
 graph.add_node("persona_update", RunnableLambda(extract_and_update_persona))
 graph.add_node("intent_update", RunnableLambda(extract_and_update_intent))
+graph.add_node("property_search", RunnableLambda(extract_and_search_properties))
 graph.add_node("chat", RunnableLambda(chat_with_session_memory))
 graph.set_entry_point("persona_update")
 graph.add_edge("persona_update", "intent_update")
-graph.add_edge("intent_update", "chat")
+graph.add_edge("intent_update", "property_search")
+graph.add_edge("property_search", "chat")
 graph.add_edge("chat", END)
 chat_graph = graph.compile()
 
-async def process_message(user_message: str, user_info: dict = None, session_id: str = None, wa_id: str = None, wamid: str = None, persona: dict = None, intent: dict = None):
+async def process_message(user_message: str, user_info: dict = None, session_id: str = None, wa_id: str = None, wamid: str = None, persona: dict = None, intent: dict = None, properties: list = None):
     """Process a message through the AI chat system with session memory"""
     if user_info is None:
         user_info = {}
@@ -273,7 +327,8 @@ async def process_message(user_message: str, user_info: dict = None, session_id:
         "wamid": wamid,
         "session_messages": session_messages,
         "persona": persona or {},
-        "intent": intent or {}
+        "intent": intent or {},
+        "properties": properties or []
     })
     
     # Save messages to database

database.py

@@ -286,4 +286,52 @@ async def update_user_intent(session_id: str, updates: dict):
             .execute()
         print(f"Successfully updated intent for session {session_id}")
     except Exception as e:
-        print(f"Error updating user intent: {e}") 
+        print(f"Error updating user intent: {e}")
+
+# --- Property Search ---
+async def search_properties(filters: dict) -> list:
+    """
+    Returns up to 5 active properties matching the user's filters.
+    """
+    if not supabase:
+        return []
+    
+    try:
+        query = supabase.table("properties").select("*").eq("is_active", True)
+        
+        # a. Location: try city first, then location field
+        loc = filters.get("location_preference")
+        if loc:
+            query = query.ilike("city", f"%{loc}%")
+            resp = query.execute()
+            if not resp.data:
+                # fallback to suburb/area match
+                query = supabase.table("properties").select("*")\
+                    .eq("is_active", True)\
+                    .ilike("location", f"%{loc}%")
+        
+        # b. Budget cap
+        budget = filters.get("budget")
+        if budget is not None:
+            query = query.lte("price", budget)
+        
+        # c. Minimum size
+        size = filters.get("size_preference_sqm")
+        if size is not None:
+            query = query.gte("size_sqm", size)
+        
+        # d. Must-have features
+        features = filters.get("must_have") or []
+        for feat in features:
+            query = query.contains("features", [feat])
+        
+        # e. Order & limit
+        query = query.order("is_featured", desc=True).order("price", asc=True).limit(5)
+        
+        # f. Execute and return
+        resp = query.execute()
+        return resp.data or []
+        
+    except Exception as e:
+        print(f"Error searching properties: {e}")
+        return []