Enhance intent management in AI chat functionality

- Introduced intent extraction and updating logic in the `ai_chat.py` module to capture user property search preferences, including location, budget, size, and must-have features.
- Updated the `process_message` function to include intent data, ensuring a more personalized chat experience.
- Modified the database functions to support intent management, allowing for the creation and updating of user intent records.
- Improved the interaction flow by prompting users for missing intent information, enhancing engagement and response relevance.

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
+from database import get_session_messages, save_message, update_user_persona, update_user_intent
 
 def chat_with_session_memory(state):
     """Chat function with session-based memory"""
@@ -28,6 +28,14 @@ def chat_with_session_memory(state):
         f" The user prefers {p.get('language','[unspecified]')} and wants a {p.get('tone','neutral')} tone."
     )
     
+    intent_data = state.get("intent", {})
+    system_message += (
+        f" They're looking for a property in {intent_data.get('location_preference','[any area]')}, "
+        f"with a budget up to {intent_data.get('budget','[any amount]')} per month, "
+        f"around {intent_data.get('size_preference_sqm','[size]')} sqm, "
+        f"and must-haves: {', '.join(intent_data.get('must_have',[])) or '[none]'}. "
+    )
+    
     # Build messages array with history
     messages = [{"role": "system", "content": system_message}]
     
@@ -67,6 +75,7 @@ class ChatState(TypedDict):
     wamid: str
     session_messages: list
     persona: dict
+    intent: dict
 
 async def extract_and_update_persona(state):
     # a. Define which persona fields to track
@@ -122,16 +131,69 @@ async def extract_and_update_persona(state):
     # f. All persona fields present—proceed to chat
     return {"response": None}
 
+async def extract_and_update_intent(state):
+    intent_fields = ["location_preference", "budget", "size_preference_sqm", "must_have"]
+    user_message = state["user_message"]
+    session_id = state["session_id"]
+    intent = state.get("intent", {})
+
+    extraction_prompt = f"""
+    Extract and normalize the user's current property search intent from this message:
+    {user_message}
+
+    Normalize abbreviations (e.g., 'sqm' → 'square metres') and correct any spelling mistakes.
+    If the user is asking a definition or clarification (e.g. 'What does square metre mean?'), answer that question fully and do not update the intent. After answering, wait for the next user message to extract values.
+    Return only a JSON object with keys {intent_fields}, using null for unknown.
+    """
+
+    response = await llm.ainvoke([{"role":"user","content":extraction_prompt}])
+    
+    # Check if response is an explanatory answer rather than JSON
+    if not response.content.strip().startswith("{"):
+        state["response"] = response.content
+        return state
+    
+    import json
+    try:
+        extracted = json.loads(response.content)
+    except:
+        print("Failed to parse intent JSON:", response.content)
+        extracted = {}
+
+    for field in intent_fields:
+        new_val = extracted.get(field)
+        old_val = intent.get(field)
+        if new_val is not None and new_val != old_val:
+            await update_user_intent(session_id, {field: new_val})
+            intent[field] = new_val
+
+    state["intent"] = intent
+
+    missing = [f for f in intent_fields if state["intent"].get(f) is None]
+    if missing:
+        questions = {
+            "location_preference": "Hi there! Which area or suburb are you interested in?",
+            "budget": "Hi there! What is your monthly budget?",
+            "size_preference_sqm": "Hi there! How many square metres do you need?",
+            "must_have": "Hi there! What features are must-haves for you?"
+        }
+        state["response"] = questions.get(missing[0], f"Hi there! Could you tell me your {missing[0]}?")
+        return state
+
+    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("chat", RunnableLambda(chat_with_session_memory))
 graph.set_entry_point("persona_update")
-graph.add_edge("persona_update", "chat")
+graph.add_edge("persona_update", "intent_update")
+graph.add_edge("intent_update", "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):
+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):
     """Process a message through the AI chat system with session memory"""
     if user_info is None:
         user_info = {}
@@ -149,7 +211,8 @@ async def process_message(user_message: str, user_info: dict = None, session_id:
         "wa_id": wa_id,
         "wamid": wamid,
         "session_messages": session_messages,
-        "persona": persona or {}
+        "persona": persona or {},
+        "intent": intent or {}
     })
     
     # Save messages to database

database.py

@@ -240,46 +240,36 @@ async def update_user_persona(wa_id: str, updates: dict):
 # --- Intent Management ---
 async def get_or_create_user_intent(session_id: str, wa_id: str) -> dict:
     """
-    Fetches the intent row for this session. 
-    If none exists, inserts a new empty intent record and returns it.
+    Fetch or create the intent record for this session.
     """
-    if not supabase or session_id == "local_session":
-        return {"session_id": session_id, "wa_id": wa_id, "created_at": datetime.utcnow().isoformat(), "updated_at": datetime.utcnow().isoformat()}
-    
-    try:
-        resp = supabase\
-            .table("user_intents")\
-            .select("*")\
-            .eq("session_id", session_id)\
-            .single()\
-            .execute()
-        if resp.data:
-            return resp.data
-        new_intent = {
-            "session_id": session_id,
-            "wa_id":      wa_id,
-            "created_at": datetime.utcnow().isoformat(),
-            "updated_at": datetime.utcnow().isoformat()
-        }
-        insert = supabase.table("user_intents").insert(new_intent).execute()
-        return insert.data[0] if insert.data else new_intent
-    except Exception as e:
-        print(f"Error in get_or_create_user_intent: {e}")
-        return {"session_id": session_id, "wa_id": wa_id, "created_at": datetime.utcnow().isoformat(), "updated_at": datetime.utcnow().isoformat()}
+    resp = supabase \
+        .table("user_intents") \
+        .select("*") \
+        .eq("session_id", session_id) \
+        .single() \
+        .execute()
+    if resp.data:
+        return resp.data
+    new_intent = {
+        "session_id":          session_id,
+        "wa_id":               wa_id,
+        "location_preference": None,
+        "budget":              None,
+        "size_preference_sqm": None,
+        "must_have":           None,
+        "created_at":          datetime.utcnow().isoformat(),
+        "updated_at":          datetime.utcnow().isoformat()
+    }
+    insert = supabase.table("user_intents").insert(new_intent).execute()
+    return insert.data[0] if insert.data else new_intent
 
 async def update_user_intent(session_id: str, updates: dict):
     """
-    Patches only the fields in the intent row that have changed.
+    Patch the intent record with any changed fields.
     """
-    if not supabase or session_id == "local_session":
-        return
-    
-    try:
-        updates_with_ts = {**updates, "updated_at": datetime.utcnow().isoformat()}
-        supabase\
-            .table("user_intents")\
-            .update(updates_with_ts)\
-            .eq("session_id", session_id)\
-            .execute()
-    except Exception as e:
-        print(f"Error updating user intent: {e}") 
+    updates_with_ts = { **updates, "updated_at": datetime.utcnow().isoformat() }
+    supabase \
+        .table("user_intents") \
+        .update(updates_with_ts) \
+        .eq("session_id", session_id) \
+        .execute() 

main.py

@@ -3,7 +3,7 @@ from fastapi.responses import JSONResponse
 
 # Import our modular components
 from config import supabase
-from database import get_or_create_user, update_user_activity, get_or_create_active_session, get_user_persona
+from database import get_or_create_user, update_user_activity, get_or_create_active_session, get_user_persona, get_or_create_user_intent
 from whatsapp import send_whatsapp_message
 from ai_chat import process_message
 from api_routes import router
@@ -49,6 +49,9 @@ async def receive_message(req: Request):
             # Get user persona
             persona = await get_user_persona(wa_id)
             
+            # Get or create user intent
+            intent = await get_or_create_user_intent(session["id"], wa_id)
+            
             # Process with AI including session memory
             ai_response = await process_message(
                 user_message=user_message,
@@ -56,7 +59,8 @@ async def receive_message(req: Request):
                 session_id=session["id"],
                 wa_id=wa_id,
                 wamid=wamid,
-                persona=persona
+                persona=persona,
+                intent=intent
             )
             
             # Send response back to WhatsApp