fyp

app/ai/config.py

@@ -99,7 +99,7 @@ except Exception as e:
 try:
     from app.ai.tools.intent_detector_tool import process_user_message
     from app.ai.tools.listing_tool import process_listing
-    from app.ai.tools.casual_chat_tool import process_casual_chat
+    from app.ai.tools.casual_chat_tool import process_casual_chat, casual_chat_handler
     from app.ai.tools.greeting_tool import process_greeting, is_greeting  # ✅ Now AI-powered & async!
     
     logger.info("✅ All Aida tools imported successfully")

app/ai/tools/casual_chat_tool.py

@@ -1,170 +1,172 @@
-# app/ai/agent/nodes/casual_chat.py
-"""
-Node: Handle casual conversation with proper state transitions
-FIXED: Transitions to IDLE instead of COMPLETE to allow conversation continuation
-"""
+# app/ai/tools/casual_chat_tool.py
+# FIXED: Added process_casual_chat function for backward compatibility
 
+from typing import Dict, Optional
 from structlog import get_logger
 from langchain_openai import ChatOpenAI
-from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
 
-from app.ai.agent.state import AgentState, FlowState
-from app.ai.agent.validators import ResponseValidator
-from app.ai.prompts.system_prompt import get_system_prompt
 from app.config import settings
+from app.ai.prompts.system_prompt import get_system_prompt
 
 logger = get_logger(__name__)
 
-# Initialize LLM for casual conversation
+# INITIALIZE LLM
 llm = ChatOpenAI(
     api_key=settings.DEEPSEEK_API_KEY,
     base_url=settings.DEEPSEEK_BASE_URL,
     model="deepseek-chat",
-    temperature=0.8,  # Higher temp for more natural conversation
+    temperature=0.8,
+    max_tokens=500,
 )
 
-def build_conversation_context(state: AgentState) -> str:
-    """
-    Build conversation context from history.
-    
-    Args:
-        state: Agent state with conversation history
-    
-    Returns:
-        Formatted conversation history string
-    """
-    
-    messages = state.conversation_history[-6:]  # Last 6 messages for context
-    
-    if not messages:
-        return "(New conversation)"
+# PROMPT TEMPLATE
+CASUAL_CHAT_PROMPT = ChatPromptTemplate.from_messages([
+    ("system", "{system_prompt}"),
+    ("human", "{input}"),
+])
+
+# MEMORY MANAGEMENT (simplified without deprecated classes)
+def create_chat_history(conversation_history: list = None) -> str:
+    """Convert conversation history to formatted string"""
+    if not conversation_history:
+        return ""
     
     formatted = []
-    for msg in messages:
-        role = "User" if msg["role"] == "user" else "Aida"
-        content = msg["content"]
+    for msg in conversation_history[-10:]:  # Last 10 messages for context
+        role = "Aida" if msg.get("role") == "assistant" else "You"
+        content = msg.get("content", "")
         formatted.append(f"{role}: {content}")
     
     return "\n".join(formatted)
 
-async def casual_chat_handler(state: AgentState) -> AgentState:
+# BACKWARD COMPATIBILITY: Keep the old function name for config.py imports
+async def process_casual_chat(
+    user_message: str,
+    user_id: str,
+    user_role: str = "renter",
+    conversation_history: list = None,
+) -> Dict:
     """
-    Handle casual conversation with proper state transitions.
-    
-    FIXED: Transitions to IDLE instead of COMPLETE to allow conversation continuation
+    Process casual chat message using LangChain LCEL (modern approach).
+    This function maintains backward compatibility with the old import.
     
     Args:
-        state: Agent state
+        user_message: What user said
+        user_id: User ID
+        user_role: User's role (landlord or renter)
+        conversation_history: Previous messages in conversation
     
     Returns:
-        Updated state
+        {
+            "success": bool,
+            "action": "casual_chat",
+            "reply": str (Aida's response),
+            "state": dict
+        }
     """
     
     logger.info(
-        "Handling casual chat",
-        user_id=state.user_id,
-        message=state.last_user_message[:50]
+        "Processing casual chat with LangChain LCEL",
+        user_id=user_id,
+        message_len=len(user_message)
     )
     
     try:
-        # ============================================================
-        # STEP 1: Build conversation context
-        # ============================================================
-        
-        conv_context = build_conversation_context(state)
-        
-        logger.info("Conversation context built", context_len=len(conv_context))
-        
-        # ============================================================
-        # STEP 2: Get system prompt
-        # ============================================================
-        
-        system_prompt = get_system_prompt(user_role=state.user_role)
-        
-        logger.info("System prompt loaded", user_role=state.user_role)
-        
-        # ============================================================
-        # STEP 3: Build chat prompt with context
-        # ============================================================
-        
-        chat_prompt = f"""{system_prompt}
-
-CONVERSATION HISTORY:
-{conv_context}
-
-CURRENT USER MESSAGE: {state.last_user_message}
-
-Respond naturally and helpfully. Keep your response conversational and friendly (2-3 sentences max)."""
-        
-        # ============================================================
-        # STEP 4: Call LLM for response
-        # ============================================================
-        
-        response = await llm.ainvoke([
-            SystemMessage(content="You are AIDA, a warm and helpful real estate AI assistant. Respond naturally to user questions."),
-            HumanMessage(content=chat_prompt)
-        ])
+        # Get system prompt
+        system_prompt = get_system_prompt(user_role=user_role)
         
-        response_text = response.content if hasattr(response, 'content') else str(response)
+        # Format conversation history
+        chat_history = create_chat_history(conversation_history)
         
-        logger.info("LLM response generated", response_len=len(response_text))
+        # Create LCEL chain (modern approach)
+        chain = CASUAL_CHAT_PROMPT | llm
         
-        # ============================================================
-        # STEP 5: Validate response
-        # ============================================================
+        # Prepare context
+        context = {
+            "system_prompt": system_prompt,
+            "input": user_message,
+            "chat_history": chat_history
+        }
         
-        is_valid, cleaned_text, error = ResponseValidator.validate_response_text(response_text)
+        # Run chain
+        response = await chain.ainvoke(context)
         
-        if not is_valid:
-            logger.warning("Response validation failed", error=error)
-            # Use fallback
-            cleaned_text = "I'm here to help with real estate questions. What would you like to know?"
+        # Extract text from response
+        if hasattr(response, 'content'):
+            aida_reply = response.content.strip()
         else:
-            # Sanitize
-            cleaned_text = ResponseValidator.sanitize_response(cleaned_text)
-        
-        logger.info("Response validated", text_len=len(cleaned_text))
-        
-        # ============================================================
-        # STEP 6: Store in state
-        # ============================================================
-        
-        state.temp_data["response_text"] = cleaned_text
-        state.temp_data["action"] = "casual_chat"
-        
-        logger.info("Response stored in state", user_id=state.user_id)
-        
-        # ============================================================
-        # STEP 7: ✅ FIXED - Transition to IDLE (not COMPLETE!)
-        # ============================================================
-        
-        success, error = state.transition_to(FlowState.IDLE, reason="Casual chat completed, ready for next interaction")
-        
-        if not success:
-            logger.error("Transition to IDLE failed", error=error)
-            state.set_error(error, should_retry=False)
-            return state
+            aida_reply = str(response).strip()
         
         logger.info(
-            "Casual chat completed",
-            user_id=state.user_id,
-            steps=state.steps_taken
+            "Casual chat response generated",
+            reply_len=len(aida_reply)
         )
         
-        return state
+        return {
+            "success": True,
+            "action": "casual_chat",
+            "reply": aida_reply,
+            "state": {
+                "status": "chatting",
+                "last_message_type": "casual_chat",
+            }
+        }
     
     except Exception as e:
         logger.error("Casual chat error", exc_info=e)
-        error_msg = f"Chat error: {str(e)}"
         
-        # Set fallback response
-        state.temp_data["response_text"] = "Sorry, I had a moment there! What were you saying?"
-        state.temp_data["action"] = "casual_chat"
+        fallback_reply = "Sorry, I had a moment there! What were you saying?"
+        
+        return {
+            "success": False,
+            "action": "casual_chat",
+            "reply": fallback_reply,
+            "state": {
+                "status": "chatting",
+                "last_message_type": "casual_chat",
+                "error": str(e)
+            }
+        }
+
+# For LangGraph compatibility - the new function name
+async def casual_chat_handler(user_message: str, user_id: str, user_role: str = "renter", conversation_history: list = None) -> Dict:
+    """
+    LangGraph-compatible version of casual chat processing
+    Just calls the process_casual_chat function
+    """
+    return await process_casual_chat(
+        user_message=user_message,
+        user_id=user_id,
+        user_role=user_role,
+        conversation_history=conversation_history
+    )
+
+# TEST FUNCTION
+async def test():
+    """Test the LangChain chat"""
+    
+    test_messages = [
+        "Hi, how are you?",
+        "Who created you?",
+        "What's the weather like?",
+        "Can you help me list my apartment?",
+    ]
+    
+    print("\nTesting LangChain Casual Chat\n" + "="*70 + "\n")
+    
+    for message in test_messages:
+        print(f"User: {message}")
         
-        # Try to recover
-        if state.set_error(error_msg, should_retry=True):
-            state.transition_to(FlowState.IDLE, reason="Chat with error recovery")
-        else:
-            state.transition_to(FlowState.ERROR, reason="Casual chat error")
+        result = await process_casual_chat(
+            user_message=message,
+            user_id="test_user",
+            user_role="landlord"
+        )
         
-        return state
+        print(f"Aida: {result['reply']}\n")
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(test())