db still not saving repleaced with ai

ai_chat.py

@@ -9,7 +9,8 @@ from persona_manager import (
     parse_user_response, 
     update_persona_field,
     PERSONA_FIELDS,
-    get_persona_summary
+    get_persona_summary,
+    extract_persona_from_message
 )
 
 def chat_with_session_memory(state):
@@ -210,6 +211,13 @@ async def process_message(user_message: str, user_info: dict = None, session_id:
                 parsed_response = await parse_user_response(user_message, field)
                 break
     
+    # Proactive persona extraction from any message
+    extracted_persona = {}
+    if not is_persona_question and wa_id:
+        # Try to extract persona fields from the current message
+        extracted_persona = await extract_persona_from_message(user_message, persona)
+        print(f"Extracted persona from message: {extracted_persona}")
+    
     # Process with AI
     result = await chat_graph.ainvoke({
         "user_message": user_message,
@@ -226,7 +234,14 @@ async def process_message(user_message: str, user_info: dict = None, session_id:
     })
     
     print("LangGraph result:", result)  # Debugging
-    # Save persona field if present
+    
+    # Save extracted persona fields first
+    for field, value in extracted_persona.items():
+        if value is not None:
+            print(f"Saving extracted persona field {field} with value {value} for user {wa_id}")
+            await update_persona_field(wa_id, field, value)
+    
+    # Save persona field if present in result
     if result.get("persona_field") and result.get("persona_value") is not None and wa_id:
         print(f"Saving persona field {result['persona_field']} with value {result['persona_value']} for user {wa_id}")
         await update_persona_field(wa_id, result["persona_field"], result["persona_value"])

persona_manager.py

@@ -308,7 +308,7 @@ async def fallback_parse_response(user_message: str, field: str) -> Tuple[bool,
 
 async def should_ask_persona_question(persona: Dict, conversation_context: str = "") -> Tuple[bool, Optional[str]]:
     """
-    Determine if we should ask a persona question
+    Determine if we should ask a persona question using AI
     Returns: (should_ask, field_to_ask)
     """
     # Check if persona is complete
@@ -317,38 +317,58 @@ async def should_ask_persona_question(persona: Dict, conversation_context: str =
     if not missing_fields:
         return False, None
     
-    # Check if user is asking about properties (indicates they want to search)
-    search_indicators = [
-        "property", "warehouse", "industrial", "space", "building",
-        "available", "looking for", "need", "find", "search", "show me", "what do you have"
-    ]
-    
-    conversation_lower = conversation_context.lower()
-    is_searching = any(indicator in conversation_lower for indicator in search_indicators)
-    
-    # Check for greetings or casual conversation - don't ask persona questions
-    casual_indicators = [
-        "hi", "hello", "hey", "good morning", "good afternoon", "good evening",
-        "how are you", "what's up", "thanks", "thank you", "bye", "goodbye",
-        "morning", "afternoon", "evening", "sup", "yo"
-    ]
-    
-    # Check if the message is primarily a greeting
-    is_casual = any(indicator in conversation_lower for indicator in casual_indicators)
-    
-    # If it's a greeting, don't ask persona questions
-    if is_casual:
+    if not OPENAI_API_KEY:
+        # Fallback to basic keyword detection
+        conversation_lower = conversation_context.lower()
+        
+        # Check for greetings
+        casual_indicators = ["hi", "hello", "hey", "thanks", "thank you", "bye", "goodbye"]
+        is_casual = any(indicator in conversation_lower for indicator in casual_indicators)
+        
+        if is_casual:
+            return False, None
+        
+        # Check for property-related keywords
+        search_indicators = ["property", "warehouse", "industrial", "space", "building", "looking for", "need", "find"]
+        is_searching = any(indicator in conversation_lower for indicator in search_indicators)
+        
+        if is_searching:
+            return True, missing_fields[0]
+        
         return False, None
     
-    # Also check if the message is very short (likely a greeting)
-    if len(user_message.strip()) <= 10 and is_casual:
+    try:
+        # Use AI to determine if we should ask persona questions
+        system_prompt = f"""You are a property agent assistant. Determine if the user is showing interest in finding a property and needs persona questions asked.
+
+Current conversation context: "{conversation_context}"
+
+Available persona fields to ask about: {missing_fields}
+
+Rules:
+- If the user is just greeting (hi, hello, etc.) → return "no"
+- If the user is asking about properties, locations, business needs, or showing interest in finding space → return "yes"
+- If the user mentions locations (including abbreviations like cpt, pta, jhb) → return "yes"
+- If the user mentions business types (clothing, manufacturing, etc.) → return "yes"
+
+Return ONLY "yes" or "no"."""
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": conversation_context}
+        ]
+        
+        response = llm.invoke(messages)
+        should_ask = response.content.strip().lower() == "yes"
+        
+        if should_ask:
+            return True, missing_fields[0]
+        else:
+            return False, None
+            
+    except Exception as e:
+        print(f"Error in AI persona question detection: {e}")
         return False, None
-    
-    # Only ask if user is actively searching for properties
-    if is_searching:
-        return True, missing_fields[0]
-    
-    return False, None
 
 def get_persona_summary(persona: Dict) -> str:
     """Get a human-readable summary of the user's persona"""
@@ -372,4 +392,62 @@ def get_persona_summary(persona: Dict) -> str:
     if summary_parts:
         return " | ".join(summary_parts)
     else:
-        return "New user - profile incomplete" 
+        return "New user - profile incomplete" 
+
+async def extract_persona_from_message(user_message: str, current_persona: Dict) -> Dict:
+    """
+    Proactively extract persona fields from any user message using AI
+    Returns: dict of field -> value for any fields that can be extracted
+    """
+    if not OPENAI_API_KEY:
+        return {}
+    
+    try:
+        # Create a comprehensive prompt for AI extraction
+        system_prompt = """You are a property agent assistant. Extract any persona information from the user's message.
+
+Available persona fields:
+- intent: "buy" or "lease" (extract from words like buy, purchase, own, lease, rent)
+- location_preference: Extract location names, including abbreviations (e.g., "cpt" = "cape town", "jhb" = "johannesburg", "pta" = "pretoria")
+- budget: Extract numeric values with currency/budget indicators (e.g., "500k" = 500000, "$1m" = 1000000)
+- size_preference_sqm: Extract size in square meters (convert from sq ft if needed)
+- must_have: Extract features as array (e.g., ["truck access", "office space"])
+
+Return ONLY a JSON object with the extracted fields. Only include fields that are clearly mentioned or implied.
+If no relevant information is found for a field, don't include it in the response.
+
+Examples:
+- "I want a property in cpt" → {"location_preference": "cape town"}
+- "Looking for warehouse in pta around 500k" → {"location_preference": "pretoria", "budget": 500000}
+- "Need space for clothing business with office" → {"must_have": ["office"]}
+"""
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_message}
+        ]
+        
+        response = llm.invoke(messages)
+        
+        # Parse the JSON response
+        import json
+        try:
+            extracted = json.loads(response.content)
+            
+            # Validate and clean the extracted data
+            cleaned_extracted = {}
+            
+            # Only include fields that aren't already set in current_persona
+            for field, value in extracted.items():
+                if field in PERSONA_FIELDS and not current_persona.get(field) and value is not None:
+                    cleaned_extracted[field] = value
+            
+            return cleaned_extracted
+            
+        except json.JSONDecodeError:
+            print(f"Failed to parse AI extraction response: {response.content}")
+            return {}
+            
+    except Exception as e:
+        print(f"Error in AI persona extraction: {e}")
+        return {}