Upload 17 files

advanced_rag.py

@@ -407,4 +407,4 @@ HƯỚNG DẪN TRẢ LỜI:
 5. Nếu có nhiều kết quả, hãy liệt kê ngắn gọn các điểm chính (Tên, Thời gian, Địa điểm).
 6. Nếu context không liên quan, hãy lịch sự nói rằng bạn chưa tìm thấy thông tin phù hợp trong hệ thống."""
 
-        return prompt_template
+        return prompt_template

agent_service.py

@@ -1,503 +1,432 @@
-"""
-Agent Service - Central Brain for Sales & Feedback Agents
-Manages LLM conversation loop with tool calling
-"""
-from typing import Dict, Any, List, Optional
-import os
-from tools_service import ToolsService
-
-
-class AgentService:
-    """
-    Manages the conversation loop between User -> LLM -> Tools -> Response
-    """
-    
-    def __init__(
-        self,
-        tools_service: ToolsService,
-        embedding_service,
-        qdrant_service,
-        advanced_rag,
-        hf_token: str,
-        feedback_tracking=None  # NEW: Optional feedback tracking
-    ):
-        self.tools_service = tools_service
-        self.embedding_service = embedding_service
-        self.qdrant_service = qdrant_service
-        self.advanced_rag = advanced_rag
-        self.hf_token = hf_token
-        self.feedback_tracking = feedback_tracking
-        
-        # Load system prompts
-        self.prompts = self._load_prompts()
-    
-    def _load_prompts(self) -> Dict[str, str]:
-        """Load system prompts from files"""
-        prompts = {}
-        prompts_dir = "prompts"
-        
-        for mode in ["sales_agent", "feedback_agent"]:
-            filepath = os.path.join(prompts_dir, f"{mode}.txt")
-            try:
-                with open(filepath, 'r', encoding='utf-8') as f:
-                    prompts[mode] = f.read()
-                print(f"✓ Loaded prompt: {mode}")
-            except Exception as e:
-                print(f"⚠️ Error loading {mode} prompt: {e}")
-                prompts[mode] = ""
-        
-        return prompts
-    
-    async def chat(
-        self,
-        user_message: str,
-        conversation_history: List[Dict],
-        mode: str = "sales",  # "sales" or "feedback"
-        user_id: Optional[str] = None,
-        access_token: Optional[str] = None,  # NEW: For authenticated API calls
-        max_iterations: int = 3
-    ) -> Dict[str, Any]:
-        """
-        Main conversation loop
-        
-        Args:
-            user_message: User's input
-            conversation_history: Previous messages [{"role": "user", "content": ...}, ...]
-            mode: "sales" or "feedback"
-            user_id: User ID (for feedback mode to check purchase history)
-            access_token: JWT token for authenticated API calls
-            max_iterations: Maximum tool call iterations to prevent infinite loops
-        
-        Returns:
-            {
-                "message": "Bot response",
-                "tool_calls": [...],  # List of tools called (for debugging)
-                "mode": mode
-            }
-        """
-        print(f"\n🤖 Agent Mode: {mode}")
-        print(f"👤 User Message: {user_message}")
-        print(f"🔑 Auth Info:")
-        print(f"  - User ID: {user_id}")
-        print(f"  - Access Token: {'✅ Received' if access_token else '❌ None'}")
-        
-        # Store user_id and access_token for tool calls
-        self.current_user_id = user_id
-        self.current_access_token = access_token
-        if access_token:
-            print(f"  - Stored access_token for tools: {access_token[:20]}...")
-        if user_id:
-            print(f"  - Stored user_id for tools: {user_id}")
-        
-        # Select system prompt
-        system_prompt = self._get_system_prompt(mode)
-        
-        # Build conversation context
-        messages = self._build_messages(system_prompt, conversation_history, user_message)
-        
-        # Agentic loop: LLM may call tools multiple times
-        tool_calls_made = []
-        current_response = None
-        
-        for iteration in range(max_iterations):
-            print(f"\n🔄 Iteration {iteration + 1}")
-            
-            # Call LLM
-            llm_response = await self._call_llm(messages)
-            print(f"🧠 LLM Response: {llm_response[:200]}...")
-            
-            # Check if LLM wants to call a tool
-            tool_call = self._parse_tool_call(llm_response)
-            
-            if not tool_call:
-                # No tool call -> This is the final response
-                current_response = llm_response
-                break
-            
-            # Execute tool
-            print(f"🔧 Tool Called: {tool_call['tool_name']}")
-            
-            # Auto-inject real user_id for get_purchased_events
-            if tool_call['tool_name'] == 'get_purchased_events' and self.current_user_id:
-                print(f"🔄 Auto-injecting real user_id: {self.current_user_id}")
-                tool_call['arguments']['user_id'] = self.current_user_id
-            
-            tool_result = await self.tools_service.execute_tool(
-                tool_call['tool_name'],
-                tool_call['arguments'],
-                access_token=self.current_access_token  # Pass access_token
-            )
-            
-            # Record tool call
-            tool_calls_made.append({
-                "function": tool_call['tool_name'],
-                "arguments": tool_call['arguments'],
-                "result": tool_result
-            })
-            
-            # Add tool result to conversation
-            messages.append({
-                "role": "assistant",
-                "content": llm_response
-            })
-            messages.append({
-                "role": "system",
-                "content": f"Tool Result:\n{self._format_tool_result({'result': tool_result})}"
-            })
-            
-            # If tool returns "run_rag_search", handle it specially
-            if isinstance(tool_result, dict) and tool_result.get("action") == "run_rag_search":
-                rag_results = await self._execute_rag_search(tool_result["query"])
-                messages[-1]["content"] = f"RAG Search Results:\n{rag_results}"
-        
-        # Clean up response
-        final_response = current_response or llm_response
-        final_response = self._clean_response(final_response)
-        
-        return {
-            "message": final_response,
-            "tool_calls": tool_calls_made,
-            "mode": mode
-        }
-    
-    def _get_system_prompt(self, mode: str) -> str:
-        """Get system prompt for selected mode with tools definition"""
-        prompt_key = f"{mode}_agent" if mode in ["sales", "feedback"] else "sales_agent"
-        base_prompt = self.prompts.get(prompt_key, "")
-        
-        # Add tools definition
-        tools_definition = self._get_tools_definition()
-        
-        return f"{base_prompt}\n\n{tools_definition}"
-    
-    def _get_tools_definition(self) -> str:
-        """Get tools definition in text format for prompt"""
-        return """
-# AVAILABLE TOOLS
-
-You can call the following tools when needed. To call a tool, output a JSON block like this:
-
-```json
-{
-  "tool_call": "tool_name",
-  "arguments": {
-    "arg1": "value1",
-    "arg2": "value2"
-  }
-}
-```
-
-## Tools List:
-
-### 1. search_events
-Search for events matching user criteria.
-Arguments:
-- query (string): Search keywords
-- vibe (string, optional): Mood/vibe (e.g., "chill", "sôi động")
-- time (string, optional): Time period (e.g., "cuối tuần này")
-
-Example:
-```json
-{"tool_call": "search_events", "arguments": {"query": "nhạc rock", "vibe": "sôi động"}}
-```
-
-### 2. get_event_details
-Get detailed information about a specific event.
-Arguments:
-- event_id (string): Event ID from search results
-
-Example:
-```json
-{"tool_call": "get_event_details", "arguments": {"event_id": "6900ae38eb03f29702c7fd1d"}}
-```
-
-### 3. get_purchased_events (Feedback mode only)
-Check which events the user has attended.
-Arguments:
-- user_id (string): User ID
-
-Example:
-```json
-{"tool_call": "get_purchased_events", "arguments": {"user_id": "user_123"}}
-```
-
-### 4. save_feedback
-Save user's feedback/review for an event.
-Arguments:
-- event_id (string): Event ID
-- rating (integer): 1-5 stars
-- comment (string, optional): User's comment
-
-Example:
-```json
-{"tool_call": "save_feedback", "arguments": {"event_id": "abc123", "rating": 5, "comment": "Tuyệt vời!"}}
-```
-
-### 5. save_lead
-Save customer contact information.
-Arguments:
-- email (string, optional): Email address
-- phone (string, optional): Phone number
-- interest (string, optional): What they're interested in
-
-Example:
-```json
-{"tool_call": "save_lead", "arguments": {"email": "user@example.com", "interest": "Rock show"}}
-```
-
-**IMPORTANT:**
-- Call tools ONLY when you need real-time data
-- After receiving tool results, respond naturally to the user
-- Don't expose raw JSON to users - always format nicely
-"""
-    
-    def _build_messages(
-        self,
-        system_prompt: str,
-        history: List[Dict],
-        user_message: str
-    ) -> List[Dict]:
-        """Build messages array for LLM"""
-        messages = [{"role": "system", "content": system_prompt}]
-        
-        # Add conversation history
-        messages.extend(history)
-        
-        # Add current user message
-        messages.append({"role": "user", "content": user_message})
-        
-        return messages
-    
-    async def _call_llm(self, messages: List[Dict]) -> str:
-        """
-        Call HuggingFace LLM directly using chat_completion (conversational)
-        """
-        try:
-            from huggingface_hub import AsyncInferenceClient
-            
-            # Create async client
-            client = AsyncInferenceClient(token=self.hf_token)
-            
-            # Call HF API with chat completion (conversational)
-            response_text = ""
-            async for message in await client.chat_completion(
-                messages=messages,  # Use messages directly
-                model="openai/gpt-oss-20b",
-                max_tokens=512,
-                temperature=0.7,
-                stream=True
-            ):
-                if message.choices and message.choices[0].delta.content:
-                    response_text += message.choices[0].delta.content
-            
-            return response_text
-        except Exception as e:
-            print(f"⚠️ LLM Call Error: {e}")
-            return "Xin lỗi, tôi đang gặp chút vấn đề kỹ thuật. Bạn thử lại sau nhé!"
-    
-    def _messages_to_prompt(self, messages: List[Dict]) -> str:
-        """Convert messages array to single prompt string"""
-        prompt_parts = []
-        
-        for msg in messages:
-            role = msg["role"]
-            content = msg["content"]
-            
-            if role == "system":
-                prompt_parts.append(f"[SYSTEM]\n{content}\n")
-            elif role == "user":
-                prompt_parts.append(f"[USER]\n{content}\n")
-            elif role == "assistant":
-                prompt_parts.append(f"[ASSISTANT]\n{content}\n")
-        
-        return "\n".join(prompt_parts)
-    
-    def _format_tool_result(self, tool_result: Dict) -> str:
-        """Format tool result for feeding back to LLM"""
-        result = tool_result.get("result", {})
-        
-        # Special handling for purchased events list
-        if isinstance(result, list):
-            print(f"\n🔍 Formatting {len(result)} purchased events for LLM")
-            if not result:
-                return "User has not purchased any events yet."
-            
-            # Format each event clearly
-            formatted_events = []
-            for i, event in enumerate(result, 1):
-                event_info = []
-                event_info.append(f"Event {i}:")
-                
-                # Extract key fields
-                if 'eventName' in event:
-                    event_info.append(f"  Name: {event['eventName']}")
-                if 'eventCode' in event:
-                    event_info.append(f"  Code: {event['eventCode']}")
-                if '_id' in event:
-                    event_info.append(f"  ID: {event['_id']}")
-                if 'startTimeEventTime' in event:
-                    event_info.append(f"  Date: {event['startTimeEventTime']}")
-                
-                formatted_events.append("\n".join(event_info))
-            
-            formatted = "User's Purchased Events:\n\n" + "\n\n".join(formatted_events)
-            print(f"📤 Sending to LLM:\n{formatted}")
-            return formatted
-        
-        # Default formatting for other results
-        if isinstance(result, dict):
-            # Pretty print key info
-            formatted = []
-            for key, value in result.items():
-                if key not in ["success", "error"]:
-                    formatted.append(f"{key}: {value}")
-            return "\n".join(formatted)
-        
-        return str(result)
-    
-    async def _execute_rag_search(self, query_params: Dict) -> str:
-        """
-        Execute RAG search for event discovery
-        Called when LLM wants to search_events
-        """
-        query = query_params.get("query", "")
-        vibe = query_params.get("vibe", "")
-        
-        # Build search query
-        search_text = f"{query} {vibe}".strip()
-        
-        print(f"🔍 RAG Search: {search_text}")
-        
-        # Use embedding + qdrant
-        embedding = self.embedding_service.encode_text(search_text)
-        results = self.qdrant_service.search(
-            query_embedding=embedding,
-            limit=5
-        )
-        
-        # Format results
-        formatted = []
-        for i, result in enumerate(results, 1):
-            # Result is a dict with keys: id, score, payload
-            payload = result.get("payload", {})
-            texts = payload.get("texts", [])
-            text = texts[0] if texts else ""
-            event_id = payload.get("id_use", "")
-            
-            formatted.append(f"{i}. {text[:100]}... (ID: {event_id})")
-        
-        return "\n".join(formatted) if formatted else "Không tìm thấy sự kiện phù hợp."
-    
-    def _parse_tool_call(self, llm_response: str) -> Optional[Dict]:
-        """
-        Parse LLM response to detect tool calls using structured JSON
-        
-        Returns:
-            {"tool_name": "...", "arguments": {...}} or None
-        """
-        import json
-        import re
-        
-        # Method 1: Look for JSON code block
-        json_match = re.search(r'```json\s*(\{.*?\})\s*```', llm_response, re.DOTALL)
-        if json_match:
-            try:
-                data = json.loads(json_match.group(1))
-                return self._extract_tool_from_json(data)
-            except json.JSONDecodeError:
-                pass
-        
-        # Method 2: Look for inline JSON object
-        # Find all potential JSON objects
-        json_objects = re.findall(r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}', llm_response)
-        for json_str in json_objects:
-            try:
-                data = json.loads(json_str)
-                tool_call = self._extract_tool_from_json(data)
-                if tool_call:
-                    return tool_call
-            except json.JSONDecodeError:
-                continue
-        
-        # Method 3: Nested JSON (for complex structures)
-        try:
-            # Find outermost curly braces
-            if '{' in llm_response and '}' in llm_response:
-                start = llm_response.find('{')
-                # Find matching closing brace
-                count = 0
-                for i, char in enumerate(llm_response[start:], start):
-                    if char == '{':
-                        count += 1
-                    elif char == '}':
-                        count -= 1
-                        if count == 0:
-                            json_str = llm_response[start:i+1]
-                            data = json.loads(json_str)
-                            return self._extract_tool_from_json(data)
-        except (json.JSONDecodeError, ValueError):
-            pass
-        
-        return None
-    
-    def _extract_tool_from_json(self, data: dict) -> Optional[Dict]:
-        """
-        Extract tool call information from parsed JSON
-        
-        Supports multiple formats:
-        - {"tool_call": "search_events", "arguments": {...}}
-        - {"function": "search_events", "parameters": {...}}
-        - {"name": "search_events", "args": {...}}
-        """
-        # Format 1: tool_call + arguments
-        if "tool_call" in data and isinstance(data["tool_call"], str):
-            return {
-                "tool_name": data["tool_call"],
-                "arguments": data.get("arguments", {})
-            }
-        
-        # Format 2: function + parameters
-        if "function" in data:
-            return {
-                "tool_name": data["function"],
-                "arguments": data.get("parameters", data.get("arguments", {}))
-            }
-        
-        # Format 3: name + args
-        if "name" in data:
-            return {
-                "tool_name": data["name"],
-                "arguments": data.get("args", data.get("arguments", {}))
-            }
-        
-        # Format 4: Direct tool name as key
-        valid_tools = ["search_events", "get_event_details", "get_purchased_events", "save_feedback", "save_lead"]
-        for tool in valid_tools:
-            if tool in data:
-                return {
-                    "tool_name": tool,
-                    "arguments": data[tool] if isinstance(data[tool], dict) else {}
-                }
-        
-        return None
-    
-    def _clean_response(self, response: str) -> str:
-        """Remove JSON artifacts from final response"""
-        # Remove JSON blocks
-        if "```json" in response:
-            response = response.split("```json")[0]
-        if "```" in response:
-            response = response.split("```")[0]
-        
-        # Remove tool call markers
-        if "{" in response and "tool_call" in response:
-            # Find the last natural sentence before JSON
-            lines = response.split("\n")
-            cleaned = []
-            for line in lines:
-                if "{" in line and "tool_call" in line:
-                    break
-                cleaned.append(line)
-            response = "\n".join(cleaned)
-        
-        return response.strip()
+"""
+Agent Service - Central Brain for Sales & Feedback Agents
+Manages LLM conversation loop with native tool calling
+"""
+from typing import Dict, Any, List, Optional
+import os
+import json
+from tools_service import ToolsService
+
+
+class AgentService:
+    """
+    Manages the conversation loop between User -> LLM -> Tools -> Response
+    Uses native tool calling via HuggingFace Inference API
+    """
+    
+    def __init__(
+        self,
+        tools_service: ToolsService,
+        embedding_service,
+        qdrant_service,
+        advanced_rag,
+        hf_token: str,
+        feedback_tracking=None  # Optional feedback tracking
+    ):
+        self.tools_service = tools_service
+        self.embedding_service = embedding_service
+        self.qdrant_service = qdrant_service
+        self.advanced_rag = advanced_rag
+        self.hf_token = hf_token
+        self.feedback_tracking = feedback_tracking
+        
+        # Load system prompts
+        self.prompts = self._load_prompts()
+    
+    def _load_prompts(self) -> Dict[str, str]:
+        """Load system prompts from files"""
+        prompts = {}
+        prompts_dir = "prompts"
+        
+        for mode in ["sales_agent", "feedback_agent"]:
+            filepath = os.path.join(prompts_dir, f"{mode}.txt")
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    prompts[mode] = f.read()
+                print(f"✓ Loaded prompt: {mode}")
+            except Exception as e:
+                print(f"⚠️ Error loading {mode} prompt: {e}")
+                prompts[mode] = ""
+        
+        return prompts
+    
+    def _get_native_tools(self, mode: str = "sales") -> List[Dict]:
+        """
+        Get tools formatted for native tool calling API.
+        Returns OpenAI-compatible tool definitions.
+        """
+        common_tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "search_events",
+                    "description": "Tìm kiếm sự kiện phù hợp theo từ khóa, vibe, hoặc thời gian.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "query": {"type": "string", "description": "Từ khóa tìm kiếm (VD: 'nhạc rock', 'hài kịch')"},
+                            "vibe": {"type": "string", "description": "Vibe/Mood (VD: 'chill', 'sôi động', 'hẹn hò')"},
+                            "time": {"type": "string", "description": "Thời gian (VD: 'cuối tuần này', 'tối nay')"}
+                        }
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_event_details",
+                    "description": "Lấy thông tin chi tiết (giá, địa điểm, thời gian) của sự kiện.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "event_id": {"type": "string", "description": "ID của sự kiện (MongoDB ID)"}
+                        },
+                        "required": ["event_id"]
+                    }
+                }
+            }
+        ]
+        
+        sales_tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "save_lead",
+                    "description": "Lưu thông tin khách hàng quan tâm (Lead).",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "email": {"type": "string", "description": "Email address"},
+                            "phone": {"type": "string", "description": "Phone number"},
+                            "interest": {"type": "string", "description": "What they're interested in"}
+                        }
+                    }
+                }
+            }
+        ]
+        
+        feedback_tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "get_purchased_events",
+                    "description": "Kiểm tra lịch sử các sự kiện user đã mua vé hoặc tham gia.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "user_id": {"type": "string", "description": "ID của user"}
+                        },
+                        "required": ["user_id"]
+                    }
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "save_feedback",
+                    "description": "Lưu đánh giá/feedback của user về sự kiện.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "event_id": {"type": "string", "description": "ID sự kiện"},
+                            "rating": {"type": "integer", "description": "Số sao đánh giá (1-5)"},
+                            "comment": {"type": "string", "description": "Nội dung nhận xét"}
+                        },
+                        "required": ["event_id", "rating"]
+                    }
+                }
+            }
+        ]
+        
+        if mode == "feedback":
+            return common_tools + feedback_tools
+        else:
+            return common_tools + sales_tools
+    
+    async def chat(
+        self,
+        user_message: str,
+        conversation_history: List[Dict],
+        mode: str = "sales",  # "sales" or "feedback"
+        user_id: Optional[str] = None,
+        access_token: Optional[str] = None,  # For authenticated API calls
+        max_iterations: int = 3
+    ) -> Dict[str, Any]:
+        """
+        Main conversation loop with native tool calling
+        
+        Args:
+            user_message: User's input
+            conversation_history: Previous messages [{"role": "user", "content": ...}, ...]
+            mode: "sales" or "feedback"
+            user_id: User ID (for feedback mode to check purchase history)
+            access_token: JWT token for authenticated API calls
+            max_iterations: Maximum tool call iterations to prevent infinite loops
+        
+        Returns:
+            {
+                "message": "Bot response",
+                "tool_calls": [...],  # List of tools called (for debugging)
+                "mode": mode
+            }
+        """
+        print(f"\n🤖 Agent Mode: {mode}")
+        print(f"👤 User Message: {user_message}")
+        print(f"🔑 Auth Info:")
+        print(f"  - User ID: {user_id}")
+        print(f"  - Access Token: {'✅ Received' if access_token else '��� None'}")
+        
+        # Store user_id and access_token for tool calls
+        self.current_user_id = user_id
+        self.current_access_token = access_token
+        if access_token:
+            print(f"  - Stored access_token for tools: {access_token[:20]}...")
+        if user_id:
+            print(f"  - Stored user_id for tools: {user_id}")
+        
+        # Select system prompt (without tool instructions - native tools handle this)
+        system_prompt = self._get_system_prompt(mode)
+        
+        # Get native tools for this mode
+        tools = self._get_native_tools(mode)
+        
+        # Build conversation context
+        messages = self._build_messages(system_prompt, conversation_history, user_message)
+        
+        # Agentic loop: LLM may call tools multiple times
+        tool_calls_made = []
+        current_response = None
+        
+        for iteration in range(max_iterations):
+            print(f"\n🔄 Iteration {iteration + 1}")
+            
+            # Call LLM with native tools
+            llm_result = await self._call_llm_with_tools(messages, tools)
+            
+            # Check if this is a final text response or a tool call
+            if llm_result["type"] == "text":
+                current_response = llm_result["content"]
+                print(f"🧠 LLM Final Response: {current_response[:200]}...")
+                break
+            
+            elif llm_result["type"] == "tool_calls":
+                # Process each tool call
+                for tool_call in llm_result["tool_calls"]:
+                    tool_name = tool_call["function"]["name"]
+                    arguments = json.loads(tool_call["function"]["arguments"])
+                    
+                    print(f"🔧 Tool Called: {tool_name}")
+                    print(f"   Arguments: {arguments}")
+                    
+                    # Auto-inject real user_id for get_purchased_events
+                    if tool_name == 'get_purchased_events' and self.current_user_id:
+                        print(f"🔄 Auto-injecting real user_id: {self.current_user_id}")
+                        arguments['user_id'] = self.current_user_id
+                    
+                    # Execute tool
+                    tool_result = await self.tools_service.execute_tool(
+                        tool_name,
+                        arguments,
+                        access_token=self.current_access_token
+                    )
+                    
+                    # Record tool call
+                    tool_calls_made.append({
+                        "function": tool_name,
+                        "arguments": arguments,
+                        "result": tool_result
+                    })
+                    
+                    # Handle RAG search specially
+                    if isinstance(tool_result, dict) and tool_result.get("action") == "run_rag_search":
+                        tool_result = await self._execute_rag_search(tool_result["query"])
+                    
+                    # Add assistant's tool call to messages
+                    messages.append({
+                        "role": "assistant",
+                        "content": None,
+                        "tool_calls": [{
+                            "id": tool_call.get("id", f"call_{iteration}"),
+                            "type": "function",
+                            "function": {
+                                "name": tool_name,
+                                "arguments": json.dumps(arguments)
+                            }
+                        }]
+                    })
+                    
+                    # Add tool result to messages
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.get("id", f"call_{iteration}"),
+                        "content": self._format_tool_result({"result": tool_result})
+                    })
+            
+            elif llm_result["type"] == "error":
+                print(f"⚠️ LLM Error: {llm_result['content']}")
+                current_response = "Xin lỗi, tôi đang gặp chút vấn đề kỹ thuật. Bạn thử lại sau nhé!"
+                break
+        
+        # Get final response if we hit max iterations
+        final_response = current_response or "Tôi cần thêm thông tin để hỗ trợ bạn."
+        
+        return {
+            "message": final_response,
+            "tool_calls": tool_calls_made,
+            "mode": mode
+        }
+    
+    def _get_system_prompt(self, mode: str) -> str:
+        """Get system prompt for selected mode (without tool instructions)"""
+        prompt_key = f"{mode}_agent" if mode in ["sales", "feedback"] else "sales_agent"
+        return self.prompts.get(prompt_key, "")
+    
+    def _build_messages(
+        self,
+        system_prompt: str,
+        history: List[Dict],
+        user_message: str
+    ) -> List[Dict]:
+        """Build messages array for LLM"""
+        messages = [{"role": "system", "content": system_prompt}]
+        
+        # Add conversation history
+        messages.extend(history)
+        
+        # Add current user message
+        messages.append({"role": "user", "content": user_message})
+        
+        return messages
+    
+    async def _call_llm_with_tools(self, messages: List[Dict], tools: List[Dict]) -> Dict:
+        """
+        Call HuggingFace LLM with native tool calling support
+        
+        Returns:
+            {"type": "text", "content": "..."} for text responses
+            {"type": "tool_calls", "tool_calls": [...]} for tool call requests
+            {"type": "error", "content": "..."} for errors
+        """
+        try:
+            from huggingface_hub import AsyncInferenceClient
+            
+            # Create async client
+            client = AsyncInferenceClient(token=self.hf_token)
+            
+            # Call HF API with chat completion and native tools
+            response = await client.chat_completion(
+                messages=messages,
+                model="Qwen/Qwen2.5-72B-Instruct",  # Use Qwen which supports tools
+                max_tokens=512,
+                temperature=0.7,
+                tools=tools,
+                tool_choice="auto"  # Let model decide when to use tools
+            )
+            
+            # Check if the model made tool calls
+            message = response.choices[0].message
+            
+            if message.tool_calls:
+                print(f"🔧 Native tool calls detected: {len(message.tool_calls)}")
+                return {
+                    "type": "tool_calls",
+                    "tool_calls": [
+                        {
+                            "id": tc.id,
+                            "function": {
+                                "name": tc.function.name,
+                                "arguments": tc.function.arguments
+                            }
+                        }
+                        for tc in message.tool_calls
+                    ]
+                }
+            else:
+                # Regular text response
+                return {
+                    "type": "text",
+                    "content": message.content or ""
+                }
+                
+        except Exception as e:
+            print(f"⚠️ LLM Call Error: {e}")
+            return {
+                "type": "error",
+                "content": str(e)
+            }
+    
+    def _format_tool_result(self, tool_result: Dict) -> str:
+        """Format tool result for feeding back to LLM"""
+        result = tool_result.get("result", {})
+        
+        # Special handling for purchased events list
+        if isinstance(result, list):
+            print(f"\n🔍 Formatting {len(result)} purchased events for LLM")
+            if not result:
+                return "User has not purchased any events yet."
+            
+            # Format each event clearly
+            formatted_events = []
+            for i, event in enumerate(result, 1):
+                event_info = []
+                event_info.append(f"Event {i}:")
+                
+                # Extract key fields
+                if 'eventName' in event:
+                    event_info.append(f"  Name: {event['eventName']}")
+                if 'eventCode' in event:
+                    event_info.append(f"  Code: {event['eventCode']}")
+                if '_id' in event:
+                    event_info.append(f"  ID: {event['_id']}")
+                if 'startTimeEventTime' in event:
+                    event_info.append(f"  Date: {event['startTimeEventTime']}")
+                
+                formatted_events.append("\n".join(event_info))
+            
+            formatted = "User's Purchased Events:\n\n" + "\n\n".join(formatted_events)
+            print(f"📤 Sending to LLM:\n{formatted}")
+            return formatted
+        
+        # Default formatting for other results
+        if isinstance(result, dict):
+            # Pretty print key info
+            formatted = []
+            for key, value in result.items():
+                if key not in ["success", "error"]:
+                    formatted.append(f"{key}: {value}")
+            return "\n".join(formatted) if formatted else json.dumps(result)
+        
+        return str(result)
+    
+    async def _execute_rag_search(self, query_params: Dict) -> str:
+        """
+        Execute RAG search for event discovery
+        Called when LLM wants to search_events
+        """
+        query = query_params.get("query", "")
+        vibe = query_params.get("vibe", "")
+        
+        # Build search query
+        search_text = f"{query} {vibe}".strip()
+        
+        print(f"🔍 RAG Search: {search_text}")
+        
+        # Use embedding + qdrant
+        embedding = self.embedding_service.encode_text(search_text)
+        results = self.qdrant_service.search(
+            query_embedding=embedding,
+            limit=5
+        )
+        
+        # Format results
+        formatted = []
+        for i, result in enumerate(results, 1):
+            # Result is a dict with keys: id, score, payload
+            payload = result.get("payload", {})
+            texts = payload.get("texts", [])
+            text = texts[0] if texts else ""
+            event_id = payload.get("id_use", "")
+            
+            formatted.append(f"{i}. {text[:100]}... (ID: {event_id})")
+        
+        return "\n".join(formatted) if formatted else "Không tìm thấy sự kiện phù hợp."

feedback_tracking_service.py

@@ -101,3 +101,35 @@ class FeedbackTrackingService:
             if event_code and not self.has_given_feedback(user_id, event_code):
                 pending.append(event)
         return pending
+
+    def get_feedbacked_events(self, user_id: str) -> list:
+        """
+        Get all events where a user has already given feedback (is_feedback: True)
+        
+        Args:
+            user_id: User ID
+        
+        Returns:
+            List of event_codes with feedback info
+        """
+        try:
+            results = self.collection.find({
+                "user_id": user_id,
+                "is_feedback": True
+            })
+            
+            feedbacked = []
+            for doc in results:
+                feedbacked.append({
+                    "event_code": doc.get("event_code"),
+                    "rating": doc.get("rating"),
+                    "comment": doc.get("comment"),
+                    "feedback_date": doc.get("feedback_date")
+                })
+            
+            print(f"📋 Found {len(feedbacked)} feedbacked events for user {user_id}")
+            return feedbacked
+        except Exception as e:
+            print(f"❌ Error getting feedbacked events: {e}")
+            return []
+

main.py

@@ -49,8 +49,9 @@ qdrant_service = QdrantVectorService(
     vector_size=embedding_service.get_embedding_dimension()
 )
 print(f"✓ Qdrant collection: {collection_name}")
+
 # MongoDB connection
-mongodb_uri = os.getenv("MONGODB_URI")
+mongodb_uri = os.getenv("MONGODB_URI", "mongodb+srv://truongtn7122003:7KaI9OT5KTUxWjVI@truongtn7122003.xogin4q.mongodb.net/")
 mongo_client = MongoClient(mongodb_uri)
 db = mongo_client[os.getenv("MONGODB_DB_NAME", "chatbot_rag")]
 documents_collection = db["documents"]
@@ -708,6 +709,44 @@ async def get_stats():
 # Old endpoints removed - now using Agentic Workflow via /agent/chat
 
 
+# ============================================
+# Feedback Tracking Endpoints
+# ============================================
+
+@app.get("/feedback/events/{user_id}")
+async def get_feedbacked_events(user_id: str):
+    """
+    Get all events where user has already given feedback (is_feedback: True)
+    
+    Args:
+        user_id: User ID
+    
+    Returns:
+        List of event_codes with feedback info (rating, comment, date)
+        
+    Example:
+    ```
+    GET /feedback/events/68bc0dfdfb475cb420ae1e4e
+    
+    Response:
+    {
+      "user_id": "68bc0dfdfb475cb420ae1e4e",
+      "count": 2,
+      "events": [
+        {"event_code": "EVT001", "rating": 5, "comment": "Tuyệt vời!", "feedback_date": "..."},
+        {"event_code": "EVT002", "rating": 4, "comment": "Hay", "feedback_date": "..."}
+      ]
+    }
+    ```
+    """
+    feedbacked = feedback_tracking.get_feedbacked_events(user_id)
+    
+    return {
+        "user_id": user_id,
+        "count": len(feedbacked),
+        "events": feedbacked
+    }
+
 
 @app.get("/chat/history/{session_id}")
 async def get_conversation_history(session_id: str, include_metadata: bool = False):

prompts/feedback_agent.txt

@@ -7,45 +7,72 @@ Nhiệm vụ của bạn là lắng nghe phản hồi của khách hàng sau khi
 2. Nếu CÓ: Xin đánh giá (feedback), cảm nhận để cải thiện dịch vụ.
 3. Nếu KHÔNG (hoặc đã feedback xong): Giới thiệu các sự kiện mới hấp dẫn (chuyển sang vai trò Sales).
 
+# CRITICAL RULES - ĐỌC KỸ TRƯỚC KHI TRẢ LỜI
+⚠️ **TUYỆT ĐỐI KHÔNG ĐƯỢC BỊA DATA:**
+- KHÔNG BAO GIỜ tự nghĩ ra tên sự kiện (như "Show Hà Anh Tuấn", "Rock Việt", etc.)
+- PHẢI gọi tool `get_purchased_events` và CHỜ kết quả THỰC từ API
+- Chỉ sử dụng tên sự kiện từ kết quả tool trả về (field: eventName, eventCode)
+- Nếu chưa có kết quả tool, KHÔNG được đề cập tên sự kiện cụ thể nào
+
 # CAPABILITIES (TOOLS)
-1. `get_purchased_events(user_id)`: Kiểm tra lịch sử mua vé/tham gia sự kiện của khách hàng.
+1. `get_purchased_events(user_id)`: Kiểm tra lịch sử mua vé - **BẮT BUỘC gọi đầu tiên**
 2. `save_feedback(event_id, rating, comment)`: Lưu đánh giá của khách hàng (rating 1-5 sao).
 3. `search_events(...)`: Tìm sự kiện mới (nếu khách muốn đi tiếp).
 
 # GUIDELINES
 
-## Phase 1: Check History (Luôn thực hiện đầu tiên)
-- Ngay khi bắt đầu hội thoại, hãy gọi `get_purchased_events(user_id)` ngầm (không cần hỏi khách).
-- **Trường hợp A: Khách chưa từng đi sự kiện nào (hoặc API trả về rỗng)**
-  - Chuyển ngay sang mode tư vấn: "Chào bạn! Bạn đang tìm kiếm sự kiện gì thú vị cho tuần này không? Bên mình đang có nhiều show hay lắm! 🎉"
-  - (Sau đó hành xử như Sales Agent).
-
-- **Trường hợp B: Khách ĐÃ đi sự kiện (ví dụ: "Show Hà Anh Tuấn")**
-  - Mở đầu bằng lời chào ấm áp: "Chào bạn! Cảm ơn bạn đã tham gia show **Hà Anh Tuấn** vừa rồi. Hy vọng bạn đã có những giây phút tuyệt vời! 🥰"
-  - Hỏi thăm cảm nhận: "Bạn thấy không khí hôm đó thế nào? Có điều gì làm bạn chưa hài lòng không?"
-
-## Phase 2: Collect Feedback (Nếu khách đã đi)
-- Lắng nghe khách chia sẻ.
-- Nếu khách khen: "Tuyệt quá! Bạn chấm cho sự kiện mấy sao nè? (1-5 sao) ⭐"
-- Nếu khách chê: Tỏ ra đồng cảm, xin lỗi và hứa cải thiện. "Dạ mình rất tiếc về trải nghiệm này. Mình sẽ ghi nhận ngay để BTC rút kinh nghiệm ạ."
-- Sau khi khách chấm điểm/comment -> Gọi `save_feedback`.
-
-## Phase 3: Transition to Sales (Sau khi feedback xong)
-- Sau khi đã lưu feedback, hãy khéo léo giới thiệu sự kiện mới:
-  "Cảm ơn bạn đã góp ý nha! À, sắp tới bên mình có show **Mỹ Tâm** cũng vibe tương tự, bạn có muốn xem qua không?"
-- Nếu khách quan tâm -> Dùng `search_events` và tư vấn tiếp.
-
-# EXAMPLES
-
-**Case 1: Có lịch sử đi event**
-System: (User ID 123 -> get_purchased_events -> ["Show Rock Việt"])
-Agent: "Chào bạn! Cảm ơn bạn đã cháy hết mình tại **Show Rock Việt** hôm qua! 🤘 Bạn thấy ban nhạc diễn có sung không?"
-User: "Sung lắm, nhưng âm thanh hơi rè."
-Agent: "Dạ mình ghi nhận góp ý về âm thanh ạ. Cảm ơn bạn nhiều. Bạn chấm show này mấy điểm trên thang 5 sao nè?"
-User: "4 sao thôi."
-Agent (Call Tool): save_feedback(event_id="rock_viet", rating=4, comment="Sung nhưng âm thanh rè")
-Agent: "Dạ mình đã lưu lại rồi ạ. À sắp tới có **RockStorm** âm thanh xịn hơn, bạn có hóng không? 🔥"
-
-**Case 2: Không có lịch sử**
-System: (User ID 456 -> get_purchased_events -> [])
-Agent: "Chào bạn! 👋 Cuối tuần này bạn đã có kế hoạch đi đâu chơi chưa? Bên mình đang có mấy show Acoustic chill lắm nè!"
+## Phase 1: Check History & Natural Opening (BẮT BUỘC)
+- **Logics:**
+  - Agent cần ngầm hiểu trạng thái: `awaiting_feedback`, `awaiting_rating`, `feedback_saved`.
+  - Nếu API trả về nhiều sự kiện: Ưu tiên chọn sự kiện có ngày diễn ra (`eventDate`) gần nhất trong quá khứ.
+- **Action:** Gọi tool `get_purchased_events(user_id)` NGAY LẬP TỨC.
+- **Greeting (Tự nhiên & Quan sát):**
+  - *Có sự kiện:* "Hi bạn 👋 Mình thấy bạn vừa tham gia **[eventName]** gần đây nè. Không biết trải nghiệm của bạn thế nào? ✨"
+  - *Không sự kiện:* "Chào bạn! TicketBot chưa thấy bạn tham gia sự kiện gần đây. Bạn đang tìm kèo đi chơi sắp tới phải không? 🎉" (Chuyển mode Sales)
+
+## Phase 2: Empathy & Adaptive Feedback (Customer Success)
+- **Nguyên tắc "Đồng cảm đi trước":**
+  - *Khách khen:* "Chuẩn bài! Năng lượng đó chỉ có thể là 10/10 đúng không? 😄"
+  - *Khách chê:* "TicketBot rất tiếc vì trải nghiệm chưa trọn vẹn này ���. Mình hoàn toàn hiểu cảm giác của bạn."
+- **Adaptive Questioning (Hỏi thông minh):**
+  - Nếu Rating 5 sao: "Điều gì làm bạn ấn tượng nhất? Âm nhạc hay không khí?"
+  - Nếu Rating < 3 sao: "Điều gì làm bạn 'xu cà na' nhất? Âm thanh, tổ chức hay gì khác ạ?"
+- **Action:** Sau khi khách chốt đánh giá -> Gọi `save_feedback`.
+
+## Phase 3: Resolution & Closing (Làm tròn cảm xúc)
+- **Mục tiêu:** Đóng lại vòng feedback một cách trọn vẹn TRƯỚC khi bán hàng.
+- **Action:**
+  1. Xác nhận đã lưu: "TicketBot đã lưu lại đánh giá của bạn rồi nhé! Cảm ơn bạn rất nhiều. 💖"
+  2. **Xử lý cảm xúc:**
+     - *Nếu Feedback Tốt:* "Team tổ chức nghe được chắc vui lắm đây! 🎉"
+     - *Nếu Feedback Xấu:* (Đã xử lý ở Phase 2, ở đây chỉ cần cảm ơn sự chia sẻ thẳng thắn).
+  3. **Tạm dừng một nhịp:** Đảm bảo khách cảm thấy được lắng nghe xong xuôi.
+
+## Phase 4: Sales Transition (The Pivot)
+- **Mục tiêu:** Chuyển sang bán hàng nhưng phải xin phép (Permission Marketing).
+- **Logics:** CHỈ chuyển qua bước này khi Phase 3 đã xong.
+- **Câu dẫn (Pivot):**
+  - "Vì bạn đã có trải nghiệm [vui/đáng nhớ] như vậy..."
+  - "Để bù đắp cho trải nghiệm chưa tốt hôm nay..."
+  - -> "Bạn có muốn mình tìm show khác phù hợp hơn/vui hơn cho tuần tới không? 🎉"
+
+# WORKFLOW EXAMPLE
+
+**Bước 1: User gửi tin nhắn đầu tiên**
+User: "Xin chào"
+
+**Bước 2: Agent PHẢI gọi tool trước (output JSON)**
+```json
+{"tool_call": "get_purchased_events", "arguments": {"user_id": "[user_id thực]"}}
+```
+
+**Bước 3: Chờ Tool Result từ hệ thống**
+Tool Result sẽ trả về dạng:
+- Có sự kiện: `[{"eventName": "Tên sự kiện thực", "eventCode": "ABC123", "_id": "..."}]`
+- Không có: `[]`
+
+**Bước 4: Agent phản hồi dựa trên kết quả THỰC**
+- Nếu có event: Dùng eventName từ result để chào
+- Nếu không có: Chuyển sang tư vấn sự kiện mới
+
+⚠️ LƯU Ý: Các ví dụ trên chỉ minh họa flow, KHÔNG sử dụng tên sự kiện trong ví dụ!

prompts/sales_agent.txt

@@ -12,13 +12,14 @@ Bạn có quyền truy cập các công cụ sau (hãy sử dụng chúng khi c
 3. `save_lead(email, phone, interest)`: Lưu thông tin khách hàng khi họ quan tâm hoặc muốn nhận tư vấn thêm.
 
 # GUIDELINES
-1. **Khơi gợi nhu cầu (Consultative Selling):**
-   - Đừng chỉ hỏi "Bạn muốn gì?". Hãy hỏi mở: "Cuối tuần này bạn rảnh không? Bạn đang mood muốn 'quẩy' hay chill nhẹ nhàng?"
-   - Nếu khách chưa rõ, hãy gợi ý dựa trên các vibe phổ biến: Hài kịch, Nhạc Indie, Workshop, EDM...
+1. **Khơi gợi nhu cầu (Consultative Selling - Trusted Advisor):**
+   - **Pain Point Agitation:** Đừng hỏi máy móc. Hãy hỏi thăm trạng thái khách: "Cuối tuần rồi làm việc căng thẳng không? Bạn cần tìm nơi 'xả stress' cháy phố hay chỉ muốn chill nhẹ nhàng healing?"
+   - **Authority & Curation:** Dùng các cụm từ thể hiện sự sành sỏi: "TicketBot mách nhỏ nè", "Kèo này đang hot rần rần", "Editor's Choice tuần này là...".
 
-2. **Tư vấn thông minh:**
-   - Khi khách hỏi giá, đừng chỉ đưa con số. Hãy kèm giá trị: "Vé hạng A giá 500k nhưng view siêu đẹp, còn hạng B 300k thì tiết kiệm hơn."
-   - Luôn đề xuất thêm (Upsell/Cross-sell) nếu phù hợp: "Đi nhóm 4 người đang có combo giảm 10% đó ạ."
+2. **Tư vấn thông minh & FOMO:**
+   - **Social Proof:** "Show này đang trending top 1 Sài Gòn đó", "Dân tình check-in ở đây nhiều lắm".
+   - **Scarcity (Khan hiếm):** "Vé hạng này sắp sold-out rồi", "Chỉ còn vài slot view đẹp thôi".
+   - **Upsell khéo:** "Đi 4 người có combo tiết kiệm hơn 20% lận nha".
 
 3. **Sử dụng Tools khéo léo:**
    - Khi khách hỏi "có sự kiện gì?", HÃY gọi `search_events`. Đừng tự bịa ra sự kiện.
@@ -29,10 +30,33 @@ Bạn có quyền truy cập các công cụ sau (hãy sử dụng chúng khi c
      "Sự kiện này đang hot lắm, bạn cho mình xin email để mình gửi link đặt vé giữ chỗ ngay nhé?"
    - Hoặc: "Mình gửi lịch diễn chi tiết qua Zalo/Email cho bạn tiện xem nha?" -> Gọi `save_lead`.
 
-5. **Tone & Voice:**
-   - Thân thiện, trẻ trung, dùng emoji tự nhiên (😄, 🎉, 🔥).
-   - Không quá cứng nhắc như robot.
-   - Nếu khách hỏi ngoài lề (off-topic), hãy trả lời ngắn gọn rồi khéo léo lái về chủ đề sự kiện.
+5. **Nhận diện Mức độ quan tâm (Intent Recognition):**
+   - **Warm Lead:** Khách hỏi giá -> Tín hiệu quan tâm. -> "Giá vé đang siêu tốt, bạn muốn mình tư vấn hạng vé nào không?"
+   - **Hot Lead:** Khách hỏi chi tiết nghệ sĩ, view chỗ ngồi -> Tín hiệu MẠNH. -> "Show này hot lắm nha 🔥. Hãy chủ động đề xuất: 'Còn vài slot view đẹp, mình giữ chỗ giúp bạn nhé? Cho mình xin SĐT hoặc Email ạ?'"
+
+6. **Xử lý khi không tìm thấy sự kiện (Zero Results):**
+   - Tuyệt đối không nói "Không tìm thấy" rồi im lặng.
+   - Hãy nói: "Tiếc quá, hiện chưa có show đúng ý bạn rồi 😢. Nhưng mình thấy có mấy show này cũng vibe tương tự/thời gian gần đó nè..." -> Gợi ý vibe/category khác.
+
+7. **Xử lý từ chối (Objection Handling):**
+   - Khách nói "Để xem đã..." -> "Oki nè, mình gửi bạn link sự kiện để tiện xem lại nha. Cần gì cứ ới TicketBot nhé!"
+   - Khách nói "Giá cao quá" -> "Giá này là bao gồm cả nước uống và view xịn đó ạ. Hoặc nhóm mình đi 4 người sẽ có combo tiết kiệm hơn á! 👯‍♀️"
+
+8. **Tone & Voice (Trẻ trung & Sôi nổi):**
+   - Sử dụng ngôn ngữ đời thường, ngắn gọn.
+   - Dùng icon linh hoạt: 🔥, 💃, 🎸, 🍻, ✨.
+   - Luôn tạo cảm giác khan hiếm nhưng không áp lực: "Show này sắp cháy vé rồi", "Còn ít slot lắm".
+
+9. **QUY TẮC ĐỊNH DẠNG (BẮT BUỘC):**
+   - **Tuyệt đối không viết liền tù tì (wall of text).**
+   - Khi liệt kê các sự kiện, PHẢI dùng gạch đầu dòng (bullet points) hoặc số thứ tự.
+   - Mỗi sự kiện phải xuống dòng rõ ràng.
+   - Sử dụng **in đậm** cho Tên sự kiện và Giá vé.
+   - Ví dụ định dạng đúng:
+     * **Tên Sự Kiện** - Giá: **500k**
+       Mô tả ngắn...
+     * **Sự Kiện Khác** - Giá: **300k**
+       Mô tả ngắn...
 
 # EXAMPLES
 

tools_service.py

@@ -190,6 +190,16 @@ class ToolsService:
                 print(f"✅ Success! Data keys: {list(data.keys())}")
                 events = data.get("data", [])
                 print(f"📊 Found {len(events)} purchased events")
+                
+                # Log actual event data
+                if events:
+                    print(f"\n📋 Purchased Events Details:")
+                    for i, event in enumerate(events, 1):
+                        print(f"{i}. Event Code: {event.get('eventCode', 'N/A')}")
+                        print(f"   Event Name: {event.get('eventName', 'N/A')}")
+                        print(f"   Event ID: {event.get('_id', 'N/A')}")
+                        print(f"   Full data: {event}")
+                
                 return events
             else:
                 print(f"❌ API Error: {response.status_code}")