user personas

ai_chat.py

@@ -3,14 +3,25 @@ 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
+from persona_manager import (
+    get_or_create_persona, 
+    should_ask_persona_question, 
+    parse_user_response, 
+    update_persona_field,
+    PERSONA_FIELDS,
+    get_persona_summary
+)
 
 def chat_with_session_memory(state):
-    """Chat function with session-based memory"""
+    """Chat function with session-based memory and persona collection"""
     user_message = state["user_message"]
     user_info = state.get("user_info", {})
     session_id = state.get("session_id")
     wa_id = state.get("wa_id")
     wamid = state.get("wamid")
+    persona = state.get("persona", {})
+    is_persona_question = state.get("is_persona_question", False)
+    current_field = state.get("current_field")
     
     # Get conversation history from database
     session_messages = []
@@ -18,15 +29,68 @@ def chat_with_session_memory(state):
         # This will be populated by the async wrapper
         session_messages = state.get("session_messages", [])
     
-    # Add system message with user context
-    system_message = "You are a helpful and concise assistant."
+    # Check if we should handle persona collection
+    if is_persona_question and current_field:
+        # Handle persona question response
+        is_valid, parsed_value, response_message = state.get("parsed_response", (False, None, ""))
+        
+        if is_valid:
+            # Update persona in database (handled by async wrapper)
+            return {
+                "response": response_message,
+                "user_message": user_message,
+                "ai_response": response_message,
+                "session_id": session_id,
+                "wa_id": wa_id,
+                "wamid": wamid,
+                "update_persona": True,
+                "persona_field": current_field,
+                "persona_value": parsed_value
+            }
+        else:
+            # Invalid response, ask for clarification or re-ask
+            return {
+                "response": response_message,
+                "user_message": user_message,
+                "ai_response": response_message,
+                "session_id": session_id,
+                "wa_id": wa_id,
+                "wamid": wamid,
+                "ask_persona_question": True,
+                "current_field": current_field
+            }
+    
+    # Regular conversation - check if we should ask persona questions
+    should_ask, field_to_ask = state.get("persona_check", (False, None))
+    
+    if should_ask and field_to_ask:
+        # Ask persona question
+        question = PERSONA_FIELDS[field_to_ask]["prompt"]
+        return {
+            "response": question,
+            "user_message": user_message,
+            "ai_response": question,
+            "session_id": session_id,
+            "wa_id": wa_id,
+            "wamid": wamid,
+            "ask_persona_question": True,
+            "current_field": field_to_ask
+        }
+    
+    # Add system message with user context and persona
+    system_message = "You are a helpful industrial property agent assistant."
     if user_info.get("name") and user_info["name"] != "Unknown":
         system_message += f" The user's name is {user_info['name']}."
     
+    # Add persona context if available
+    persona_summary = get_persona_summary(persona)
+    if persona_summary != "New user - profile incomplete":
+        system_message += f" User profile: {persona_summary}. Use this information to provide relevant property advice."
+    
     # Build messages array with history
     messages = [{"role": "system", "content": system_message}]
     
-    # Add conversation history (last 10 messages)
+    # Add conversation history (last 30 messages)
     for msg in session_messages[-30:]:
         messages.append({"role": msg["role"], "content": msg["content"]})
     
@@ -61,6 +125,15 @@ class ChatState(TypedDict):
     wa_id: str
     wamid: str
     session_messages: list
+    persona: dict
+    is_persona_question: bool
+    current_field: str
+    parsed_response: tuple
+    persona_check: tuple
+    update_persona: bool
+    persona_field: str
+    persona_value: any
+    ask_persona_question: bool
 
 # --- Build LangGraph ---
 graph = StateGraph(ChatState)
@@ -70,14 +143,37 @@ 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):
-    """Process a message through the AI chat system with session memory"""
+    """Process a message through the AI chat system with session memory and persona collection"""
     if user_info is None:
         user_info = {}
     
+    # Get user persona
+    persona = await get_or_create_persona(wa_id) if wa_id else {}
+    
     # Get session messages for context
     session_messages = []
     if session_id:
-        session_messages = await get_session_messages(session_id, limit=10)
+        session_messages = await get_session_messages(session_id, limit=30)
+    
+    # Check if we should ask persona questions
+    conversation_context = " ".join([msg["content"] for msg in session_messages[-5:]]) + " " + user_message
+    should_ask, field_to_ask = await should_ask_persona_question(persona, conversation_context)
+    
+    # Check if this is a response to a persona question
+    is_persona_question = False
+    current_field = None
+    parsed_response = (False, None, "")
+    
+    # Check if the last AI message was a persona question
+    if session_messages and session_messages[-1]["role"] == "assistant":
+        last_ai_message = session_messages[-1]["content"]
+        for field, field_info in PERSONA_FIELDS.items():
+            if field_info["prompt"] in last_ai_message:
+                is_persona_question = True
+                current_field = field
+                # Parse user response
+                parsed_response = await parse_user_response(user_message, field)
+                break
     
     # Process with AI
     result = await chat_graph.ainvoke({
@@ -86,9 +182,18 @@ async def process_message(user_message: str, user_info: dict = None, session_id:
         "session_id": session_id,
         "wa_id": wa_id,
         "wamid": wamid,
-        "session_messages": session_messages
+        "session_messages": session_messages,
+        "persona": persona,
+        "is_persona_question": is_persona_question,
+        "current_field": current_field,
+        "parsed_response": parsed_response,
+        "persona_check": (should_ask, field_to_ask)
     })
     
+    # Handle persona updates
+    if result.get("update_persona") and wa_id:
+        await update_persona_field(wa_id, result["persona_field"], result["persona_value"])
+    
     # Save messages to database
     if session_id and wa_id and wamid:
         await save_message(session_id, wa_id, wamid, "user", user_message)

api_routes.py

@@ -7,6 +7,7 @@ from datetime import datetime
 from config import VERIFY_TOKEN, supabase, OPENAI_API_KEY, WHATSAPP_API_TOKEN
 from database import get_user, list_users, update_user_name
 from ai_chat import process_message
+from persona_manager import get_user_persona, get_persona_summary, update_persona_field
 
 router = APIRouter()
 
@@ -84,4 +85,36 @@ async def update_user_endpoint(wa_id: str, name: str):
     if user:
         return user
     else:
-        raise HTTPException(status_code=404, detail="User not found") 
+        raise HTTPException(status_code=404, detail="User not found")
+
+# --- Persona Management Endpoints ---
+@router.get("/personas/{wa_id}")
+async def get_persona_endpoint(wa_id: str):
+    """Get user persona by WhatsApp ID"""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not configured")
+    
+    persona = await get_user_persona(wa_id)
+    if persona:
+        return {
+            **persona,
+            "summary": get_persona_summary(persona)
+        }
+    else:
+        raise HTTPException(status_code=404, detail="Persona not found")
+
+@router.put("/personas/{wa_id}")
+async def update_persona_endpoint(wa_id: str, field: str, value: str):
+    """Update a specific persona field"""
+    if not supabase:
+        raise HTTPException(status_code=503, detail="Database not configured")
+    
+    success = await update_persona_field(wa_id, field, value)
+    if success:
+        persona = await get_user_persona(wa_id)
+        return {
+            **persona,
+            "summary": get_persona_summary(persona)
+        }
+    else:
+        raise HTTPException(status_code=404, detail="Persona not found") 

persona_manager.py

@@ -0,0 +1,284 @@
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+from config import supabase, llm, OPENAI_API_KEY
+
+# Persona field definitions and their collection prompts
+PERSONA_FIELDS = {
+    "intent": {
+        "prompt": "Are you looking to buy a place, or maybe lease for now?",
+        "clarification": "Great question. Buying gives you long-term control, but leasing gives flexibility. Happy to guide you either way.",
+        "skip_response": "No problem at all. We can always revisit that later."
+    },
+    "location_preference": {
+        "prompt": "Any specific areas you'd prefer to be based in?",
+        "clarification": "I can help you find properties in any area. Just let me know what locations work best for you.",
+        "skip_response": "No problem at all. We can always revisit that later."
+    },
+    "size_preference_sqm": {
+        "prompt": "Do you have a rough size in mind? For example, 1500 or 3000 sqm?",
+        "clarification": "Size can vary a lot - from small workshops to large warehouses. What kind of space do you need?",
+        "skip_response": "No problem at all. We can always revisit that later."
+    },
+    "budget": {
+        "prompt": "Is there a budget you'd like me to work within?",
+        "clarification": "Budget helps me find the right properties for you. We can discuss options at any price point.",
+        "skip_response": "No problem at all. We can always revisit that later."
+    },
+    "must_have": {
+        "prompt": "Anything important that's a must-have? Like truck access or yard space?",
+        "clarification": "Must-haves are features you really need, like loading docks, high ceilings, or specific zoning.",
+        "skip_response": "No problem at all. We can always revisit that later."
+    }
+}
+
+async def get_user_persona(wa_id: str) -> Optional[Dict]:
+    """Get user persona from database"""
+    if not supabase:
+        return None
+    
+    try:
+        response = supabase.table("user_personas").select("*").eq("wa_id", wa_id).execute()
+        return response.data[0] if response.data else None
+    except Exception as e:
+        print(f"Error getting user persona: {e}")
+        return None
+
+async def create_user_persona(wa_id: str) -> Dict:
+    """Create a new user persona"""
+    if not supabase:
+        return {"wa_id": wa_id, "language": "English", "tone": "neutral"}
+    
+    try:
+        new_persona = {
+            "wa_id": wa_id,
+            "language": "English",
+            "tone": "neutral",
+            "created_at": datetime.utcnow().isoformat(),
+            "updated_at": datetime.utcnow().isoformat()
+        }
+        response = supabase.table("user_personas").insert(new_persona).execute()
+        return response.data[0] if response.data else new_persona
+    except Exception as e:
+        print(f"Error creating user persona: {e}")
+        return {"wa_id": wa_id, "language": "English", "tone": "neutral"}
+
+async def update_persona_field(wa_id: str, field: str, value) -> bool:
+    """Update a specific field in user persona"""
+    if not supabase:
+        return False
+    
+    try:
+        update_data = {
+            field: value,
+            "updated_at": datetime.utcnow().isoformat()
+        }
+        supabase.table("user_personas").update(update_data).eq("wa_id", wa_id).execute()
+        return True
+    except Exception as e:
+        print(f"Error updating persona field {field}: {e}")
+        return False
+
+async def get_or_create_persona(wa_id: str) -> Dict:
+    """Get existing persona or create new one"""
+    persona = await get_user_persona(wa_id)
+    if persona:
+        return persona
+    else:
+        return await create_user_persona(wa_id)
+
+def get_missing_fields(persona: Dict) -> List[str]:
+    """Get list of missing persona fields"""
+    missing = []
+    for field in PERSONA_FIELDS.keys():
+        if not persona.get(field):
+            missing.append(field)
+    return missing
+
+def get_next_field_to_ask(persona: Dict) -> Optional[str]:
+    """Get the next field to ask about"""
+    missing = get_missing_fields(persona)
+    return missing[0] if missing else None
+
+async def parse_user_response(user_message: str, field: str) -> Tuple[bool, any, str]:
+    """
+    Parse user response for a specific field
+    Returns: (is_valid, parsed_value, response_message)
+    """
+    if not OPENAI_API_KEY:
+        return False, None, "Sorry, I can't process that right now."
+    
+    try:
+        # Create a structured prompt for parsing
+        system_prompt = f"""You are a property agent assistant. Parse the user's response for the field '{field}'.
+        
+        Field: {field}
+        Field description: {PERSONA_FIELDS[field]['prompt']}
+        
+        Parse the user's response and return ONLY a JSON object with these fields:
+        - "is_valid": boolean (true if user provided a valid answer)
+        - "value": the parsed value (null if invalid/not provided)
+        - "response": string message to send back to user
+        - "is_clarification": boolean (true if user asked for clarification)
+        - "is_skip": boolean (true if user wants to skip this question)
+        
+        Rules:
+        - For intent: accept "buy", "lease", "rent", "purchase", "own"
+        - For budget: extract numeric values (e.g., "around 500k" -> 500000)
+        - For size: extract square meters (e.g., "1500 sqm" -> 1500)
+        - For location: extract location names
+        - For must_have: extract features as array (e.g., ["truck access", "yard space"])
+        - If user asks for clarification, set is_clarification=true
+        - If user says "not sure", "skip", "later", set is_skip=true
+        """
+        
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_message}
+        ]
+        
+        response = llm.invoke(messages)
+        
+        # Try to parse the JSON response
+        import json
+        try:
+            result = json.loads(response.content)
+            return (
+                result.get("is_valid", False),
+                result.get("value"),
+                result.get("response", "I understand. Let me know if you need anything else.")
+            )
+        except json.JSONDecodeError:
+            # Fallback parsing
+            return await fallback_parse_response(user_message, field)
+            
+    except Exception as e:
+        print(f"Error parsing user response: {e}")
+        return False, None, "I didn't quite catch that. Could you rephrase?"
+
+async def fallback_parse_response(user_message: str, field: str) -> Tuple[bool, any, str]:
+    """Fallback parsing when LLM parsing fails"""
+    user_message_lower = user_message.lower()
+    
+    # Check for clarification requests
+    clarification_words = ["what", "how", "explain", "difference", "mean", "clarify"]
+    if any(word in user_message_lower for word in clarification_words):
+        return False, None, PERSONA_FIELDS[field]["clarification"]
+    
+    # Check for skip requests
+    skip_words = ["not sure", "skip", "later", "don't know", "maybe later"]
+    if any(word in user_message_lower for word in skip_words):
+        return True, None, PERSONA_FIELDS[field]["skip_response"]
+    
+    # Basic field-specific parsing
+    if field == "intent":
+        if any(word in user_message_lower for word in ["buy", "purchase", "own"]):
+            return True, "buy", "Got it, you're looking to buy. That's great!"
+        elif any(word in user_message_lower for word in ["lease", "rent"]):
+            return True, "lease", "Perfect, leasing gives you flexibility."
+    
+    elif field == "budget":
+        import re
+        numbers = re.findall(r'\d+', user_message)
+        if numbers:
+            # Assume the largest number is the budget
+            budget = max(int(n) for n in numbers)
+            if "k" in user_message_lower or "thousand" in user_message_lower:
+                budget *= 1000
+            elif "m" in user_message_lower or "million" in user_message_lower:
+                budget *= 1000000
+            return True, budget, f"Thanks! I'll look for properties around ${budget:,}."
+    
+    elif field == "size_preference_sqm":
+        import re
+        numbers = re.findall(r'\d+', user_message)
+        if numbers:
+            size = max(int(n) for n in numbers)
+            return True, size, f"Perfect! {size} sqm should give you good options."
+    
+    elif field == "location_preference":
+        # Extract location names (basic approach)
+        locations = ["downtown", "suburb", "industrial", "warehouse district"]
+        found_location = None
+        for loc in locations:
+            if loc in user_message_lower:
+                found_location = loc
+                break
+        
+        if found_location:
+            return True, found_location, f"Great! {found_location.title()} has good options."
+        else:
+            # Assume the whole message is a location
+            return True, user_message.strip(), f"Got it! I'll look in {user_message.strip()}."
+    
+    elif field == "must_have":
+        features = []
+        feature_keywords = {
+            "truck": ["truck", "loading", "dock"],
+            "yard": ["yard", "space", "outdoor"],
+            "office": ["office", "admin"],
+            "parking": ["parking", "car"],
+            "high_ceiling": ["ceiling", "height", "tall"]
+        }
+        
+        for feature, keywords in feature_keywords.items():
+            if any(keyword in user_message_lower for keyword in keywords):
+                features.append(feature)
+        
+        if features:
+            return True, features, f"Perfect! I'll make sure to find places with {', '.join(features)}."
+    
+    return False, None, "I didn't quite understand. Could you try again?"
+
+async def should_ask_persona_question(persona: Dict, conversation_context: str = "") -> Tuple[bool, Optional[str]]:
+    """
+    Determine if we should ask a persona question
+    Returns: (should_ask, field_to_ask)
+    """
+    # Check if persona is complete
+    missing_fields = get_missing_fields(persona)
+    
+    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"
+    ]
+    
+    conversation_lower = conversation_context.lower()
+    is_searching = any(indicator in conversation_lower for indicator in search_indicators)
+    
+    # If user is actively searching, ask persona questions
+    if is_searching:
+        return True, missing_fields[0]
+    
+    # If this is a new user (no fields filled), ask the first question
+    if len(missing_fields) == len(PERSONA_FIELDS):
+        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"""
+    summary_parts = []
+    
+    if persona.get("intent"):
+        summary_parts.append(f"Looking to {persona['intent']}")
+    
+    if persona.get("location_preference"):
+        summary_parts.append(f"in {persona['location_preference']}")
+    
+    if persona.get("size_preference_sqm"):
+        summary_parts.append(f"around {persona['size_preference_sqm']} sqm")
+    
+    if persona.get("budget"):
+        summary_parts.append(f"budget ~${persona['budget']:,}")
+    
+    if persona.get("must_have"):
+        summary_parts.append(f"must have: {', '.join(persona['must_have'])}")
+    
+    if summary_parts:
+        return " | ".join(summary_parts)
+    else:
+        return "New user - profile incomplete" 

supabase_setup.sql

@@ -26,6 +26,20 @@ CREATE TABLE IF NOT EXISTS messages (
     created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
 );
 
+-- Create user_personas table
+CREATE TABLE IF NOT EXISTS user_personas (
+    wa_id TEXT PRIMARY KEY REFERENCES users(wa_id) ON DELETE CASCADE,
+    language TEXT DEFAULT 'English',
+    tone TEXT DEFAULT 'neutral',
+    intent TEXT,
+    budget NUMERIC,
+    size_preference_sqm INTEGER,
+    location_preference TEXT,
+    must_have TEXT[],
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
 -- Create indexes for better query performance
 CREATE INDEX IF NOT EXISTS idx_users_created_at ON users(created_at DESC);
 CREATE INDEX IF NOT EXISTS idx_users_updated_at ON users(updated_at DESC);
@@ -36,11 +50,14 @@ CREATE INDEX IF NOT EXISTS idx_messages_session_id ON messages(session_id);
 CREATE INDEX IF NOT EXISTS idx_messages_wa_id ON messages(wa_id);
 CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at DESC);
 CREATE INDEX IF NOT EXISTS idx_messages_wamid ON messages(wamid);
+CREATE INDEX IF NOT EXISTS idx_user_personas_intent ON user_personas(intent);
+CREATE INDEX IF NOT EXISTS idx_user_personas_location ON user_personas(location_preference);
 
 -- Enable Row Level Security (RLS) - optional but recommended
 ALTER TABLE users ENABLE ROW LEVEL SECURITY;
 ALTER TABLE chat_sessions ENABLE ROW LEVEL SECURITY;
 ALTER TABLE messages ENABLE ROW LEVEL SECURITY;
+ALTER TABLE user_personas ENABLE ROW LEVEL SECURITY;
 
 -- Create policies to allow all operations (you can restrict this based on your needs)
 CREATE POLICY "Allow all operations on users" ON users
@@ -52,6 +69,9 @@ CREATE POLICY "Allow all operations on chat_sessions" ON chat_sessions
 CREATE POLICY "Allow all operations on messages" ON messages
     FOR ALL USING (true);
 
+CREATE POLICY "Allow all operations on user_personas" ON user_personas
+    FOR ALL USING (true);
+
 -- Optional: Create a function to automatically update the updated_at timestamp
 CREATE OR REPLACE FUNCTION update_updated_at_column()
 RETURNS TRIGGER AS $$
@@ -79,4 +99,10 @@ $$ language 'plpgsql';
 CREATE TRIGGER update_chat_sessions_last_activity 
     BEFORE UPDATE ON chat_sessions 
     FOR EACH ROW 
-    EXECUTE FUNCTION update_last_activity_column(); 
+    EXECUTE FUNCTION update_last_activity_column();
+
+-- Create trigger to automatically update updated_at for user_personas
+CREATE TRIGGER update_user_personas_updated_at 
+    BEFORE UPDATE ON user_personas 
+    FOR EACH ROW 
+    EXECUTE FUNCTION update_updated_at_column();