Upload 14 files

chat_endpoint.py

@@ -0,0 +1,261 @@
+"""
+Chat endpoint với Multi-turn Conversation + Function Calling
+"""
+from fastapi import HTTPException
+from datetime import datetime
+from huggingface_hub import InferenceClient
+from typing import Dict, List
+import json
+
+
+async def chat_endpoint(
+    request,  # ChatRequest
+    conversation_service,
+    tools_service,
+    advanced_rag,
+    embedding_service,
+    qdrant_service,
+    chat_history_collection,
+    hf_token
+):
+    """
+    Multi-turn conversational chatbot với RAG + Function Calling
+    
+    Flow:
+    1. Session management - create hoặc load existing session
+    2. RAG search - retrieve context nếu enabled
+    3. Build messages với conversation history +  tools prompt
+    4. LLM generation - có thể trigger tool calls
+    5. Execute tools nếu cần
+    6. Final LLM response với tool results
+    7. Save to conversation history
+    """
+    try:
+        # ===== 1. SESSION MANAGEMENT =====
+        session_id = request.session_id
+        if not session_id:
+            # Create new session (server-side)
+            session_id = conversation_service.create_session(
+                metadata={"user_agent": "api", "created_via": "chat_endpoint"}
+            )
+            print(f"Created new session: {session_id}")
+        else:
+            # Validate existing session
+            if not conversation_service.session_exists(session_id):
+                raise HTTPException(
+                    status_code=404, 
+                    detail=f"Session {session_id} not found. It may have expired."
+                )
+        
+        # Load conversation history
+        conversation_history = conversation_service.get_conversation_history(session_id)
+        
+        # ===== 2. RAG SEARCH =====
+        context_used = []
+        rag_stats = None
+        context_text = ""
+        
+        if request.use_rag:
+            if request.use_advanced_rag:
+                # Use Advanced RAG Pipeline
+                hf_client = None
+                if request.hf_token or hf_token:
+                    hf_client = InferenceClient(token=request.hf_token or hf_token)
+                
+                documents, stats = advanced_rag.hybrid_rag_pipeline(
+                    query=request.message,
+                    top_k=request.top_k,
+                    score_threshold=request.score_threshold,
+                    use_reranking=request.use_reranking,
+                    use_compression=request.use_compression,
+                    use_query_expansion=request.use_query_expansion,
+                    max_context_tokens=500,
+                    hf_client=hf_client
+                )
+                
+                # Convert to dict format
+                context_used = [
+                    {
+                        "id": doc.id,
+                        "confidence": doc.confidence,
+                        "metadata": doc.metadata
+                    }
+                    for doc in documents
+                ]
+                rag_stats = stats
+                
+                # Format context
+                context_text = advanced_rag.format_context_for_llm(documents)
+            else:
+                # Basic 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
+                )
+                context_used = results
+                
+                context_text = "\n\nRelevant Context:\n"
+                for i, doc in enumerate(context_used, 1):
+                    doc_text = doc["metadata"].get("text", "")
+                    if not doc_text:
+                        doc_text = " ".join(doc["metadata"].get("texts", []))
+                    confidence = doc["confidence"]
+                    context_text += f"\n[{i}] (Confidence: {confidence:.2f})\n{doc_text}\n"
+        
+        # ===== 3. BUILD MESSAGES với TOOLS PROMPT =====
+        messages = []
+        
+        # System message với RAG context + Tools instruction
+        if request.use_rag and context_used:
+            if request.use_advanced_rag:
+                base_prompt = advanced_rag.build_rag_prompt(
+                    query="",  # Query sẽ đi trong user message
+                    context=context_text,
+                    system_message=request.system_message
+                )
+            else:
+                base_prompt = f"""{request.system_message}
+
+{context_text}
+
+HƯỚNG DẪN:
+- Sử dụng thông tin từ context trên để trả lời câu hỏi.
+- Trả lời tự nhiên, thân thiện, không copy nguyên văn.
+- Nếu tìm thấy sự kiện, hãy tóm tắt các thông tin quan trọng nhất.
+"""
+        else:
+            base_prompt = request.system_message
+        
+        # Add tools instruction nếu enabled
+        if request.enable_tools:
+            tools_prompt = tools_service.get_tools_prompt()
+            system_message_with_tools = f"{base_prompt}\n\n{tools_prompt}"
+        else:
+            system_message_with_tools = base_prompt
+        
+        # Bắt đầu messages với system
+        messages.append({"role": "system", "content": system_message_with_tools})
+        
+        # Add conversation history (past turns)
+        messages.extend(conversation_history)
+        
+        # Add current user message
+        messages.append({"role": "user", "content": request.message})
+        
+        # ===== 4. LLM GENERATION =====
+        token = request.hf_token or hf_token
+        tool_calls_made = []
+        
+        if not token:
+            response = f"""[LLM Response Placeholder]
+
+Context retrieved: {len(context_used)} documents
+User question: {request.message}
+Session: {session_id}
+
+To enable actual LLM generation:
+1. Set HUGGINGFACE_TOKEN environment variable, OR
+2. Pass hf_token in request body
+"""
+        else:
+            try:
+                client = InferenceClient(
+                    token=token,
+                    model="openai/gpt-oss-20b"  # Hoặc model khác
+                )
+                
+                # First LLM call
+                first_response = ""
+                for msg in client.chat_completion(
+                    messages,
+                    max_tokens=request.max_tokens,
+                    stream=True,
+                    temperature=request.temperature,
+                    top_p=request.top_p,
+                ):
+                    choices = msg.choices
+                    if len(choices) and choices[0].delta.content:
+                        first_response += choices[0].delta.content
+                
+                # ===== 5. PARSE & EXECUTE TOOLS =====
+                if request.enable_tools:
+                    tool_result = await tools_service.parse_and_execute(first_response)
+                    
+                    if tool_result:
+                        # Tool was called!
+                        tool_calls_made.append(tool_result)
+                        
+                        # Add tool result to messages
+                        messages.append({"role": "assistant", "content": first_response})
+                        messages.append({
+                            "role": "user", 
+                            "content": f"TOOL RESULT:\n{json.dumps(tool_result['result'], ensure_ascii=False, indent=2)}\n\nHãy dùng thông tin này để trả lời câu hỏi của user."
+                        })
+                        
+                        # Second LLM call với tool results
+                        final_response = ""
+                        for msg in client.chat_completion(
+                            messages,
+                            max_tokens=request.max_tokens,
+                            stream=True,
+                            temperature=request.temperature,
+                            top_p=request.top_p,
+                        ):
+                            choices = msg.choices
+                            if len(choices) and choices[0].delta.content:
+                                final_response += choices[0].delta.content
+                        
+                        response = final_response
+                    else:
+                        # No tool call, use first response
+                        response = first_response
+                else:
+                    response = first_response
+                
+            except Exception as e:
+                response = f"Error generating response with LLM: {str(e)}\n\nContext was retrieved successfully, but LLM generation failed."
+        
+        # ===== 6. SAVE TO CONVERSATION HISTORY =====
+        conversation_service.add_message(
+            session_id, 
+            "user", 
+            request.message
+        )
+        conversation_service.add_message(
+            session_id, 
+            "assistant", 
+            response,
+            metadata={
+                "rag_stats": rag_stats,
+                "tool_calls": tool_calls_made,
+                "context_count": len(context_used)
+            }
+        )
+        
+        # Also save to legacy chat_history collection
+        chat_data = {
+            "session_id": session_id,
+            "user_message": request.message,
+            "assistant_response": response,
+            "context_used": context_used,
+            "tool_calls": tool_calls_made,
+            "timestamp": datetime.utcnow()
+        }
+        chat_history_collection.insert_one(chat_data)
+        
+        # ===== 7. RETURN RESPONSE =====
+        return {
+            "response": response,
+            "context_used": context_used,
+            "timestamp": datetime.utcnow().isoformat(),
+            "rag_stats": rag_stats,
+            "session_id": session_id,
+            "tool_calls": tool_calls_made if tool_calls_made else None
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")

chat_routes_integration.py

@@ -0,0 +1,116 @@
+# Integration code để thêm vào main.py
+
+# ADD THIS IMPORT near line 20:
+from chat_endpoint import chat_endpoint
+
+# ADD THESE ROUTES before "if __name__ == '__main__':" (around line 1000):
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat(request: ChatRequest):
+    """
+    Multi-turn conversational chatbot với RAG + Function Calling
+    
+    Features:
+    - Server-side session management
+    - Conversation history tracking 
+    - RAG context retrieval
+    - Function calling (API integration)
+    
+    Example:
+    ```
+    # First message - creates session
+    POST /chat
+    {
+      "message": "Tìm sự kiện hòa nhạc",
+      "use_rag": true
+    }
+    Response: { "session_id": "abc-123", ... }
+    
+    # Follow-up message - uses session
+    POST /chat
+    {
+      "message": "Ngày tổ chức chính xác là khi nào?",
+      "session_id": "abc-123"
+    }
+    # Bot understands context và calls API nếu cần
+    ```
+    """
+    return await chat_endpoint(
+        request=request,
+        conversation_service=conversation_service,
+        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
+    )
+
+
+@app.post("/chat/clear-session")
+async def clear_chat_session(session_id: str):
+    """
+    Clear conversation history cho một session
+    
+    Args:
+        session_id: Session identifier to clear
+    
+    Returns:
+        Success message
+    
+    Example:
+    ```
+    POST /chat/clear-session?session_id=abc-123
+    ```
+    """
+    success = conversation_service.clear_session(session_id)
+    
+    if success:
+        return {
+            "success": True,
+            "message": f"Session {session_id} cleared successfully"
+        }
+    else:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Session {session_id} not found or already cleared"
+        )
+
+
+@app.get("/chat/session/{session_id}")
+async def get_session_info(session_id: str):
+    """
+    Get thông tin về một conversation session
+    
+    Args:
+        session_id: Session identifier
+    
+    Returns:
+        Session metadata và message count
+    
+    Example:
+    ```
+    GET /chat/session/abc-123
+    ```
+    """
+    session = conversation_service.get_session_info(session_id)
+    
+    if not session:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Session {session_id} not found"
+        )
+    
+    # Get message count
+    history = conversation_service.get_conversation_history(
+        session_id, 
+        include_metadata=True
+    )
+    
+    return {
+        "session_id": session["session_id"],
+        "created_at": session["created_at"],
+        "updated_at": session["updated_at"],
+        "message_count": len(history),
+        "metadata": session.get("metadata", {})
+    }

conversation_service.py

@@ -0,0 +1,184 @@
+"""
+Conversation Service for Multi-turn Chat
+Server-side session management
+"""
+from typing import List, Dict, Optional
+from datetime import datetime
+from pymongo.collection import Collection
+import uuid
+
+
+class ConversationService:
+    """
+    Manages multi-turn conversation history với server-side session
+    """
+    
+    def __init__(self, mongo_collection: Collection, max_history: int = 10):
+        """
+        Args:
+            mongo_collection: MongoDB collection for storing conversations
+            max_history: Maximum số messages giữ lại (sliding window)
+        """
+        self.collection = mongo_collection
+        self.max_history = max_history
+        
+        # Create indexes
+        self._ensure_indexes()
+    
+    def _ensure_indexes(self):
+        """Create necessary indexes"""
+        try:
+            self.collection.create_index("session_id", unique=True)
+            # Auto-delete sessions sau 7 ngày không dùng
+            self.collection.create_index(
+                "updated_at", 
+                expireAfterSeconds=604800  # 7 days
+            )
+            print("✓ Conversation indexes created")
+        except Exception as e:
+            print(f"Conversation indexes already exist or error: {e}")
+    
+    def create_session(self, metadata: Optional[Dict] = None) -> str:
+        """
+        Create new conversation session
+        
+        Returns:
+            session_id (UUID string)
+        """
+        session_id = str(uuid.uuid4())
+        
+        self.collection.insert_one({
+            "session_id": session_id,
+            "messages": [],
+            "metadata": metadata or {},
+            "created_at": datetime.utcnow(),
+            "updated_at": datetime.utcnow()
+        })
+        
+        return session_id
+    
+    def add_message(
+        self, 
+        session_id: str, 
+        role: str, 
+        content: str,
+        metadata: Optional[Dict] = None
+    ):
+        """
+        Add message to conversation history
+        
+        Args:
+            session_id: Session identifier
+            role: "user" or "assistant"
+            content: Message text
+            metadata: Additional info (rag_stats, tool_calls, etc.)
+        """
+        message = {
+            "role": role,
+            "content": content,
+            "timestamp": datetime.utcnow().isoformat(),
+            "metadata": metadata or {}
+        }
+        
+        # Upsert: tạo session nếu chưa tồn tại
+        self.collection.update_one(
+            {"session_id": session_id},
+            {
+                "$push": {
+                    "messages": {
+                        "$each": [message],
+                        "$slice": -self.max_history  # Keep only last N messages
+                    }
+                },
+                "$set": {"updated_at": datetime.utcnow()}
+            },
+            upsert=True
+        )
+    
+    def get_conversation_history(
+        self, 
+        session_id: str,
+        limit: Optional[int] = None,
+        include_metadata: bool = False
+    ) -> List[Dict]:
+        """
+        Get conversation messages for LLM context
+        
+        Args:
+            session_id: Session identifier
+            limit: Override max_history với số lượng tùy chỉnh
+            include_metadata: Include metadata trong response
+        
+        Returns:
+            List of messages in format: [{"role": "user", "content": "..."}, ...]
+        """
+        session = self.collection.find_one({"session_id": session_id})
+        
+        if not session:
+            return []
+        
+        messages = session.get("messages", [])
+        
+        # Limit to recent messages
+        if limit:
+            messages = messages[-limit:]
+        else:
+            messages = messages[-self.max_history:]
+        
+        # Format for LLM
+        if include_metadata:
+            return messages
+        else:
+            return [
+                {
+                    "role": msg["role"],
+                    "content": msg["content"]
+                }
+                for msg in messages
+            ]
+    
+    def get_session_info(self, session_id: str) -> Optional[Dict]:
+        """
+        Get session metadata
+        
+        Returns:
+            Session info hoặc None nếu không tồn tại
+        """
+        session = self.collection.find_one(
+            {"session_id": session_id},
+            {"_id": 0, "session_id": 1, "created_at": 1, "updated_at": 1, "metadata": 1}
+        )
+        return session
+    
+    def clear_session(self, session_id: str) -> bool:
+        """
+        Clear conversation history for session
+        
+        Returns:
+            True nếu xóa thành công, False nếu session không tồn tại
+        """
+        result = self.collection.delete_one({"session_id": session_id})
+        return result.deleted_count > 0
+    
+    def session_exists(self, session_id: str) -> bool:
+        """
+        Check if session exists
+        """
+        return self.collection.count_documents({"session_id": session_id}) > 0
+    
+    def get_last_user_message(self, session_id: str) -> Optional[str]:
+        """
+        Get the last user message in conversation
+        Useful for context extraction
+        """
+        session = self.collection.find_one({"session_id": session_id})
+        if not session:
+            return None
+        
+        messages = session.get("messages", [])
+        # Tìm message cuối cùng từ user
+        for msg in reversed(messages):
+            if msg["role"] == "user":
+                return msg["content"]
+        
+        return None

main.py

@@ -17,6 +17,8 @@ from advanced_rag import AdvancedRAG
 from cag_service import CAGService
 from pdf_parser import PDFIndexer
 from multimodal_pdf_parser import MultimodalPDFIndexer
+from conversation_service import ConversationService
+from tools_service import ToolsService
 
 # Initialize FastAPI app
 app = FastAPI(
@@ -96,6 +98,15 @@ multimodal_pdf_indexer = MultimodalPDFIndexer(
 )
 print("✓ Multimodal PDF Indexer initialized")
 
+# Initialize Conversation Service
+conversations_collection = db["conversations"]
+conversation_service = ConversationService(conversations_collection, max_history=10)
+print("✓ Conversation Service initialized")
+
+# Initialize Tools Service
+tools_service = ToolsService(base_url="https://www.festavenue.site")
+print("✓ Tools Service initialized (Function Calling enabled)")
+
 print("✓ Services initialized successfully")
 
 
@@ -123,6 +134,7 @@ class IndexResponse(BaseModel):
 # Pydantic models for ChatbotRAG
 class ChatRequest(BaseModel):
     message: str
+    session_id: Optional[str] = None  # Multi-turn conversation
     use_rag: bool = True
     top_k: int = 3
     system_message: Optional[str] = """Bạn là trợ lý AI chuyên biệt cho hệ thống quản lý sự kiện và bán vé. 
@@ -143,6 +155,8 @@ Quy tắc tuyệt đối:
     use_reranking: bool = False  # Disabled - Cross-Encoder not good for Vietnamese
     use_compression: bool = True
     score_threshold: float = 0.5
+    # Function calling
+    enable_tools: bool = True  # Enable API tool calling
 
 
 class ChatResponse(BaseModel):
@@ -150,6 +164,8 @@ class ChatResponse(BaseModel):
     context_used: List[Dict]
     timestamp: str
     rag_stats: Optional[Dict] = None  # Stats from advanced RAG pipeline
+    session_id: str  # NEW: Session identifier for multi-turn
+    tool_calls: Optional[List[Dict]] = None  # NEW: Track API calls made
 
 
 class AddDocumentRequest(BaseModel):
@@ -748,7 +764,16 @@ async def chat(request: ChatRequest):
                 )
             else:
                 # Basic prompt
-                system_message = f"{request.system_message}\n{context_text}\n\nPlease use the above context to answer the user's question when relevant."
+                # Basic prompt with better instructions
+                system_message = f"""{request.system_message}
+
+{context_text}
+
+HƯỚNG DẪN:
+- Sử dụng thông tin từ context trên để trả lời câu hỏi.
+- Trả lời tự nhiên, thân thiện, không copy nguyên văn.
+- Nếu tìm thấy sự kiện, hãy tóm tắt các thông tin quan trọng nhất.
+"""
         else:
             system_message = request.system_message
 

tools_service.py

@@ -0,0 +1,164 @@
+"""
+Tools Service for LLM Function Calling
+HuggingFace-compatible với prompt engineering
+"""
+import httpx
+from typing import List, Dict, Any, Optional
+import json
+import asyncio
+
+
+class ToolsService:
+    """
+    Manages external API tools that LLM can call via prompt engineering
+    """
+    
+    def __init__(self, base_url: str = "https://www.festavenue.site"):
+        self.base_url = base_url
+        self.client = httpx.AsyncClient(timeout=10.0)
+    
+    def get_tools_prompt(self) -> str:
+        """
+        Return prompt instruction for HuggingFace LLM về available tools
+        """
+        return """
+AVAILABLE TOOLS:
+Bạn có thể sử dụng các công cụ sau để lấy thông tin chi tiết:
+
+1. get_event_details(event_code: str)
+   - Mô tả: Lấy thông tin đầy đủ về một sự kiện từ hệ thống
+   - Khi nào dùng: Khi user hỏi về ngày giờ chính xác, địa điểm cụ thể, thông tin liên hệ, hoặc chi tiết khác về một sự kiện
+   - Tham số: event_code (mã sự kiện, ví dụ: "Y-CONCERT", "EVT001")
+   - Ví dụ: User hỏi "Ngày tổ chức Y-CONCERT là khi nào?" → Dùng get_event_details("Y-CONCERT")
+
+CÚ PHÁP GỌI TOOL:
+Khi bạn cần gọi tool, hãy trả lời CHÍNH XÁC theo format JSON này:
+```json
+{
+  "tool_call": true,
+  "function_name": "get_event_details",
+  "arguments": {
+    "event_code": "Y-CONCERT"
+  },
+  "reason": "Cần lấy thông tin chính xác về ngày giờ tổ chức"
+}
+```
+
+QUAN TRỌNG:
+- CHỈ trả JSON khi BẮT BUỘC cần gọi tool
+- Nếu có thể trả lời từ context sẵn có, đừng gọi tool
+- Sau khi nhận kết quả từ tool, hãy trả lời user bằng ngôn ngữ tự nhiên
+"""
+    
+    async def parse_and_execute(self, llm_response: str) -> Optional[Dict[str, Any]]:
+        """
+        Parse LLM response và execute tool nếu có
+        
+        Returns:
+            None nếu không có tool call
+            Dict với tool result nếu có tool call
+        """
+        # Try to extract JSON from response
+        try:
+            # Tìm JSON block trong response
+            if "```json" in llm_response:
+                json_start = llm_response.find("```json") + 7
+                json_end = llm_response.find("```", json_start)
+                json_str = llm_response[json_start:json_end].strip()
+            elif "{" in llm_response and "}" in llm_response:
+                # Fallback: tìm JSON object đầu tiên
+                json_start = llm_response.find("{")
+                json_end = llm_response.rfind("}") + 1
+                json_str = llm_response[json_start:json_end]
+            else:
+                return None
+            
+            tool_call = json.loads(json_str)
+            
+            # Validate tool call structure
+            if not tool_call.get("tool_call"):
+                return None
+            
+            function_name = tool_call.get("function_name")
+            arguments = tool_call.get("arguments", {})
+            
+            # Execute tool
+            if function_name == "get_event_details":
+                result = await self._get_event_details(arguments.get("event_code"))
+                return {
+                    "function": function_name,
+                    "arguments": arguments,
+                    "result": result
+                }
+            else:
+                return {
+                    "function": function_name,
+                    "arguments": arguments,
+                    "result": {"success": False, "error": f"Unknown function: {function_name}"}
+                }
+                
+        except (json.JSONDecodeError, KeyError, ValueError) as e:
+            # Không phải tool call, response bình thường
+            return None
+    
+    async def _get_event_details(self, event_code: str) -> Dict[str, Any]:
+        """
+        Call getEventByEventCode API
+        """
+        try:
+            response = await self.client.get(
+                f"{self.base_url}/event/get-event-by-event-code",
+                params={"eventCode": event_code}
+            )
+            response.raise_for_status()
+            data = response.json()
+            
+            # Extract relevant fields
+            event = data.get("data", {})
+            
+            if not event:
+                return {
+                    "success": False,
+                    "error": "Event not found",
+                    "message": f"Không tìm thấy sự kiện với mã {event_code}"
+                }
+            
+            return {
+                "success": True,
+                "event_code": event.get("eventCode"),
+                "event_name": event.get("eventName"),
+                "description": event.get("description"),
+                "short_description": event.get("shortDescription"),
+                "start_time": event.get("startTimeEventTime"),
+                "end_time": event.get("endTimeEventTime"),
+                "start_sale": event.get("startTicketSaleTime"),
+                "end_sale": event.get("endTicketSaleTime"),
+                "location": {
+                    "address": event.get("location", {}).get("address"),
+                    "city": event.get("location", {}).get("city"),
+                },
+                "contact": {
+                    "email": event.get("publicContactEmail"),
+                    "phone": event.get("publicContactPhone"),
+                    "website": event.get("website")
+                },
+                "capacity": event.get("capacity"),
+                "hashtags": event.get("hashtags", [])
+            }
+            
+        except httpx.HTTPStatusError as e:
+            return {
+                "success": False,
+                "error": f"HTTP {e.response.status_code}",
+                "message": f"API trả về lỗi khi truy vấn sự kiện {event_code}"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "message": "Không thể kết nối đến API để lấy thông tin sự kiện"
+            }
+    
+    async def close(self):
+        """Close HTTP client"""
+        await self.client.aclose()