Upload 36 files

hybrid_chat_endpoint.py

@@ -5,21 +5,25 @@ Routes between scripted scenarios and knowledge retrieval
 from fastapi import HTTPException
 from datetime import datetime
 from typing import Dict, Any
-import json
+
+# Import scenario handlers
+from scenario_handlers.price_inquiry import PriceInquiryHandler
+from scenario_handlers.event_recommendation import EventRecommendationHandler
+from scenario_handlers.post_event_feedback import PostEventFeedbackHandler
+from scenario_handlers.exit_intent_rescue import ExitIntentRescueHandler
 
 
 async def hybrid_chat_endpoint(
     request,  # ChatRequest
     conversation_service,
     intent_classifier,
-    scenario_engine,
+    embedding_service,  # For handlers
+    qdrant_service,     # For handlers
     tools_service,
     advanced_rag,
-    embedding_service,
-    qdrant_service,
     chat_history_collection,
     hf_token,
-    lead_storage  # NEW: For saving customer leads
+    lead_storage
 ):
     """
     Hybrid conversational chatbot: Scenario FSM + RAG
@@ -28,7 +32,7 @@ async def hybrid_chat_endpoint(
     1. Load session & scenario state
     2. Classify intent (scenario vs RAG)
     3. Route:
-       - Scenario: Execute FSM flow
+       - Scenario: Execute FSM flow with dedicated handlers
        - RAG: Knowledge retrieval
        - RAG+Resume: Answer question then resume scenario
     4. Save state & history
@@ -55,16 +59,16 @@ async def hybrid_chat_endpoint(
         
         # ===== ROUTING =====
         if intent.startswith("scenario:"):
-            # Route to scenario engine
+            # Route to dedicated scenario handler
             response_data = await handle_scenario(
                 intent,
                 request.message,
                 session_id,
                 scenario_state,
-                scenario_engine,
+                embedding_service,
+                qdrant_service,
                 conversation_service,
-                advanced_rag,
-                lead_storage  # NEW: Pass for action handling
+                lead_storage
             )
         
         elif intent == "rag:with_resume":
@@ -73,7 +77,6 @@ async def hybrid_chat_endpoint(
                 request,
                 session_id,
                 scenario_state,
-                advanced_rag,
                 embedding_service,
                 qdrant_service,
                 conversation_service
@@ -107,7 +110,7 @@ async def hybrid_chat_endpoint(
             response_data["response"],
             metadata={
                 "mode": response_data.get("mode", "unknown"),
-                "context_used": response_data.get("context_used", [])[:3]  # Limit size
+                "context_used": response_data.get("context_used", [])[:3]
             }
         )
         
@@ -129,71 +132,75 @@ async def handle_scenario(
     user_message,
     session_id,
     scenario_state,
-    scenario_engine,
+    embedding_service,
+    qdrant_service,
     conversation_service,
-    advanced_rag,
-    lead_storage=None
+    lead_storage
 ):
-    """Handle scenario-based conversation"""
+    """
+    Handle scenario-based conversation using dedicated handlers
+    
+    Replaces old scenario_engine with per-scenario handlers
+    """
+    
+    # Initialize all scenario handlers
+    handlers = {
+        'price_inquiry': PriceInquiryHandler(embedding_service, qdrant_service, lead_storage),
+        'event_recommendation': EventRecommendationHandler(embedding_service, qdrant_service, lead_storage),
+        'post_event_feedback': PostEventFeedbackHandler(embedding_service, qdrant_service, lead_storage),
+        'exit_intent_rescue': ExitIntentRescueHandler(embedding_service, qdrant_service, lead_storage)
+    }
     
     if intent == "scenario:continue":
         # Continue existing scenario
-        result = scenario_engine.next_step(
-            scenario_id=scenario_state["active_scenario"],
-            current_step=scenario_state["scenario_step"],
+        scenario_id = scenario_state.get("active_scenario")
+        
+        if scenario_id not in handlers:
+            return {
+                "response": f"Xin lỗi, scenario '{scenario_id}' không tồn tại.",
+                "mode": "error",
+                "scenario_active": False
+            }
+        
+        handler = handlers[scenario_id]
+        result = handler.next_step(
+            current_step=scenario_state.get("scenario_step", 1),
             user_input=user_message,
-            scenario_data=scenario_state.get("scenario_data", {}),
-            rag_service=advanced_rag
+            scenario_data=scenario_state.get("scenario_data", {})
         )
     else:
         # Start new scenario
         scenario_type = intent.split(":", 1)[1]
-        result = scenario_engine.start_scenario(scenario_type)
+        
+        if scenario_type not in handlers:
+            return {
+                "response": f"Xin lỗi, scenario '{scenario_type}' không tồn tại.",
+                "mode": "error",
+                "scenario_active": False
+            }
+        
+        handler = handlers[scenario_type]
+        
+        # Get initial_data from scenario_state (if any)
+        initial_data = scenario_state.get("scenario_data", {})
+        result = handler.start(initial_data=initial_data)
     
     # Update scenario state
-    if result.get("end_scenario"):
+    if result.get("end_scenario") or not result.get("scenario_active", True):
         conversation_service.clear_scenario(session_id)
         scenario_active = False
-    else:
+    elif result.get("new_state"):
         conversation_service.set_scenario_state(session_id, result["new_state"])
         scenario_active = True
-    
-    # Execute action if any
-    if result.get("action") and lead_storage:
-        action = result['action']
-        scenario_data = result.get('new_state', {}).get('scenario_data', scenario_state.get('scenario_data', {}))
-        
-        if action == "send_pdf_email":
-            # Save lead with email
-            lead_storage.save_lead(
-                event_name=scenario_data.get('step_1_input', 'Unknown Event'),
-                email=scenario_data.get('step_5_input'),  # Email from step 5
-                interests={
-                    "group": scenario_data.get('group_size'),
-                    "wants_pdf": True
-                },
-                session_id=session_id
-            )
-            print(f"📧 Lead saved: email sent (saved to DB)")
-        
-        elif action == "save_lead_phone":
-            # Save lead with phone
-            lead_storage.save_lead(
-                event_name=scenario_data.get('step_1_input', 'Unknown Event'),
-                email=scenario_data.get('step_5_input'),
-                phone=scenario_data.get('step_8_input'),  # Phone from step 8
-                interests={
-                    "group": scenario_data.get('group_size'),
-                    "wants_reminder": True
-                },
-                session_id=session_id
-            )
-            print(f"📱 Lead saved: SMS reminder (saved to DB)")
+    else:
+        # new_state is None → stay at same step (e.g., validation failed)
+        scenario_active = True
     
     return {
-        "response": result["message"],
+        "response": result.get("message", ""),
         "mode": "scenario",
-        "scenario_active": scenario_active
+        "scenario_active": scenario_active,
+        "loading_message": result.get("loading_message")  # For UI
     }
 
 
@@ -201,7 +208,6 @@ async def handle_rag_with_resume(
     request,
     session_id,
     scenario_state,
-    advanced_rag,
     embedding_service,
     qdrant_service,
     conversation_service
@@ -287,12 +293,3 @@ async def handle_pure_rag(
         "mode": "rag",
         "context_used": result.get("context_used", [])
     }
-
-
-async def simple_rag_response(message, context, system_message):
-    """Simple RAG response without LLM (for quick answers)"""
-    if context:
-        # Return top context
-        top = context[0]
-        return f"{top['metadata'].get('text', 'Không tìm thấy thông tin.')}"
-    return "Xin lỗi, tôi không tìm thấy thông tin về điều này."

hybrid_chat_endpoint_backup.py

@@ -0,0 +1,214 @@
+"""
+Hybrid Chat Endpoint: RAG + Scenario FSM
+Routes between scripted scenarios and knowledge retrieval
+"""
+from fastapi import HTTPException
+from datetime import datetime
+from typing import Dict, Any
+import json
+
+# Import scenario handlers
+from scenario_handlers.price_inquiry import PriceInquiryHandler
+from scenario_handlers.event_recommendation import EventRecommendationHandler
+from scenario_handlers.post_event_feedback import PostEventFeedbackHandler
+from scenario_handlers.exit_intent_rescue import ExitIntentRescueHandler
+
+
+async def hybrid_chat_endpoint(
+    request,  # ChatRequest
+    conversation_service,
+    intent_classifier,
+    embedding_service,  # NEW: For handlers
+    qdrant_service,     # NEW: For handlers
+    tools_service,
+    advanced_rag,
+    chat_history_collection,
+    hf_token,
+    lead_storage
+):
+
+    """
+    Hybrid conversational chatbot: Scenario FSM + RAG
+    
+    Flow:
+    1. Load session & scenario state
+    2. Classify intent (scenario vs RAG)
+    3. Route:
+       - Scenario: Execute FSM flow
+       - RAG: Knowledge retrieval
+       - RAG+Resume: Answer question then resume scenario
+    4. Save state & history
+    """
+    try:
+        # ===== SESSION MANAGEMENT =====
+        session_id = request.session_id
+        if not session_id:
+            session_id = conversation_service.create_session(
+                metadata={"user_agent": "api", "created_via": "hybrid_chat"},
+                user_id=request.user_id
+            )
+            print(f"✓ Created session: {session_id} (user: {request.user_id or 'anon'})")
+        else:
+            if not conversation_service.session_exists(session_id):
+                raise HTTPException(404, detail=f"Session {session_id} not found")
+        
+        # ===== LOAD SCENARIO STATE =====
+        scenario_state = conversation_service.get_scenario_state(session_id) or {}
+        
+        # ===== INTENT CLASSIFICATION =====
+        intent = intent_classifier.classify(request.message, scenario_state)
+        print(f"🎯 Intent: {intent}")
+        
+        # ===== ROUTING =====
+        if intent.startswith("scenario:"):
+            # Route to scenario engine
+            response_data = await handle_scenario(
+                intent,
+                request.message,
+                session_id,
+                scenario_state,
+                scenario_engine,
+                conversation_service,
+                advanced_rag,
+                lead_storage  # NEW: Pass for action handling
+            )
+        
+        elif intent == "rag:with_resume":
+            # Answer question but keep scenario active
+            response_data = await handle_rag_with_resume(
+                request,
+                session_id,
+                scenario_state,
+                advanced_rag,
+                embedding_service,
+                qdrant_service,
+                conversation_service
+            )
+        
+        else:  # rag:general
+            # Pure RAG query
+            response_data = await handle_pure_rag(
+                request,
+                session_id,
+                advanced_rag,
+                embedding_service,
+                qdrant_service,
+                tools_service,
+                chat_history_collection,
+                hf_token,
+                conversation_service
+            )
+        
+        # ===== SAVE HISTORY =====
+        conversation_service.add_message(
+            session_id,
+            "user",
+            request.message,
+            metadata={"intent": intent}
+        )
+        
+        conversation_service.add_message(
+            session_id,
+            "assistant",
+            response_data["response"],
+            metadata={
+                "mode": response_data.get("mode", "unknown"),
+                "context_used": response_data.get("context_used", [])[:3]  # Limit size
+    request,
+    session_id,
+    scenario_state,
+    advanced_rag,
+    embedding_service,
+    qdrant_service,
+    conversation_service
+):
+    """
+    Handle RAG query mid-scenario
+    Answer question properly, then remind user to continue scenario
+    """
+    # Query RAG with proper search
+    context_used = []
+    if request.use_rag:
+        query_embedding = embedding_service.encode_text(request.message)
+        results = qdrant_service.search(
+            query_embedding=query_embedding,
+            limit=request.top_k,
+            score_threshold=request.score_threshold,
+            ef=256
+        )
+        context_used = results
+    
+    # Build REAL RAG response (not placeholder)
+    if context_used and len(context_used) > 0:
+        # Format top results nicely
+        top_result = context_used[0]
+        text = top_result['metadata'].get('text', '')
+        
+        # Extract most relevant snippet (first 300 chars)
+        if text:
+            rag_response = text[:300].strip()
+            if len(text) > 300:
+                rag_response += "..."
+        else:
+            rag_response = "Tôi tìm thấy thông tin nhưng không thể hiển thị chi tiết."
+        
+        # If multiple results, add count
+        if len(context_used) > 1:
+            rag_response += f"\n\n(Tìm thấy {len(context_used)} kết quả liên quan)"
+    else:
+        rag_response = "Xin lỗi, tôi không tìm thấy thông tin về câu hỏi này trong tài liệu."
+    
+    # Add resume hint
+    resume_hint = "\n\n---\n💬 Vậy nha! Quay lại câu hỏi trước, bạn đã quyết định chưa?"
+    
+    return {
+        "response": rag_response + resume_hint,
+        "mode": "rag_with_resume",
+        "scenario_active": True,
+        "context_used": context_used
+    }
+
+
+async def handle_pure_rag(
+    request,
+    session_id,
+    advanced_rag,
+    embedding_service,
+    qdrant_service,
+    tools_service,
+    chat_history_collection,
+    hf_token,
+    conversation_service
+):
+    """
+    Handle pure RAG query (fallback to existing logic)
+    """
+    # Import existing chat_endpoint logic
+    from chat_endpoint import chat_endpoint
+    
+    # Call existing endpoint
+    result = await chat_endpoint(
+        request,
+        conversation_service,
+        tools_service,
+        advanced_rag,
+        embedding_service,
+        qdrant_service,
+        chat_history_collection,
+        hf_token
+    )
+    
+    return {
+        "response": result["response"],
+        "mode": "rag",
+        "context_used": result.get("context_used", [])
+    }
+
+
+async def simple_rag_response(message, context, system_message):
+    """Simple RAG response without LLM (for quick answers)"""
+    if context:
+        # Return top context
+        top = context[0]
+        return f"{top['metadata'].get('text', 'Không tìm thấy thông tin.')}"
+    return "Xin lỗi, tôi không tìm thấy thông tin về điều này."

main.py

@@ -776,11 +776,10 @@ async def chat(request: ChatRequest):
         request=request,
         conversation_service=conversation_service,
         intent_classifier=intent_classifier,
-        scenario_engine=scenario_engine,
+        embedding_service=embedding_service,  # NEW: Required by handlers
+        qdrant_service=qdrant_service,        # NEW: Required by handlers
         tools_service=tools_service,
         advanced_rag=advanced_rag,
-        embedding_service=embedding_service,
-        qdrant_service=qdrant_service,
         chat_history_collection=chat_history_collection,
         hf_token=hf_token,
         lead_storage=lead_storage

scenario_handlers/__init__.py

@@ -0,0 +1,7 @@
+"""
+Scenario Handlers Package
+Dedicated handlers for each scenario with proper RAG integration
+"""
+from .base_handler import BaseScenarioHandler
+
+__all__ = ['BaseScenarioHandler']

scenario_handlers/base_handler.py

@@ -0,0 +1,186 @@
+"""
+Base Scenario Handler - Abstract class for all scenario handlers
+Provides common functionality: RAG search, formatting, unexpected input handling
+"""
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+
+
+class BaseScenarioHandler(ABC):
+    """
+    Abstract base class for scenario handlers
+    
+    Each scenario (price_inquiry, event_recommendation, etc.) 
+    should inherit from this and implement start() and next_step()
+    """
+    
+    def __init__(self, embedding_service, qdrant_service, lead_storage):
+        """
+        Initialize handler with required services
+        
+        Args:
+            embedding_service: JinaClipEmbeddingService for text encoding
+            qdrant_service: QdrantVectorService for vector search
+            lead_storage: LeadStorageService for saving customer data
+        """
+        self.embedding_service = embedding_service
+        self.qdrant_service = qdrant_service
+        self.lead_storage = lead_storage
+    
+    @abstractmethod
+    def start(self, initial_data: Dict = None) -> Dict[str, Any]:
+        """
+        Start the scenario - return first message
+        
+        Args:
+            initial_data: Optional initial context (e.g., event_name, mood)
+        
+        Returns:
+            {
+                "message": "First bot message",
+                "new_state": {
+                    "active_scenario": "scenario_id",
+                    "scenario_step": 1,
+                    "scenario_data": {...}
+                }
+            }
+        """
+        pass
+    
+    @abstractmethod
+    def next_step(self, current_step: int, user_input: str, scenario_data: Dict) -> Dict[str, Any]:
+        """
+        Process user input and advance to next step
+        
+        Args:
+            current_step: Current step number (1-indexed)
+            user_input: User's message
+            scenario_data: Accumulated scenario data
+        
+        Returns:
+            {
+                "message": "Bot response",
+                "new_state": {...} or None if don't advance,
+                "loading_message": "Optional loading text",
+                "end_scenario": True/False,
+                "action": "Optional action to execute"
+            }
+        """
+        pass
+    
+    def _search_rag(self, query: str, limit: int = 3) -> list:
+        """
+        Execute RAG search using Qdrant
+        
+        Args:
+            query: Search query text
+            limit: Max number of results
+        
+        Returns:
+            List of search results with metadata
+        """
+        try:
+            embedding = self.embedding_service.encode_text(query)
+            results = self.qdrant_service.search(
+                query_embedding=embedding,
+                limit=limit,
+                score_threshold=0.5,
+                ef=256
+            )
+            return results
+        except Exception as e:
+            print(f"⚠️ RAG search error: {e}")
+            return []
+    
+    def _format_rag_results(self, results: list, max_length: int = 200) -> str:
+        """
+        Format RAG search results as readable text
+        
+        Args:
+            results: Search results from _search_rag()
+            max_length: Max chars per result
+        
+        Returns:
+            Formatted string with numbered results
+        """
+        if not results or len(results) == 0:
+            return "Không tìm thấy kết quả."
+        
+        formatted = []
+        for i, r in enumerate(results[:3], 1):
+            text = r['metadata'].get('text', '')
+            if text:
+                snippet = text[:max_length].strip()
+                if len(text) > max_length:
+                    snippet += "..."
+                formatted.append(f"{i}. {snippet}")
+        
+        return "\n".join(formatted) if formatted else "Không tìm thấy kết quả."
+    
+    def handle_unexpected_input(
+        self, 
+        user_input: str, 
+        expected_type: str, 
+        current_step: int
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Handle when user gives unexpected input (e.g., asks question instead of answering)
+        
+        Args:
+            user_input: User's message
+            expected_type: What we expected (email, choice, event_name, etc.)
+            current_step: Current step number
+        
+        Returns:
+            None - Continue with normal flow
+            Dict - Return this response (RAG answer + retry prompt)
+        """
+        # Detect if user is asking a question instead of answering
+        question_indicators = [
+            "?", "đâu", "gì", "sao", "where", "what", "how", 
+            "khi nào", "mấy giờ", "thế nào", "bao nhiêu"
+        ]
+        
+        message_lower = user_input.lower()
+        is_question = any(q in message_lower for q in question_indicators)
+        
+        if is_question:
+            # User asking off-topic question → Answer with RAG, then retry
+            print(f"🔀 Unexpected input detected: '{user_input}' (expected: {expected_type})")
+            
+            results = self._search_rag(user_input)
+            rag_answer = self._format_rag_results(results)
+            
+            # Build retry prompt based on expected_type
+            retry_prompts = {
+                'interest_tag': "Vậy nha! Quay lại câu hỏi: Bạn thích vibe nào? (Chill / Sôi động / Hài / Workshop)",
+                'event_name': "OK! Vậy bạn muốn xem event nào trong danh sách trên?",
+                'email': "Được rồi! Cho mình xin email nhé?",
+                'phone': "Okie! Vậy cho mình số điện thoại để liên hệ nhé?",
+                'choice': "Hiểu rồi! Vậy bạn chọn gì?",
+                'rating': "Vậy nha! Bạn đánh giá mấy sao? (1-5)"
+            }
+            
+            retry_msg = retry_prompts.get(expected_type, "Vậy nha! Quay lại câu hỏi trước nhé ^^")
+            
+            return {
+                "message": f"{rag_answer}\n\n---\n💬 {retry_msg}",
+                "new_state": None,  # Don't advance step
+                "scenario_active": True,
+                "loading_message": "⏳ Bạn đợi tôi tìm 1 chút nhé..."
+            }
+        
+        return None  # Continue normal flow
+    
+    def _validate_email(self, email: str) -> bool:
+        """Simple email validation"""
+        import re
+        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+        return re.match(pattern, email) is not None
+    
+    def _validate_phone(self, phone: str) -> bool:
+        """Simple phone validation (Vietnam format)"""
+        import re
+        # Accept formats: 0123456789, +84123456789, 84123456789
+        pattern = r'^(\+?84|0)[0-9]{9,10}$'
+        return re.match(pattern, phone.replace(' ', '')) is not None

scenario_handlers/event_recommendation.py

@@ -0,0 +1,261 @@
+"""
+Event Recommendation Scenario Handler
+Recommends events based on user's vibe/mood with RAG integration
+"""
+from typing import Dict, Any
+from .base_handler import BaseScenarioHandler
+
+
+class EventRecommendationHandler(BaseScenarioHandler):
+    """
+    Handle event recommendation flow
+    
+    Steps:
+    1. Ask for vibe/mood (Chill, Sôi động, Hài, Workshop)
+    2. Search events matching vibe → RAG
+    3. Show event list, ask which to see details
+    4. Ask what info needed (price, lineup, location, time)
+    5-8. Show specific info → RAG
+    9. Ask if want to save event to email
+    10. Collect email + send summary
+    11-12. End scenario
+    """
+    
+    def start(self, initial_data: Dict = None) -> Dict[str, Any]:
+        """Start event recommendation flow"""
+        return {
+            "message": "Hello! 👋 Bạn muốn tìm sự kiện theo vibe gì nè? Chill – Sôi động – Hài – Workshop?",
+            "new_state": {
+                "active_scenario": "event_recommendation",
+                "scenario_step": 1,
+                "scenario_data": initial_data or {}
+            }
+        }
+    
+    def next_step(self, current_step: int, user_input: str, scenario_data: Dict) -> Dict[str, Any]:
+        """Process user input and advance scenario"""
+        
+        # Get expected input type for this step
+        expected_type = self._get_expected_type(current_step)
+        
+        # Check for unexpected input (off-topic questions)
+        unexpected = self.handle_unexpected_input(user_input, expected_type, current_step)
+        if unexpected:
+            return unexpected
+        
+        # ===== STEP 1: Collect interest tag =====
+        if current_step == 1:
+            scenario_data['interest_tag'] = user_input
+            
+            return {
+                "message": f"Mình hiểu rồi! Để mình tìm sự kiện hợp vibe **{user_input}** nha",
+                "new_state": {
+                    "active_scenario": "event_recommendation",
+                    "scenario_step": 2,
+                    "scenario_data": scenario_data
+                },
+                "scenario_active": True
+            }
+        
+        # ===== STEP 2: Execute RAG search for events =====
+        elif current_step == 2:
+            # Search events matching interest_tag
+            query = f"sự kiện phù hợp với {scenario_data.get('interest_tag', 'mọi người')}"
+            print(f"🔍 RAG Search: {query}")
+            
+            results = self._search_rag(query, limit=3)
+            formatted_events = self._format_event_list(results)
+            
+            # Save results to scenario data
+            scenario_data['rag_results'] = formatted_events
+            scenario_data['available_events'] = [
+                r['metadata'].get('event_name', f'Event {i+1}') 
+                for i, r in enumerate(results[:3])
+            ]
+            
+            return {
+                "message": f"Đây là 2–3 event hợp với bạn nè:\n{formatted_events}\n\nBạn có muốn xem chi tiết event nào không?",
+                "new_state": {
+                    "active_scenario": "event_recommendation",
+                    "scenario_step": 3,
+                    "scenario_data": scenario_data
+                },
+                "scenario_active": True,
+                "loading_message": "⏳ Bạn đợi tôi tìm 1 chút nhé..."
+            }
+        
+        # ===== STEP 3: User picks event =====
+        elif current_step == 3:
+            scenario_data['event_name'] = user_input
+            
+            return {
+                "message": "Bạn cần xem: giá – line-up – địa điểm – hay thời gian của sự kiện?",
+                "new_state": {
+                    "active_scenario": "event_recommendation",
+                    "scenario_step": 4,
+                    "scenario_data": scenario_data
+                },
+                "scenario_active": True
+            }
+        
+        # ===== STEP 4: Branch based on info choice =====
+        elif current_step == 4:
+            choice = self._detect_choice(user_input)
+            event_name = scenario_data.get('event_name', 'sự kiện này')
+            
+            # Build RAG query based on choice
+            query_map = {
+                'price': f"giá vé {event_name}",
+                'lineup': f"lineup nghệ sĩ {event_name}",
+                'location': f"địa điểm tổ chức {event_name}",
+                'time': f"thời gian lịch diễn {event_name}"
+            }
+            
+            query = query_map.get(choice, query_map['price'])
+            print(f"🔍 RAG Search: {query}")
+            
+            results = self._search_rag(query)
+            formatted_info = self._format_rag_results(results)
+            
+            # Build response message
+            message_map = {
+                'price': f"Giá vé event {event_name} nè:\n{formatted_info}",
+                'lineup': f"Lineup / nghệ sĩ của event {event_name} là:\n{formatted_info}",
+                'location': f"Địa điểm tổ chức event {event_name}:\n{formatted_info}",
+                'time': f"Thời gian / lịch diễn của event {event_name}:\n{formatted_info}"
+            }
+            
+            return {
+                "message": message_map.get(choice, message_map['price']),
+                "new_state": {
+                    "active_scenario": "event_recommendation",
+                    "scenario_step": 9,  # Skip to email step
+                    "scenario_data": scenario_data
+                },
+                "scenario_active": True,
+                "loading_message": "⏳ Bạn đợi tôi tìm 1 chút nhé..."
+            }
+        
+        # ===== STEP 9: Ask if want to save event to email =====
+        elif current_step == 9:
+            choice = self._detect_yes_no(user_input)
+            
+            if choice == 'yes':
+                return {
+                    "message": "Cho mình xin email để gửi bản tóm tắt event kèm link mua vé?",
+                    "new_state": {
+                        "active_scenario": "event_recommendation",
+                        "scenario_step": 10,
+                        "scenario_data": scenario_data
+                    },
+                    "scenario_active": True
+                }
+            else:
+                return {
+                    "message": "Okie, bạn cần event theo vibe khác không nè? 😄",
+                    "new_state": None,
+                    "scenario_active": False,
+                    "end_scenario": True
+                }
+        
+        # ===== STEP 10: Collect email and send summary =====
+        elif current_step == 10:
+            email = user_input.strip()
+            
+            if not self._validate_email(email):
+                return {
+                    "message": "Email này có vẻ không đúng định dạng. Bạn nhập lại giúp mình nhé? (Ví dụ: name@example.com)",
+                    "new_state": None,  # Stay at same step
+                    "scenario_active": True
+                }
+            
+            # Save lead
+            scenario_data['email'] = email
+            
+            try:
+                self.lead_storage.save_lead(
+                    event_name=scenario_data.get('event_name', 'Unknown Event'),
+                    email=email,
+                    interests={
+                        "vibe": scenario_data.get('interest_tag'),
+                        "wants_event_summary": True
+                    },
+                    session_id=scenario_data.get('session_id')
+                )
+                print(f"📧 Lead saved: {email}")
+            except Exception as e:
+                print(f"⚠️ Error saving lead: {e}")
+            
+            return {
+                "message": "Đã gửi email cho bạn nha! ✨",
+                "new_state": None,
+                "scenario_active": False,
+                "end_scenario": True,
+                "action": "send_event_summary_email"
+            }
+        
+        # Fallback - unknown step
+        return {
+            "message": "Xin lỗi, có lỗi xảy ra. Bạn muốn bắt đầu lại không?",
+            "new_state": None,
+            "scenario_active": False,
+            "end_scenario": True
+        }
+    
+    def _get_expected_type(self, step: int) -> str:
+        """Get expected input type for each step"""
+        type_map = {
+            1: 'interest_tag',
+            2: None,  # Auto-advance after RAG
+            3: 'event_name',
+            4: 'choice',
+            9: 'choice',
+            10: 'email'
+        }
+        return type_map.get(step, 'text')
+    
+    def _format_event_list(self, results: list) -> str:
+        """Format event search results as numbered list"""
+        if not results or len(results) == 0:
+            return "Hiện tại chưa có event phù hợp 😢\nBạn thử vibe khác nhé!"
+        
+        events = []
+        for i, r in enumerate(results[:3], 1):
+            metadata = r.get('metadata', {})
+            name = metadata.get('event_name', f'Event {i}')
+            date = metadata.get('date', 'TBA')
+            location = metadata.get('location', '')
+            
+            event_str = f"{i}. **{name}**"
+            if date != 'TBA':
+                event_str += f" ({date})"
+            if location:
+                event_str += f" - {location}"
+            
+            events.append(event_str)
+        
+        return "\n".join(events)
+    
+    def _detect_choice(self, user_input: str) -> str:
+        """Detect what info user wants to see"""
+        input_lower = user_input.lower()
+        
+        if any(k in input_lower for k in ['giá', 'price', 'vé', 'ticket', 'bao nhiêu']):
+            return 'price'
+        elif any(k in input_lower for k in ['lineup', 'line-up', 'nghệ sĩ', 'artist', 'performer']):
+            return 'lineup'
+        elif any(k in input_lower for k in ['địa điểm', 'location', 'ở đâu', 'where', 'chỗ']):
+            return 'location'
+        elif any(k in input_lower for k in ['thời gian', 'time', 'khi nào', 'when', 'lịch', 'date']):
+            return 'time'
+        else:
+            return 'price'  # Default
+    
+    def _detect_yes_no(self, user_input: str) -> str:
+        """Detect yes/no response"""
+        input_lower = user_input.lower()
+        
+        if any(k in input_lower for k in ['có', 'yes', 'ok', 'được', 'ừ', 'oke']):
+            return 'yes'
+        else:
+            return 'no'

scenario_handlers/exit_intent_rescue.py

@@ -0,0 +1,100 @@
+"""
+Exit Intent Rescue Scenario Handler
+Quick flow to retain users about to leave
+"""
+from typing import Dict, Any
+from .base_handler import BaseScenarioHandler
+
+
+class ExitIntentRescueHandler(BaseScenarioHandler):
+    """
+    Handle exit intent rescue flow
+    
+    Very short 2-step flow to capture leaving users
+    
+    Steps:
+    1. Offer discount coupon
+    2. Collect email to send coupon
+    """
+    
+    def start(self, initial_data: Dict = None) -> Dict[str, Any]:
+        """Start exit intent flow with urgency"""
+        return {
+            "message": "Khoan đã! 😭 Trước khi bạn rời đi…\n\nChúng mình sắp có mã giảm **5%** cho lần mua đầu tiên. Bạn muốn nhận không?",
+            "new_state": {
+                "active_scenario": "exit_intent_rescue",
+                "scenario_step": 1,
+                "scenario_data": initial_data or {}
+            }
+        }
+    
+    def next_step(self, current_step: int, user_input: str, scenario_data: Dict) -> Dict[str, Any]:
+        """Process and try to capture email quickly"""
+        
+        # STEP 1: Want coupon?
+        if current_step == 1:
+            choice = self._detect_yes_no(user_input)
+            
+            if choice == 'yes':
+                return {
+                    "message": "Tuyệt vời! 🎉 Cho mình xin email để gửi mã giảm giá nhé?",
+                    "new_state": {
+                        "active_scenario": "exit_intent_rescue",
+                        "scenario_step": 2,
+                        "scenario_data": scenario_data
+                    },
+                    "scenario_active": True
+                }
+            else:
+                return {
+                    "message": "Okie! Hẹn gặp lại bạn nhé 👋",
+                    "new_state": None,
+                    "scenario_active": False,
+                    "end_scenario": True
+                }
+        
+        # STEP 2: Collect email and send coupon
+        elif current_step == 2:
+            email = user_input.strip()
+            
+            if not self._validate_email(email):
+                return {
+                    "message": "Email này có vẻ không đúng. Bạn nhập lại nhanh giúp mình nhé?",
+                    "new_state": None,
+                    "scenario_active": True
+                }
+            
+            scenario_data['email'] = email
+            
+            # Save lead with high priority (exit intent)
+            try:
+                self.lead_storage.save_lead(
+                    event_name="Exit Intent Coupon",
+                    email=email,
+                    interests={"exit_intent": True, "discount_5_percent": True},
+                    session_id=scenario_data.get('session_id')
+                )
+                print(f"🎯 Exit intent lead saved: {email}")
+            except Exception as e:
+                print(f"⚠️ Error saving lead: {e}")
+            
+            return {
+                "message": "Đã gửi mã **FIRST5** vào email rồi nha! ✨\n\nDùng ngay hôm nay nhé, mã chỉ có hiệu lực 24h thôi!",
+                "new_state": None,
+                "scenario_active": False,
+                "end_scenario": True,
+                "action": "send_coupon_email"
+            }
+        
+        # Fallback
+        return {
+            "message": "Hẹn gặp lại bạn! 👋",
+            "new_state": None,
+            "scenario_active": False,
+            "end_scenario": True
+        }
+    
+    def _detect_yes_no(self, user_input: str) -> str:
+        """Detect yes/no quickly"""
+        input_lower = user_input.lower()
+        return 'yes' if any(k in input_lower for k in ['có', 'yes', 'ok', 'được', 'ừ', 'muốn']) else 'no'

scenario_handlers/post_event_feedback.py

@@ -0,0 +1,176 @@
+"""
+Post Event Feedback Scenario Handler
+Collects feedback after user attends an event
+"""
+from typing import Dict, Any
+from .base_handler import BaseScenarioHandler
+
+
+class PostEventFeedbackHandler(BaseScenarioHandler):
+    """
+    Handle post-event feedback flow
+    
+    Requires initial_data: {event_name, event_date, event_id}
+    
+    Steps:
+    1. Ask for rating (1-5 stars)
+    2. Ask what they liked most
+    3. Ask for improvement suggestions
+    4. Thank + ask if want similar events
+    5. Collect email for future events
+    """
+    
+    def start(self, initial_data: Dict = None) -> Dict[str, Any]:
+        """Start feedback flow with event context"""
+        initial_data = initial_data or {}
+        event_name = initial_data.get('event_name', 'sự kiện')
+        
+        return {
+            "message": f"Cảm ơn bạn đã tham dự *{event_name}* hôm qua! 🎉\n\nBạn thấy trải nghiệm như thế nào? (1-5 sao)",
+            "new_state": {
+                "active_scenario": "post_event_feedback",
+                "scenario_step": 1,
+                "scenario_data": initial_data
+            }
+        }
+    
+    def next_step(self, current_step: int, user_input: str, scenario_data: Dict) -> Dict[str, Any]:
+        """Process feedback and advance"""
+        
+        expected_type = self._get_expected_type(current_step)
+        unexpected = self.handle_unexpected_input(user_input, expected_type, current_step)
+        if unexpected:
+            return unexpected
+        
+        # STEP 1: Collect rating
+        if current_step == 1:
+            rating = self._extract_rating(user_input)
+            scenario_data['rating'] = rating
+            
+            if rating >= 4:
+                msg = "Tuyệt vời! 🎉 Bạn thích điểm gì nhất về event?"
+            else:
+                msg = "Cảm ơn feedback! Bạn thấy event cần cải thiện điểm nào?"
+            
+            return {
+                "message": msg,
+                "new_state": {
+                    "active_scenario": "post_event_feedback",
+                    "scenario_step": 2,
+                    "scenario_data": scenario_data
+                },
+                "scenario_active": True
+            }
+        
+        # STEP 2: What they liked/disliked
+        elif current_step == 2:
+            scenario_data['feedback_text'] = user_input
+            
+            return {
+                "message": "Cảm ơn bạn nhiều! Feedback này giúp chúng mình rất nhiều 💙\n\nBạn muốn nhận thông tin về các event tương tự không?",
+                "new_state": {
+                    "active_scenario": "post_event_feedback",
+                    "scenario_step": 4,
+                    "scenario_data": scenario_data
+                },
+                "scenario_active": True
+            }
+        
+        # STEP 4: Want similar events?
+        elif current_step == 4:
+            choice = self._detect_yes_no(user_input)
+            
+            if choice == 'yes':
+                return {
+                    "message": "Tuyệt! Cho mình xin email để gửi thông tin event sắp tới nhé?",
+                    "new_state": {
+                        "active_scenario": "post_event_feedback",
+                        "scenario_step": 5,
+                        "scenario_data": scenario_data
+                    },
+                    "scenario_active": True
+                }
+            else:
+                # Save feedback without email
+                self._save_feedback(scenario_data)
+                
+                return {
+                    "message": "Okie! Cảm ơn bạn đã dành thời gian góp ý 🙏",
+                    "new_state": None,
+                    "scenario_active": False,
+                    "end_scenario": True
+                }
+        
+        # STEP 5: Collect email
+        elif current_step == 5:
+            email = user_input.strip()
+            
+            if not self._validate_email(email):
+                return {
+                    "message": "Email này có vẻ không đúng. Bạn nhập lại giúp mình nhé?",
+                    "new_state": None,
+                    "scenario_active": True
+                }
+            
+            scenario_data['email'] = email
+            
+            # Save feedback + email
+            self._save_feedback(scenario_data)
+            
+            # Save lead
+            try:
+                self.lead_storage.save_lead(
+                    event_name=scenario_data.get('event_name'),
+                    email=email,
+                    interests={"wants_similar_events": True},
+                    session_id=scenario_data.get('session_id')
+                )
+                print(f"📧 Feedback + lead saved: {email}")
+            except Exception as e:
+                print(f"⚠️ Error saving lead: {e}")
+            
+            return {
+                "message": "Cảm ơn bạn! Mình sẽ gửi thông tin event mới cho bạn sớm nhất ✨",
+                "new_state": None,
+                "scenario_active": False,
+                "end_scenario": True
+            }
+        
+        # Fallback
+        return {
+            "message": "Cảm ơn bạn! Hẹn gặp lại ✨",
+            "new_state": None,
+            "scenario_active": False,
+            "end_scenario": True
+        }
+    
+    def _get_expected_type(self, step: int) -> str:
+        """Get expected input type"""
+        type_map = {
+            1: 'rating',
+            2: 'text',
+            4: 'choice',
+            5: 'email'
+        }
+        return type_map.get(step, 'text')
+    
+    def _extract_rating(self, user_input: str) -> int:
+        """Extract rating from user input"""
+        import re
+        # Look for numbers 1-5
+        match = re.search(r'[1-5]', user_input)
+        if match:
+            return int(match.group())
+        
+        # Default to 3 if can't extract
+        return 3
+    
+    def _detect_yes_no(self, user_input: str) -> str:
+        """Detect yes/no"""
+        input_lower = user_input.lower()
+        return 'yes' if any(k in input_lower for k in ['có', 'yes', 'ok', 'được', 'ừ']) else 'no'
+    
+    def _save_feedback(self, scenario_data: Dict):
+        """Save feedback to database (placeholder)"""
+        # TODO: Implement actual feedback storage
+        print(f"💾 Feedback saved: {scenario_data.get('rating')} stars - {scenario_data.get('feedback_text', '')[:50]}")

scenario_handlers/price_inquiry.py

@@ -0,0 +1,224 @@
+"""
+Price Inquiry Scenario Handler
+Helps users understand pricing and collects leads
+"""
+from typing import Dict, Any
+from .base_handler import BaseScenarioHandler
+
+
+class PriceInquiryHandler(BaseScenarioHandler):
+    """
+    Handle price inquiry flow
+    
+    Steps:
+    1. Ask which event
+    2. Ask group size (1 person vs group)
+    3. Show pricing info
+    4. Ask if want PDF via email
+    5. Collect email → Send PDF
+    6. Ask if want SMS reminder
+    7-8. Collect phone → Send SMS
+    """
+    
+    def start(self, initial_data: Dict = None) -> Dict[str, Any]:
+        """Start price inquiry flow"""
+        return {
+            "message": "Hello 👋 Bạn muốn xem giá vé của show nào?",
+            "new_state": {
+                "active_scenario": "price_inquiry",
+                "scenario_step": 1,
+                "scenario_data": initial_data or {}
+            }
+        }
+    
+    def next_step(self, current_step: int, user_input: str, scenario_data: Dict) -> Dict[str, Any]:
+        """Process user input and advance scenario"""
+        
+        expected_type = self._get_expected_type(current_step)
+        unexpected = self.handle_unexpected_input(user_input, expected_type, current_step)
+        if unexpected:
+            return unexpected
+        
+        # STEP 1: Which event?
+        if current_step == 1:
+            scenario_data['event_name'] = user_input
+            return {
+                "message": "Bạn đi 1 mình hay đi nhóm?",
+                "new_state": {
+                    "active_scenario": "price_inquiry",
+                    "scenario_step": 2,
+                    "scenario_data": scenario_data
+                },
+                "scenario_active": True
+            }
+        
+        # STEP 2: Group size
+        elif current_step == 2:
+            group = self._detect_group_size(user_input)
+            scenario_data['group_size'] = group
+            
+            event = scenario_data.get('event_name', 'event này')
+            
+            # Show pricing based on group size
+            if group == 'single':
+                msg = f"Giá vé cho **{event}**:\n- Vé thường: 300k\n- Vé VIP: 500k"
+            else:
+                msg = f"Giá vé nhóm cho **{event}**:\n- Nhóm 3-5: 250k/người\n- Nhóm 6+: 200k/người"
+            
+            return {
+                "message": msg + "\n\nBạn muốn mình gửi bảng giá chi tiết qua email không?",
+                "new_state": {
+                    "active_scenario": "price_inquiry",
+                    "scenario_step": 4,  # Skip step 3
+                    "scenario_data": scenario_data
+                },
+                "scenario_active": True
+            }
+        
+        # STEP 4: Want PDF?
+        elif current_step == 4:
+            choice = self._detect_yes_no(user_input)
+            
+            if choice == 'yes':
+                return {
+                    "message": "Cho mình xin email để gửi PDF bảng giá nhé?",
+                    "new_state": {
+                        "active_scenario": "price_inquiry",
+                        "scenario_step": 5,
+                        "scenario_data": scenario_data
+                    },
+                    "scenario_active": True
+                }
+            else:
+                return {
+                    "message": "Okie! Bạn cần tư vấn gì thêm không? 😊",
+                    "new_state": None,
+                    "scenario_active": False,
+                    "end_scenario": True
+                }
+        
+        # STEP 5: Collect email
+        elif current_step == 5:
+            email = user_input.strip()
+            
+            if not self._validate_email(email):
+                return {
+                    "message": "Email này có vẻ không đúng. Bạn nhập lại giúp mình nhé?",
+                    "new_state": None,
+                    "scenario_active": True
+                }
+            
+            scenario_data['email'] = email
+            
+            # Save lead
+            try:
+                self.lead_storage.save_lead(
+                    event_name=scenario_data.get('event_name'),
+                    email=email,
+                    interests={"group": scenario_data.get('group_size'), "wants_pdf": True},
+                    session_id=scenario_data.get('session_id')
+                )
+                print(f"📧 Lead saved: {email}")
+            except Exception as e:
+                print(f"⚠️ Error saving lead: {e}")
+            
+            return {
+                "message": "Đã gửi PDF rồi nha 🎫\n\nBạn muốn nhận nhắc lịch qua SMS không?",
+                "new_state": {
+                    "active_scenario": "price_inquiry",
+                    "scenario_step": 6,
+                    "scenario_data": scenario_data
+                },
+                "scenario_active": True,
+                "action": "send_pdf_email"
+            }
+        
+        # STEP 6: Want SMS?
+        elif current_step == 6:
+            choice = self._detect_yes_no(user_input)
+            
+            if choice == 'yes':
+                return {
+                    "message": "Cho mình xin số điện thoại để gửi SMS nhắc lịch nhé?",
+                    "new_state": {
+                        "active_scenario": "price_inquiry",
+                        "scenario_step": 8,
+                        "scenario_data": scenario_data
+                    },
+                    "scenario_active": True
+                }
+            else:
+                return {
+                    "message": "Okie! Cảm ơn bạn nha ✨",
+                    "new_state": None,
+                    "scenario_active": False,
+                    "end_scenario": True
+                }
+        
+        # STEP 8: Collect phone
+        elif current_step == 8:
+            phone = user_input.strip()
+            
+            if not self._validate_phone(phone):
+                return {
+                    "message": "Số điện thoại này có vẻ không đúng. Bạn nhập lại giúp mình nhé? (VD: 0901234567)",
+                    "new_state": None,
+                    "scenario_active": True
+                }
+            
+            scenario_data['phone'] = phone
+            
+            # Save lead with phone
+            try:
+                self.lead_storage.save_lead(
+                    event_name=scenario_data.get('event_name'),
+                    email=scenario_data.get('email'),
+                    phone=phone,
+                    interests={"group": scenario_data.get('group_size'), "wants_reminder": True},
+                    session_id=scenario_data.get('session_id')
+                )
+                print(f"📱 Lead saved: {phone}")
+            except Exception as e:
+                print(f"⚠️ Error saving lead: {e}")
+            
+            return {
+                "message": "Đã lưu rồi nha! Mình sẽ nhắc bạn trước show 1 ngày ✨",
+                "new_state": None,
+                "scenario_active": False,
+                "end_scenario": True,
+                "action": "save_lead_phone"
+            }
+        
+        # Fallback
+        return {
+            "message": "Có lỗi xảy ra. Bạn muốn bắt đầu lại không?",
+            "new_state": None,
+            "scenario_active": False,
+            "end_scenario": True
+        }
+    
+    def _get_expected_type(self, step: int) -> str:
+        """Get expected input type for each step"""
+        type_map = {
+            1: 'event_name',
+            2: 'choice',
+            4: 'choice',
+            5: 'email',
+            6: 'choice',
+            8: 'phone'
+        }
+        return type_map.get(step, 'text')
+    
+    def _detect_group_size(self, user_input: str) -> str:
+        """Detect if single or group"""
+        input_lower = user_input.lower()
+        
+        if any(k in input_lower for k in ['nhóm', 'group', 'team', 'mấy người', 'nhiều']):
+            return 'group'
+        else:
+            return 'single'
+    
+    def _detect_yes_no(self, user_input: str) -> str:
+        """Detect yes/no"""
+        input_lower = user_input.lower()
+        return 'yes' if any(k in input_lower for k in ['có', 'yes', 'ok', 'được', 'ừ']) else 'no'