upload backend

.env

@@ -0,0 +1,5 @@
+GEMINI_API_KEY=AIzaSyBW0gv3-bwuKE05MP8y0N0lA2Y2KpyTvCs
+MONGO_URI=mongodb+srv://linhha2705:[email protected]/
+MONGO_DB_NAME=nutribot_db
+JWT_SECRET_KEY=hathimylinh
+OPENAI_API_KEY=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

Dockerfile

@@ -0,0 +1,41 @@
+# Sử dụng bookworm thay vì bullseye vì có SQLite3 phiên bản mới hơn
+FROM python:3.9-slim-bookworm
+
+# Thiết lập working directory
+WORKDIR /app
+
+# Thiết lập environment variables
+ENV PYTHONPATH=/app
+ENV ENVIRONMENT=production
+ENV PYTHONUNBUFFERED=1
+
+# Cài đặt system dependencies cần thiết cho ChromaDB
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    gcc \
+    g++ \
+    cmake \
+    sqlite3 \
+    libsqlite3-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements và cài đặt Python dependencies
+COPY requirements.txt .
+
+# Cài đặt pysqlite3-binary trước để override SQLite3 nếu cần
+RUN pip install --no-cache-dir pysqlite3-binary
+
+# Cài đặt các dependencies khác
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy source code
+COPY . .
+
+# Tạo thư mục cần thiết
+RUN mkdir -p logs uploads chroma_data
+
+# Expose port
+EXPOSE 7860
+
+# Chạy ứng dụng
+CMD ["python", "app.py"]

api/admin.py

@@ -0,0 +1,2385 @@
+from flask import Blueprint, request, jsonify
+import logging
+import datetime
+import os
+from bson.objectid import ObjectId
+from models.user_model import User
+from models.conversation_model import get_db, Conversation
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from functools import wraps
+import json
+from core.embedding_model import get_embedding_model
+from werkzeug.utils import secure_filename
+import google.generativeai as genai
+from config import GEMINI_API_KEY
+import time
+import sys
+from models.feedback_model import Feedback
+
+# Thiết lập logging
+logger = logging.getLogger(__name__)
+
+# Tạo blueprint
+admin_routes = Blueprint('admin', __name__)
+
+# Configure Gemini
+genai.configure(api_key=GEMINI_API_KEY)
+
+def setup_debug_logging():
+    """Thiết lập logging debug cho Gemini response"""
+    log_dir = "logs"
+    if not os.path.exists(log_dir):
+        os.makedirs(log_dir)
+    return log_dir
+
+def save_gemini_response_to_file(response_text, parsed_data, doc_id):
+    """Lưu response của Gemini vào file để debug"""
+    try:
+        log_dir = setup_debug_logging()
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        # Tạo tên file log
+        log_filename = f"gemini_response_{doc_id}_{timestamp}.log"
+        log_path = os.path.join(log_dir, log_filename)
+        
+        with open(log_path, 'w', encoding='utf-8') as f:
+            f.write("=" * 80 + "\n")
+            f.write(f"GEMINI RESPONSE DEBUG LOG\n")
+            f.write(f"Document ID: {doc_id}\n")
+            f.write(f"Timestamp: {datetime.datetime.now().isoformat()}\n")
+            f.write("=" * 80 + "\n\n")
+            
+            f.write("RAW RESPONSE FROM GEMINI:\n")
+            f.write("-" * 40 + "\n")
+            f.write(response_text)
+            f.write("\n\n")
+            
+            f.write("PARSED JSON DATA:\n")
+            f.write("-" * 40 + "\n")
+            f.write(json.dumps(parsed_data, indent=2, ensure_ascii=False))
+            f.write("\n\n")
+            
+            # Debug chunks content vs summary
+            f.write("CHUNKS CONTENT vs SUMMARY ANALYSIS:\n")
+            f.write("-" * 40 + "\n")
+            for i, chunk in enumerate(parsed_data.get('chunks', [])[:3]):  # Chỉ log 3 chunks đầu
+                f.write(f"CHUNK {i+1} ({chunk.get('id', 'no-id')}):\n")
+                f.write(f"Title: {chunk.get('title', 'no-title')}\n")
+                f.write(f"Summary Length: {len(chunk.get('summary', ''))}\n")
+                f.write(f"Content Length: {len(chunk.get('content', ''))}\n")
+                f.write(f"Summary: {chunk.get('summary', 'no-summary')[:200]}...\n")
+                f.write(f"Content: {chunk.get('content', 'no-content')[:200]}...\n")
+                f.write("\n")
+            
+            # Debug tables
+            if parsed_data.get('tables'):
+                f.write("TABLES ANALYSIS:\n")
+                f.write("-" * 40 + "\n")
+                for i, table in enumerate(parsed_data.get('tables', [])[:2]):
+                    f.write(f"TABLE {i+1} ({table.get('id', 'no-id')}):\n")
+                    f.write(f"Title: {table.get('title', 'no-title')}\n")
+                    f.write(f"Summary: {table.get('summary', 'no-summary')[:100]}...\n")
+                    f.write(f"Content: {table.get('content', 'no-content')[:100]}...\n")
+                    f.write("\n")
+        
+        logger.info(f"Saved Gemini response debug log to: {log_path}")
+        return log_path
+        
+    except Exception as e:
+        logger.error(f"Error saving debug log: {e}")
+        return None
+
+def require_admin(f):
+    """Decorator để kiểm tra quyền admin"""
+    @wraps(f)
+    @jwt_required()
+    def decorated_function(*args, **kwargs):
+        try:
+            user_id = get_jwt_identity()
+            user = User.find_by_id(user_id)
+            
+            if not user or not user.is_admin():
+                return jsonify({
+                    "success": False,
+                    "error": "Không có quyền truy cập admin"
+                }), 403
+            
+            request.current_user = user
+            return f(*args, **kwargs)
+        except Exception as e:
+            logger.error(f"Lỗi xác thực admin: {e}")
+            return jsonify({
+                "success": False,
+                "error": "Lỗi xác thực"
+            }), 500
+    return decorated_function
+
+# ===== DASHBOARD ROUTES =====
+
+@admin_routes.route('/stats/overview', methods=['GET'])
+@require_admin
+def get_overview_stats():
+    """Lấy thống kê tổng quan cho dashboard"""
+    try:
+        db = get_db()
+        
+        # Sử dụng timezone Việt Nam (UTC+7)
+        import pytz
+        vietnam_tz = pytz.timezone('Asia/Ho_Chi_Minh')
+        now_vietnam = datetime.datetime.now(vietnam_tz)
+        
+        # Thống kê users thực tế
+        total_users = db.users.count_documents({}) if hasattr(db, 'users') else 0
+        today_start = now_vietnam.replace(hour=0, minute=0, second=0, microsecond=0)
+        new_users_today = db.users.count_documents({
+            "created_at": {"$gte": today_start.astimezone(pytz.UTC).replace(tzinfo=None)}
+        }) if hasattr(db, 'users') else 0
+        
+        # Thống kê conversations thực tế
+        total_conversations = db.conversations.count_documents({})
+        day_ago = now_vietnam - datetime.timedelta(days=1)
+        recent_conversations = db.conversations.count_documents({
+            "updated_at": {"$gte": day_ago.astimezone(pytz.UTC).replace(tzinfo=None)}
+        })
+        
+        # Thống kê tin nhắn thực tế
+        pipeline = [
+            {"$project": {"message_count": {"$size": "$messages"}}},
+            {"$group": {"_id": None, "total_messages": {"$sum": "$message_count"}}}
+        ]
+        message_result = list(db.conversations.aggregate(pipeline))
+        total_messages = message_result[0]["total_messages"] if message_result else 0
+        
+        # Thống kê admin thực tế
+        total_admins = db.users.count_documents({"role": "admin"}) if hasattr(db, 'users') else 0
+        
+        # Thống kê theo tuần (7 ngày gần nhất) - SỬA LẠI
+        daily_stats = []
+        for i in range(7):
+            # Tính ngày theo timezone Việt Nam
+            target_date = now_vietnam.date() - datetime.timedelta(days=6-i)
+            day_start = vietnam_tz.localize(datetime.datetime.combine(target_date, datetime.time.min))
+            day_end = vietnam_tz.localize(datetime.datetime.combine(target_date, datetime.time.max))
+            
+            # Convert về UTC để query MongoDB
+            day_start_utc = day_start.astimezone(pytz.UTC).replace(tzinfo=None)
+            day_end_utc = day_end.astimezone(pytz.UTC).replace(tzinfo=None)
+            
+            # Đếm conversations được tạo HOẶC cập nhật trong ngày
+            daily_conversations_created = db.conversations.count_documents({
+                "created_at": {"$gte": day_start_utc, "$lte": day_end_utc}
+            })
+            
+            daily_conversations_updated = db.conversations.count_documents({
+                "updated_at": {"$gte": day_start_utc, "$lte": day_end_utc},
+                "created_at": {"$lt": day_start_utc}  # Không đếm trùng với conversations mới tạo
+            })
+            
+            total_daily_activity = daily_conversations_created + daily_conversations_updated
+            
+            daily_users = 0
+            if hasattr(db, 'users'):
+                daily_users = db.users.count_documents({
+                    "created_at": {"$gte": day_start_utc, "$lte": day_end_utc}
+                })
+            
+            daily_stats.append({
+                "date": target_date.strftime("%Y-%m-%d"),
+                "label": target_date.strftime("%d/%m"),
+                "conversations": total_daily_activity,
+                "users": daily_users,
+                "created": daily_conversations_created,
+                "updated": daily_conversations_updated
+            })
+        
+        # Thống kê theo độ tuổi thực tế
+        age_pipeline = [
+            {"$group": {"_id": "$age_context", "count": {"$sum": 1}}},
+            {"$sort": {"_id": 1}}
+        ]
+        age_stats = list(db.conversations.aggregate(age_pipeline))
+        
+        return jsonify({
+            "success": True,
+            "stats": {
+                "users": {
+                    "total": total_users,
+                    "new_today": new_users_today,
+                    "active": total_users
+                },
+                "conversations": {
+                    "total": total_conversations,
+                    "recent": recent_conversations
+                },
+                "messages": {
+                    "total": total_messages,
+                    "avg_per_conversation": round(total_messages / total_conversations, 1) if total_conversations > 0 else 0
+                },
+                "admins": {
+                    "total": total_admins
+                },
+                "daily_stats": daily_stats,
+                "age_distribution": [
+                    {
+                        "age_group": f"{stat['_id']} tuổi" if stat['_id'] else "Không rõ",
+                        "count": stat["count"]
+                    }
+                    for stat in age_stats
+                ],
+                "timezone": "Asia/Ho_Chi_Minh",
+                "current_time": now_vietnam.isoformat()
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy thống kê tổng quan: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/system-info', methods=['GET'])
+@require_admin 
+def get_system_info():
+    """Lấy thông tin hệ thống"""
+    try:
+        from core.embedding_model import get_embedding_model
+        
+        # Thông tin vector database
+        try:
+            embedding_model = get_embedding_model()
+            vector_count = embedding_model.count()
+        except:
+            vector_count = 0
+        
+        # Thông tin database
+        db = get_db()
+        collections = db.list_collection_names()
+        
+        system_info = {
+            "database": {
+                "type": "MongoDB",
+                "collections": len(collections),
+                "status": "active"
+            },
+            "vector_db": {
+                "type": "ChromaDB", 
+                "embeddings": vector_count,
+                "model": "multilingual-e5-base"
+            },
+            "ai": {
+                "generation_model": "Gemini 2.0 Flash",
+                "embedding_model": "multilingual-e5-base",
+                "status": "active"
+            }
+        }
+        
+        return jsonify({
+            "success": True,
+            "system_info": system_info
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy thông tin hệ thống: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/alerts', methods=['GET'])
+@require_admin
+def get_system_alerts():
+    """Lấy cảnh báo hệ thống"""
+    try:
+        alerts = []
+        
+        # Kiểm tra số lượng conversations
+        db = get_db()
+        total_conversations = db.conversations.count_documents({})
+        
+        if total_conversations > 100:
+            alerts.append({
+                "type": "info",
+                "title": "Lượng dữ liệu cao",
+                "message": f"Hệ thống có {total_conversations} cuộc hội thoại",
+                "severity": "low"
+            })
+        
+        # Mặc định: hệ thống hoạt động bình thường
+        if not alerts:
+            alerts.append({
+                "type": "info",
+                "title": "Hệ thống hoạt động bình thường",
+                "message": "Tất cả dịch vụ đang chạy ổn định",
+                "severity": "low"
+            })
+        
+        return jsonify({
+            "success": True,
+            "alerts": alerts
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy cảnh báo hệ thống: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+# ===== USER MANAGEMENT ROUTES =====
+
+@admin_routes.route('/users', methods=['GET'])
+@require_admin
+def get_all_users():
+    """Lấy danh sách người dùng với thông tin thực tế"""
+    try:
+        db = get_db()
+        users_collection = db.users
+        
+        page = int(request.args.get('page', 1))
+        per_page = int(request.args.get('per_page', 20))
+        search = request.args.get('search', '')
+        gender_filter = request.args.get('gender', '')
+        role_filter = request.args.get('role', '')
+        sort_by = request.args.get('sort_by', 'created_at')
+        sort_order = request.args.get('sort_order', 'desc')
+        
+        # Tạo query filter
+        query_filter = {}
+        if search:
+            query_filter["$or"] = [
+                {"name": {"$regex": search, "$options": "i"}},
+                {"email": {"$regex": search, "$options": "i"}}
+            ]
+        if gender_filter:
+            query_filter["gender"] = gender_filter
+        if role_filter:
+            query_filter["role"] = role_filter
+        
+        # Pagination
+        skip = (page - 1) * per_page
+        sort_direction = -1 if sort_order == 'desc' else 1
+        
+        users_cursor = users_collection.find(query_filter).sort(sort_by, sort_direction).skip(skip).limit(per_page)
+        total_users = users_collection.count_documents(query_filter)
+        
+        users_list = []
+        for user_data in users_cursor:
+            # Đếm conversations thực tế
+            conversation_count = db.conversations.count_documents({"user_id": user_data["_id"]})
+            
+            # Lấy conversation mới nhất để biết last_activity
+            latest_conversation = db.conversations.find_one(
+                {"user_id": user_data["_id"]},
+                sort=[("updated_at", -1)]
+            )
+            
+            # Đếm tin nhắn
+            user_conversations = list(db.conversations.find({"user_id": user_data["_id"]}))
+            total_messages = sum(len(conv.get("messages", [])) for conv in user_conversations)
+            
+            users_list.append({
+                "id": str(user_data["_id"]),
+                "name": user_data.get("name", ""),
+                "email": user_data.get("email", ""),
+                "gender": user_data.get("gender", ""),
+                "role": user_data.get("role", "user"),
+                "created_at": user_data.get("created_at").isoformat() if user_data.get("created_at") else None,
+                "updated_at": user_data.get("updated_at").isoformat() if user_data.get("updated_at") else None,
+                "last_login": user_data.get("last_login").isoformat() if user_data.get("last_login") else None,
+                "conversation_count": conversation_count,
+                "message_count": total_messages,
+                "last_activity": latest_conversation.get("updated_at").isoformat() if latest_conversation and latest_conversation.get("updated_at") else None,
+                "avg_messages_per_conversation": round(total_messages / conversation_count, 1) if conversation_count > 0 else 0
+            })
+        
+        # Thống kê tổng hợp
+        stats = {
+            "total_users": total_users,
+            "total_admins": users_collection.count_documents({"role": "admin"}),
+            "total_regular_users": users_collection.count_documents({"role": "user"}),
+            "active_users": users_collection.count_documents({"last_login": {"$exists": True}}),
+            "gender_stats": {
+                "male": users_collection.count_documents({"gender": "male"}),
+                "female": users_collection.count_documents({"gender": "female"}),
+                "other": users_collection.count_documents({"gender": "other"}),
+                "unknown": users_collection.count_documents({"gender": {"$in": [None, ""]}})
+            }
+        }
+        
+        return jsonify({
+            "success": True,
+            "users": users_list,
+            "stats": stats,
+            "pagination": {
+                "page": page,
+                "per_page": per_page,
+                "total": total_users,
+                "pages": (total_users + per_page - 1) // per_page
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy danh sách users: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/users/<user_id>', methods=['GET'])
+@require_admin
+def get_user_detail(user_id):
+    """Lấy chi tiết người dùng với thông tin đầy đủ"""
+    try:
+        user = User.find_by_id(user_id)
+        if not user:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy người dùng"
+            }), 404
+        
+        db = get_db()
+        
+        # Lấy conversations của user
+        user_conversations = list(db.conversations.find(
+            {"user_id": ObjectId(user_id)},
+            {"title": 1, "created_at": 1, "updated_at": 1, "age_context": 1, "messages": 1}
+        ).sort("updated_at", -1))
+        
+        # Tính thống kê chi tiết
+        total_messages = sum(len(conv.get("messages", [])) for conv in user_conversations)
+        conversation_stats = {
+            "total_conversations": len(user_conversations),
+            "total_messages": total_messages,
+            "avg_messages_per_conversation": round(total_messages / len(user_conversations), 1) if user_conversations else 0,
+            "most_recent_conversation": user_conversations[0].get("updated_at").isoformat() if user_conversations and user_conversations[0].get("updated_at") else None,
+            "oldest_conversation": user_conversations[-1].get("created_at").isoformat() if user_conversations and user_conversations[-1].get("created_at") else None
+        }
+        
+        # Thống kê theo độ tuổi
+        age_stats = {}
+        for conv in user_conversations:
+            age = conv.get("age_context")
+            if age:
+                age_stats[age] = age_stats.get(age, 0) + 1
+        
+        user_detail = {
+            "id": str(user.user_id),
+            "name": user.name,
+            "email": user.email,
+            "gender": user.gender,
+            "role": user.role,
+            "created_at": user.created_at.isoformat() if user.created_at else None,
+            "updated_at": user.updated_at.isoformat() if user.updated_at else None,
+            "last_login": user.last_login.isoformat() if user.last_login else None,
+            "stats": conversation_stats,
+            "age_usage": age_stats,
+            "recent_conversations": [
+                {
+                    "id": str(conv["_id"]),
+                    "title": conv.get("title", ""),
+                    "created_at": conv.get("created_at").isoformat() if conv.get("created_at") else None,
+                    "updated_at": conv.get("updated_at").isoformat() if conv.get("updated_at") else None,
+                    "message_count": len(conv.get("messages", [])),
+                    "age_context": conv.get("age_context")
+                }
+                for conv in user_conversations[:10]
+            ]
+        }
+        
+        return jsonify({
+            "success": True,
+            "user": user_detail
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy chi tiết user: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/users/<user_id>', methods=['DELETE'])
+@require_admin
+def delete_user(user_id):
+    """Xóa người dùng"""
+    try:
+        user = User.find_by_id(user_id)
+        if not user:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy người dùng"
+            }), 404
+        
+        # Xóa tất cả conversations của user
+        db = get_db()
+        conversations_deleted = db.conversations.delete_many({"user_id": ObjectId(user_id)})
+        
+        # Xóa user
+        user_deleted = user.delete()
+        
+        if user_deleted:
+            return jsonify({
+                "success": True,
+                "message": f"Đã xóa người dùng và {conversations_deleted.deleted_count} cuộc hội thoại"
+            })
+        else:
+            return jsonify({
+                "success": False,
+                "error": "Không thể xóa người dùng"
+            }), 500
+        
+    except Exception as e:
+        logger.error(f"Lỗi xóa user: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/users/bulk-delete', methods=['POST'])
+@require_admin
+def bulk_delete_users():
+    """Xóa nhiều người dùng"""
+    try:
+        data = request.json
+        user_ids = data.get('user_ids', [])
+        
+        if not user_ids:
+            return jsonify({
+                "success": False,
+                "error": "Không có user nào được chọn"
+            }), 400
+        
+        deleted_count = 0
+        failed_ids = []
+        
+        db = get_db()
+        
+        for user_id in user_ids:
+            try:
+                # Xóa conversations của user
+                db.conversations.delete_many({"user_id": ObjectId(user_id)})
+                
+                # Xóa user
+                user = User.find_by_id(user_id)
+                if user and user.delete():
+                    deleted_count += 1
+                else:
+                    failed_ids.append(user_id)
+            except Exception as e:
+                logger.error(f"Lỗi xóa user {user_id}: {e}")
+                failed_ids.append(user_id)
+        
+        return jsonify({
+            "success": True,
+            "message": f"Đã xóa {deleted_count}/{len(user_ids)} người dùng",
+            "deleted_count": deleted_count,
+            "failed_ids": failed_ids
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi xóa bulk users: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+# ===== CONVERSATION MANAGEMENT ROUTES =====
+@admin_routes.route('/conversations', methods=['GET'])
+@require_admin
+def get_all_conversations():
+    """Lấy danh sách cuộc hội thoại - Fixed ObjectId serialization"""
+    try:
+        db = get_db()
+        
+        page = int(request.args.get('page', 1))
+        per_page = int(request.args.get('per_page', 20))
+        search = request.args.get('search', '')
+        age_filter = request.args.get('age', '')
+        archived_filter = request.args.get('archived', 'all')
+        
+        # Tạo query filter
+        query_filter = {}
+        if search:
+            query_filter["title"] = {"$regex": search, "$options": "i"}
+        if age_filter:
+            query_filter["age_context"] = int(age_filter)
+        if archived_filter != 'all':
+            query_filter["is_archived"] = archived_filter == 'true'
+        
+        skip = (page - 1) * per_page
+        conversations = list(db.conversations.find(query_filter).skip(skip).limit(per_page).sort("updated_at", -1))
+        total_conversations = db.conversations.count_documents(query_filter)
+        
+        conversations_list = []
+        for conv in conversations:
+            try:
+                # ✅ FIX: Safely convert ObjectId to string và handle user lookup
+                user_id = conv.get("user_id")
+                user_name = "Unknown"
+                
+                if user_id:
+                    try:
+                        # Ensure user_id is ObjectId
+                        if isinstance(user_id, str):
+                            user_id = ObjectId(user_id)
+                        
+                        user = User.find_by_id(str(user_id))  # Convert to string for the method
+                        if user:
+                            user_name = user.name
+                    except Exception as user_error:
+                        logger.warning(f"Could not fetch user {user_id}: {user_error}")
+                        user_name = "Unknown"
+                
+                # ✅ FIX: Safely handle datetime objects
+                def safe_isoformat(dt):
+                    if dt is None:
+                        return None
+                    if hasattr(dt, 'isoformat'):
+                        return dt.isoformat()
+                    return str(dt)
+                
+                # ✅ FIX: Safely handle messages array
+                messages = conv.get("messages", [])
+                processed_messages = []
+                
+                for msg in messages:
+                    if isinstance(msg, dict):
+                        processed_msg = {
+                            "role": msg.get("role", ""),
+                            "content": msg.get("content", ""),
+                            "timestamp": safe_isoformat(msg.get("timestamp"))
+                        }
+                        processed_messages.append(processed_msg)
+                
+                conversation_data = {
+                    "id": str(conv["_id"]),  # ✅ Always convert ObjectId to string
+                    "title": conv.get("title", ""),
+                    "user_name": user_name,
+                    "age_context": conv.get("age_context"),
+                    "message_count": len(messages),
+                    "is_archived": conv.get("is_archived", False),
+                    "created_at": safe_isoformat(conv.get("created_at")),
+                    "updated_at": safe_isoformat(conv.get("updated_at")),
+                    "messages": processed_messages
+                }
+                
+                conversations_list.append(conversation_data)
+                
+            except Exception as conv_error:
+                logger.error(f"Error processing conversation {conv.get('_id')}: {conv_error}")
+                # Skip this conversation but continue with others
+                continue
+        
+        return jsonify({
+            "success": True,
+            "conversations": conversations_list,
+            "pagination": {
+                "page": page,
+                "per_page": per_page,
+                "total": total_conversations,
+                "pages": (total_conversations + per_page - 1) // per_page
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy danh sách conversations: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/conversations/<conversation_id>', methods=['DELETE'])
+@require_admin
+def delete_conversation(conversation_id):
+    """Xóa cuộc hội thoại - Fixed ObjectId handling"""
+    try:
+        # ✅ FIX: Use Conversation model instead of direct DB access
+        conversation = Conversation.find_by_id(conversation_id)
+        if not conversation:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc hội thoại"
+            }), 404
+        
+        success = conversation.delete()
+        
+        if success:
+            return jsonify({
+                "success": True,
+                "message": "Đã xóa cuộc hội thoại"
+            })
+        else:
+            return jsonify({
+                "success": False,
+                "error": "Không thể xóa cuộc hội thoại"
+            }), 500
+        
+    except Exception as e:
+        logger.error(f"Lỗi xóa conversation: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/conversations/bulk-delete', methods=['POST'])
+@require_admin
+def bulk_delete_conversations():
+    """Xóa nhiều cuộc hội thoại - Fixed ObjectId handling"""
+    try:
+        data = request.json
+        conversation_ids = data.get('conversation_ids', [])
+        
+        if not conversation_ids:
+            return jsonify({
+                "success": False,
+                "error": "Không có conversation nào được chọn"
+            }), 400
+        
+        db = get_db()
+        deleted_count = 0
+        failed_ids = []
+        
+        for conv_id in conversation_ids:
+            try:
+                # ✅ FIX: Ensure proper ObjectId conversion
+                if isinstance(conv_id, str):
+                    conv_id = ObjectId(conv_id)
+                
+                result = db.conversations.delete_one({"_id": conv_id})
+                if result.deleted_count > 0:
+                    deleted_count += 1
+                else:
+                    failed_ids.append(str(conv_id))
+                    
+            except Exception as e:
+                logger.error(f"Error deleting conversation {conv_id}: {e}")
+                failed_ids.append(str(conv_id))
+                continue
+        
+        return jsonify({
+            "success": True,
+            "message": f"Đã xóa {deleted_count}/{len(conversation_ids)} cuộc hội thoại",
+            "deleted_count": deleted_count,
+            "failed_ids": failed_ids
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi xóa bulk conversations: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+# ===== DOCUMENT MANAGEMENT ROUTES =====
+
+@admin_routes.route('/documents', methods=['GET'])
+@require_admin
+def get_all_documents():
+    """Lấy danh sách tài liệu t�� ChromaDB theo đúng metadata"""
+    try:
+        embedding_model = get_embedding_model()
+        
+        # Lấy tất cả documents từ ChromaDB
+        results = embedding_model.collection.get(
+            include=['metadatas', 'documents']
+        )
+        
+        if not results or not results['metadatas']:
+            return jsonify({
+                "success": True,
+                "documents": [],
+                "stats": {
+                    "total": 0,
+                    "by_chapter": {},
+                    "by_type": {}
+                }
+            })
+        
+        # Phân tích metadata để nhóm theo chapter
+        documents_by_chapter = {}
+        stats = {
+            "total": 0,
+            "by_chapter": {},
+            "by_type": {}
+        }
+        
+        for i, metadata in enumerate(results['metadatas']):
+            # Lấy chapter từ metadata
+            chapter = metadata.get('chapter', 'unknown')
+            content_type = metadata.get('content_type', 'text')
+            
+            # Cập nhật stats
+            stats["by_chapter"][chapter] = stats["by_chapter"].get(chapter, 0) + 1
+            stats["by_type"][content_type] = stats["by_type"].get(content_type, 0) + 1
+            
+            # Nhóm theo chapter
+            if chapter not in documents_by_chapter:
+                chapter_title = get_chapter_title(chapter)
+                chapter_type = get_chapter_type(chapter)
+                
+                documents_by_chapter[chapter] = {
+                    "id": chapter,
+                    "title": chapter_title,
+                    "description": f"Tài liệu {chapter_title.lower()}",
+                    "type": chapter_type,
+                    "status": "processed",
+                    "created_at": metadata.get('created_at', datetime.datetime.now().isoformat()),
+                    "content_stats": {
+                        "chunks": 0,
+                        "tables": 0,
+                        "figures": 0
+                    }
+                }
+            
+            # Cập nhật content stats
+            if content_type == "table":
+                documents_by_chapter[chapter]["content_stats"]["tables"] += 1
+            elif content_type == "figure":
+                documents_by_chapter[chapter]["content_stats"]["figures"] += 1
+            else:
+                documents_by_chapter[chapter]["content_stats"]["chunks"] += 1
+        
+        documents_list = list(documents_by_chapter.values())
+        stats["total"] = len(documents_list)
+        
+        logger.info(f"Found chapters: {list(documents_by_chapter.keys())}")
+        logger.info(f"Stats: {stats}")
+        
+        return jsonify({
+            "success": True,
+            "documents": documents_list,
+            "stats": stats
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy danh sách documents: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+def get_chapter_title(chapter):
+    try:
+        # Nếu là document upload, lấy title từ metadata
+        if chapter.startswith('bosung') or chapter.startswith('upload_'):
+            embedding_model = get_embedding_model()
+            results = embedding_model.collection.get(
+                where={"chapter": chapter},
+                limit=1
+            )
+            
+            if results and results.get('metadatas') and results['metadatas'][0]:
+                metadata = results['metadatas'][0]
+                document_title = metadata.get('document_title') or metadata.get('document_source')
+                if document_title and document_title != 'Tài liệu upload':
+                    return document_title
+        
+        # Fallback cho các chapter chuẩn
+        chapter_titles = {
+            'bai1': 'Bài 1: Dinh dưỡng theo lứa tuổi học sinh',
+            'bai2': 'Bài 2: An toàn thực phẩm',
+            'bai3': 'Bài 3: Vệ sinh dinh dưỡng',
+            'bai4': 'Bài 4: Giáo dục dinh dưỡng',
+            'phuluc': 'Phụ lục'
+        }
+        
+        # Kiểm tra pattern bosung
+        if chapter.startswith('bosung'):
+            return f'Tài liệu bổ sung {chapter.replace("bosung", "")}'
+        
+        return chapter_titles.get(chapter, f'Tài liệu {chapter}')
+        
+    except Exception as e:
+        logger.error(f"Error getting chapter title: {e}")
+        return f'Tài liệu {chapter}'
+
+def get_chapter_type(chapter):
+    """Lấy loại chapter"""
+    if chapter.startswith('bai'):
+        return 'lesson'
+    elif chapter == 'phuluc':
+        return 'appendix'
+    else:
+        return 'uploaded'
+
+@admin_routes.route('/documents/<doc_id>', methods=['GET'])
+@require_admin
+def get_document_detail(doc_id):
+    """Lấy chi tiết document theo chapter"""
+    try:
+        logger.info(f"Getting document detail for: {doc_id}")
+        
+        # Sử dụng try-catch để tránh l���i tensor
+        try:
+            embedding_model = get_embedding_model()
+        except Exception as model_error:
+            logger.warning(f"Cannot load embedding model: {model_error}")
+            # Fallback: truy cập trực tiếp ChromaDB
+            import chromadb
+            from config import CHROMA_PERSIST_DIRECTORY, COLLECTION_NAME
+            
+            chroma_client = chromadb.PersistentClient(path=CHROMA_PERSIST_DIRECTORY)
+            collection = chroma_client.get_collection(name=COLLECTION_NAME)
+        else:
+            collection = embedding_model.collection
+        
+        # Lấy tất cả documents và filter manually để tránh lỗi query
+        try:
+            all_results = collection.get(
+                include=['metadatas', 'documents']  # Bỏ 'ids' để tránh lỗi
+            )
+            
+            if not all_results or not all_results.get('metadatas'):
+                logger.warning("No documents found in collection")
+                return jsonify({
+                    "success": False,
+                    "error": "Không có dữ liệu trong collection"
+                }), 404
+            
+            # Filter manually
+            filtered_documents = []
+            filtered_metadatas = []
+            
+            for i, metadata in enumerate(all_results['metadatas']):
+                if not metadata:
+                    continue
+                    
+                chunk_id = metadata.get('chunk_id', '')
+                chapter = metadata.get('chapter', '')
+                
+                # Kiểm tra match với doc_id
+                if (chunk_id.startswith(f"{doc_id}_") or 
+                    chapter == doc_id or
+                    (doc_id in ['bai1', 'bai2', 'bai3', 'bai4'] and chunk_id.startswith(f"{doc_id}_")) or
+                    (doc_id == 'phuluc' and 'phuluc' in chunk_id.lower())):
+                    
+                    filtered_documents.append(all_results['documents'][i])
+                    filtered_metadatas.append(metadata)
+            
+            logger.info(f"Found {len(filtered_documents)} matching documents for {doc_id}")
+            
+            if not filtered_documents:
+                return jsonify({
+                    "success": False,
+                    "error": f"Không tìm thấy tài liệu cho {doc_id}"
+                }), 404
+            
+        except Exception as query_error:
+            logger.error(f"ChromaDB query error: {query_error}")
+            return jsonify({
+                "success": False,
+                "error": f"Lỗi truy vấn cơ sở dữ liệu: {str(query_error)}"
+            }), 500
+        
+        # Xử lý kết quả và nhóm theo content_type
+        chunks_by_type = {
+            'text': [],
+            'table': [],
+            'figure': []
+        }
+        
+        for i, metadata in enumerate(filtered_metadatas):
+            content_type = metadata.get('content_type', 'text')
+            
+            # Parse age_range
+            age_range_str = metadata.get('age_range', '1-19')
+            try:
+                if '-' in age_range_str:
+                    age_min, age_max = map(int, age_range_str.split('-'))
+                else:
+                    age_min = age_max = int(age_range_str)
+            except:
+                age_min, age_max = 1, 19
+            
+            chunk = {
+                "id": metadata.get('chunk_id', f'chunk_{i}'),
+                "title": metadata.get('title', 'Không có tiêu đề'),
+                "content": filtered_documents[i],
+                "content_type": content_type,
+                "age_range": age_range_str,
+                "age_min": age_min,
+                "age_max": age_max,
+                "summary": metadata.get('summary', 'Không có tóm tắt'),
+                "pages": metadata.get('pages', ''),
+                "word_count": metadata.get('word_count', 0),
+                "token_count": metadata.get('token_count', 0),
+                "related_chunks": metadata.get('related_chunks', '').split(',') if metadata.get('related_chunks') else [],
+                "created_at": metadata.get('created_at', ''),
+                "document_source": metadata.get('document_source', ''),
+                # Metadata đặc biệt
+                "contains_table": metadata.get('contains_table', False),
+                "contains_figure": metadata.get('contains_figure', False),
+                "table_columns": metadata.get('table_columns', '').split(',') if metadata.get('table_columns') else []
+            }
+            
+            # Phân loại vào đúng nhóm
+            if content_type in chunks_by_type:
+                chunks_by_type[content_type].append(chunk)
+            else:
+                chunks_by_type['text'].append(chunk)
+        
+        # Tính thống kê
+        total_chunks = sum(len(chunks) for chunks in chunks_by_type.values())
+        
+        logger.info(f"Successfully processed {total_chunks} chunks for {doc_id}")
+        
+        return jsonify({
+            "success": True,
+            "document": {
+                "id": doc_id,
+                "chunks": chunks_by_type,
+                "stats": {
+                    "total_chunks": total_chunks,
+                    "text_chunks": len(chunks_by_type['text']),
+                    "table_chunks": len(chunks_by_type['table']),
+                    "figure_chunks": len(chunks_by_type['figure'])
+                }
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Error getting document detail: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Lỗi máy chủ: {str(e)}"
+        }), 500
+
+@admin_routes.route('/documents/debug/metadata', methods=['GET'])
+@require_admin
+def debug_metadata():
+    """Debug metadata trong ChromaDB"""
+    try:
+        # Sử dụng try-catch để tránh lỗi tensor
+        try:
+            embedding_model = get_embedding_model()
+            total_docs = embedding_model.count()
+        except Exception as model_error:
+            logger.warning(f"Không thể load embedding model: {model_error}")
+            # Fallback: truy cập trực tiếp ChromaDB
+            import chromadb
+            from config import CHROMA_PERSIST_DIRECTORY, COLLECTION_NAME
+            
+            chroma_client = chromadb.PersistentClient(path=CHROMA_PERSIST_DIRECTORY)
+            collection = chroma_client.get_collection(name=COLLECTION_NAME)
+            total_docs = collection.count()
+            
+            # Lấy sample metadata
+            results = collection.get(
+                limit=10,
+                include=['metadatas']
+            )
+        else:
+            # Lấy 10 documents đầu tiên để debug
+            results = embedding_model.collection.get(
+                limit=10,
+                include=['metadatas']
+            )
+        
+        debug_info = {
+            "total_documents": total_docs,
+            "sample_metadata": results['metadatas'][:5] if results and results.get('metadatas') else [],
+            "all_metadata_keys": []
+        }
+        
+        if results and results.get('metadatas'):
+            # Lấy tất cả keys từ metadata
+            all_keys = set()
+            for metadata in results['metadatas']:
+                if metadata:  # Kiểm tra metadata không None
+                    all_keys.update(metadata.keys())
+            debug_info["all_metadata_keys"] = list(all_keys)
+        
+        return jsonify({
+            "success": True,
+            "debug_info": debug_info
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi debug metadata: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/documents/upload', methods=['POST'])
+@require_admin
+def upload_document():
+    """Upload PDF document"""
+    try:
+        if 'file' not in request.files:
+            return jsonify({
+                "success": False,
+                "error": "Không có file được upload"
+            }), 400
+        
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({
+                "success": False,
+                "error": "Không có file được chọn"
+            }), 400
+        
+        if not file.filename.lower().endswith('.pdf'):
+            return jsonify({
+                "success": False,
+                "error": "Chỉ chấp nhận file PDF"
+            }), 400
+        
+        # Tạo thư mục temp nếu chưa có
+        temp_dir = '/tmp'
+        if not os.path.exists(temp_dir):
+            os.makedirs(temp_dir)
+        
+        # Lưu file tạm thời
+        filename = secure_filename(file.filename)
+        temp_path = os.path.join(temp_dir, f"{int(time.time())}_{filename}")
+        file.save(temp_path)
+        
+        # Metadata từ form
+        title = request.form.get('title', filename.replace('.pdf', ''))
+        description = request.form.get('description', '')
+        author = request.form.get('author', '')
+        
+        # Tạo document_id duy nhất dựa trên số lượng tài liệu bổ sung hiện có
+        document_id = generate_unique_document_id(title)
+        
+        logger.info(f"Uploaded file: {filename} -> {temp_path}")
+        
+        return jsonify({
+            "success": True,
+            "message": "File đã được upload thành công",
+            "document_id": document_id,
+            "filename": filename,
+            "temp_path": temp_path,
+            "metadata": {
+                "title": title,
+                "description": description,
+                "author": author
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi upload document: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Lỗi upload: {str(e)}"
+        }), 500
+
+def generate_unique_document_id(title):
+    """Tạo document ID duy nhất dựa trên title và số thứ tự"""
+    try:
+        embedding_model = get_embedding_model()
+        
+        # Đếm số tài liệu bổ sung hiện có
+        results = embedding_model.collection.get(
+            where={"chapter": {"$like": "bosung%"}}
+        )
+        
+        if results and results.get('metadatas'):
+            # Lấy tất cả chapter IDs bắt đầu bằng "bosung"
+            existing_chapters = set()
+            for metadata in results['metadatas']:
+                if metadata and metadata.get('chapter'):
+                    chapter = metadata['chapter']
+                    if chapter.startswith('bosung'):
+                        existing_chapters.add(chapter)
+            
+            # Tìm số thứ tự cao nhất
+            max_num = 0
+            for chapter in existing_chapters:
+                try:
+                    num = int(chapter.replace('bosung', ''))
+                    max_num = max(max_num, num)
+                except:
+                    continue
+            
+            next_num = max_num + 1
+        else:
+            next_num = 1
+        
+        # Tạo ID mới
+        document_id = f"bosung{next_num}"
+        logger.info(f"Generated unique document ID: {document_id}")
+        
+        return document_id
+        
+    except Exception as e:
+        logger.error(f"Error generating document ID: {e}")
+        # Fallback: sử dụng timestamp
+        return f"bosung_{int(time.time())}"
+
+@admin_routes.route('/documents/<doc_id>/process', methods=['POST'])
+@require_admin
+def process_document(doc_id):
+    """Process document với Gemini - THÊM DEBUG LOGGING"""
+    try:
+        data = request.json
+        temp_path = data.get('temp_path')
+        
+        if not temp_path or not os.path.exists(temp_path):
+            return jsonify({
+                "success": False,
+                "error": "File không tồn tại"
+            }), 400
+        
+        logger.info(f"Processing document {doc_id} from {temp_path}")
+        
+        # Kiểm tra và import PyPDF2
+        try:
+            import PyPDF2
+        except ImportError:
+            logger.error("PyPDF2 không được cài đặt")
+            return jsonify({
+                "success": False,
+                "error": "Thiếu thư viện PyPDF2. Vui lòng cài đặt: pip install PyPDF2"
+            }), 500
+        
+        # Đọc PDF content
+        try:
+            with open(temp_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                pdf_text = ""
+                for page_num in range(len(pdf_reader.pages)):
+                    page = pdf_reader.pages[page_num]
+                    page_text = page.extract_text()
+                    if page_text:
+                        pdf_text += page_text + "\n"
+                        
+            logger.info(f"Extracted {len(pdf_text)} characters from PDF")
+            
+            # DEBUG: Log phần đầu của PDF text
+            logger.info(f"PDF text preview (first 500 chars): {pdf_text[:500]}...")
+            
+        except Exception as pdf_error:
+            logger.error(f"Lỗi đọc PDF: {pdf_error}")
+            return jsonify({
+                "success": False,
+                "error": f"Không thể đọc file PDF: {str(pdf_error)}"
+            }), 400
+        
+        if not pdf_text.strip():
+            return jsonify({
+                "success": False,
+                "error": "Không thể trích xuất text từ PDF. Vui lòng đảm bảo PDF có thể copy được chữ (không phải file scan)"
+            }), 400
+        
+        # Tạo prompt cho Gemini
+        try:
+            prompt = create_document_processing_prompt(pdf_text)
+            logger.info("Created prompt for Gemini")
+            
+            # DEBUG: Log độ dài prompt
+            logger.info(f"Prompt length: {len(prompt)} characters")
+            
+        except Exception as prompt_error:
+            logger.error(f"Lỗi tạo prompt: {prompt_error}")
+            return jsonify({
+                "success": False,
+                "error": f"Lỗi tạo prompt: {str(prompt_error)}"
+            }), 500
+        
+        # Gọi Gemini API
+        try:
+            model = genai.GenerativeModel('gemini-2.5-flash')
+            logger.info("Calling Gemini API...")
+            
+            response = model.generate_content(
+                prompt,
+                generation_config=genai.types.GenerationConfig(
+                    temperature=0.1,
+                    max_output_tokens=100000  # Sử dụng giá trị bạn đã tăng
+                )
+            )
+            
+            if not response or not response.text:
+                return jsonify({
+                    "success": False,
+                    "error": "Gemini không trả về response"
+                }), 500
+                
+            result_text = response.text.strip()
+            logger.info(f"Got response from Gemini: {len(result_text)} characters")
+            
+            # DEBUG: Log phần đầu của response
+            logger.info(f"Gemini response preview (first 1000 chars): {result_text[:1000]}...")
+            
+        except Exception as gemini_error:
+            logger.error(f"Lỗi gọi Gemini API: {gemini_error}")
+            return jsonify({
+                "success": False,
+                "error": f"Lỗi gọi AI API: {str(gemini_error)}"
+            }), 500
+        
+        # Parse JSON response
+        try:
+            # Làm sạch JSON response
+            original_result_text = result_text  # Lưu bản gốc để log
+            
+            if result_text.startswith('```json'):
+                result_text = result_text.replace('```json', '').replace('```', '').strip()
+            elif result_text.startswith('```'):
+                result_text = result_text[3:].rstrip('```').strip()
+            
+            logger.info(f"Cleaned response length: {len(result_text)} characters")
+            
+            processed_data = json.loads(result_text)
+            logger.info("Successfully parsed JSON response")
+            
+            # DEBUG: Log sample chunks để kiểm tra content vs summary
+            chunks = processed_data.get('chunks', [])
+            logger.info(f"Found {len(chunks)} chunks in response")
+            
+            if chunks:
+                for i, chunk in enumerate(chunks[:2]):  # Log 2 chunks đầu
+                    chunk_id = chunk.get('id', f'chunk_{i}')
+                    summary_len = len(chunk.get('summary', ''))
+                    content_len = len(chunk.get('content', ''))
+                    logger.info(f"Chunk {chunk_id}: summary_len={summary_len}, content_len={content_len}")
+                    
+                    # Log content preview
+                    content_preview = chunk.get('content', '')[:300]
+                    summary_preview = chunk.get('summary', '')[:300]
+                    logger.info(f"Chunk {chunk_id} content preview: {content_preview}...")
+                    logger.info(f"Chunk {chunk_id} summary preview: {summary_preview}...")
+            
+            # Lưu debug log vào file
+            debug_log_path = save_gemini_response_to_file(original_result_text, processed_data, doc_id)
+            logger.info(f"Debug log saved to: {debug_log_path}")
+            
+        except json.JSONDecodeError as json_error:
+            logger.error(f"JSON decode error: {json_error}")
+            logger.error(f"Raw response: {result_text}")
+            
+            # Lưu response lỗi vào file debug
+            try:
+                log_dir = setup_debug_logging()
+                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+                error_log_path = os.path.join(log_dir, f"gemini_error_{doc_id}_{timestamp}.log")
+                
+                with open(error_log_path, 'w', encoding='utf-8') as f:
+                    f.write("GEMINI JSON PARSE ERROR\n")
+                    f.write("=" * 40 + "\n")
+                    f.write(f"Error: {json_error}\n\n")
+                    f.write("Raw Response:\n")
+                    f.write(result_text)
+                
+                logger.info(f"Error log saved to: {error_log_path}")
+            except:
+                pass
+            
+            return jsonify({
+                "success": False,
+                "error": f"AI trả về format không hợp lệ: {str(json_error)}"
+            }), 500
+        
+        # Validate format
+        try:
+            if not validate_processed_format(processed_data):
+                return jsonify({
+                    "success": False,
+                    "error": "AI trả về format không đúng cấu trúc yêu cầu"
+                }), 500
+        except Exception as validate_error:
+            logger.error(f"Validation error: {validate_error}")
+            return jsonify({
+                "success": False,
+                "error": f"Lỗi validate format: {str(validate_error)}"
+            }), 500
+        
+        # Lưu vào ChromaDB
+        try:
+            save_processed_document(doc_id, processed_data)
+            logger.info(f"Successfully saved document {doc_id} to ChromaDB")
+        except Exception as save_error:
+            logger.error(f"Lỗi lưu document: {save_error}")
+            return jsonify({
+                "success": False,
+                "error": f"Lỗi lưu document: {str(save_error)}"
+            }), 500
+        
+        # Xóa file tạm
+        try:
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+                logger.info(f"Deleted temp file: {temp_path}")
+        except Exception as delete_error:
+            logger.warning(f"Cannot delete temp file: {delete_error}")
+        
+        return jsonify({
+            "success": True,
+            "message": "Xử lý tài liệu thành công",
+            "processed_chunks": len(processed_data.get('chunks', [])),
+            "processed_tables": len(processed_data.get('tables', [])),
+            "processed_figures": len(processed_data.get('figures', [])),
+            "document_id": doc_id,
+            "debug_log": debug_log_path  # Trả về đường dẫn log file
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi xử lý document: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Lỗi xử lý: {str(e)}"
+        }), 500
+
+def create_document_processing_prompt(pdf_text):
+    """Tạo prompt chi tiết cho Gemini - CẢI THIỆN THÊM"""
+    # Cắt ngắn text để tránh vượt quá limit
+    max_text_length = 80000  # Tăng lên do bạn đã tăng token limit
+    if len(pdf_text) > max_text_length:
+        pdf_text = pdf_text[:max_text_length] + "..."
+    
+    prompt = f"""
+Bạn là một chuyên gia phân tích tài liệu. Nhiệm vụ của bạn là phân tích và chia nhỏ tài liệu PDF thành các phần có nghĩa.
+
+TÀI LIỆU CẦN XỬ LÝ:
+{pdf_text}
+
+YÊU CẦU PHÂN TÍCH:
+
+1. PHÂN CHIA NỘI DUNG:
+   - Chia tài liệu thành các chunk có nghĩa (mỗi chunk 200-1000 từ)
+   - QUAN TRỌNG: Trong field "content" của mỗi chunk, bạn PHẢI SAO CHÉP NGUYÊN VĂN nội dung từ tài liệu gốc
+   - Field "summary" chỉ là tóm tắt ngắn gọn (1-2 câu)
+   - Field "content" phải chứa toàn bộ văn bản gốc của phần đó
+   - KHÔNG viết lại, KHÔNG diễn giải, KHÔNG tóm tắt trong field "content"
+
+2. CẤU TRÚC JSON:
+Mỗi chunk PHẢI có đủ các field sau:
+- "id": ID duy nhất 
+- "title": Tiêu đề của chunk
+- "content": NỘI DUNG NGUYÊN VĂN từ PDF (bắt buộc phải có)
+- "summary": Tóm tắt ngắn gọn (khác với content)
+- "content_type": "text", "table", hoặc "figure"
+- "age_range": [min_age, max_age] từ 1-19
+- "pages": trang nếu biết
+- "related_chunks": []
+- "word_count": số từ trong content
+- "token_count": ước tính token
+
+3. VÍ DỤ ĐÚNG:
+{{
+  "id": "bosung1_muc1_1",
+  "title": "Giới thiệu về dinh dưỡng",
+  "content": "Dinh dưỡng là quá trình cung cấp cho cơ thể các chất cần thiết để duy trì sự sống, phát triển và hoạt động. Các chất dinh dưỡng bao gồm...", 
+  "summary": "Giới thiệu khái niệm cơ bản về dinh dưỡng",
+  "content_type": "text",
+  "age_range": [1, 19]
+}}
+
+4. ĐỊNH DẠNG OUTPUT JSON:
+{{
+    "bai_info": {{
+        "id": "bosung1",
+        "title": "Tiêu đề tài liệu",
+        "overview": "Tổng quan"
+    }},
+    "chunks": [
+        {{
+            "id": "bosung1_muc1_1",
+            "title": "Tiêu đề chunk",
+            "content": "NỘI DUNG NGUYÊN VĂN TỪ PDF - BẮTED BUỘC PHẢI CÓ",
+            "summary": "Tóm tắt ngắn gọn",
+            "content_type": "text",
+            "age_range": [1, 19],
+            "pages": "",
+            "related_chunks": [],
+            "word_count": 100,
+            "token_count": 150,
+            "contains_table": false,
+            "contains_figure": false
+        }}
+    ],
+    "tables": [],
+    "figures": [],
+    "total_items": {{"chunks": 1, "tables": 0, "figures": 0}}
+}}
+
+LƯU Ý QUAN TRỌNG:
+- Field "content" PHẢI chứa văn bản nguyên gốc từ PDF
+- Field "summary" mới là phần tóm tắt
+- KHÔNG được để field "content" trống hoặc giống "summary"
+- Trả về JSON hợp lệ, không có text thừa
+
+Hãy phân tích và trả về JSON, đảm bảo field "content" chứa nội dung đầy đủ từ PDF.
+"""
+    return prompt
+
+def validate_processed_format(data):
+    """Validate format của processed data"""
+    try:
+        # Kiểm tra required fields
+        required_fields = ['bai_info', 'chunks', 'total_items']
+        for field in required_fields:
+            if field not in data:
+                logger.error(f"Missing required field: {field}")
+                return False
+        
+        # Validate bai_info
+        bai_info = data['bai_info']
+        bai_info_fields = ['id', 'title', 'overview']
+        for field in bai_info_fields:
+            if field not in bai_info:
+                logger.error(f"Missing bai_info field: {field}")
+                return False
+        
+        # Validate chunks
+        if not isinstance(data['chunks'], list):
+            logger.error("chunks must be a list")
+            return False
+        
+        for i, chunk in enumerate(data['chunks']):
+            chunk_fields = ['id', 'title', 'content_type', 'age_range', 'summary']
+            for field in chunk_fields:
+                if field not in chunk:
+                    logger.error(f"Missing chunk field '{field}' in chunk {i}")
+                    return False
+            
+            # Validate age_range
+            age_range = chunk['age_range']
+            if not isinstance(age_range, list) or len(age_range) != 2:
+                logger.error(f"Invalid age_range in chunk {i}: must be list of 2 integers")
+                return False
+            
+            if not all(isinstance(x, int) and 1 <= x <= 19 for x in age_range):
+                logger.error(f"Invalid age_range values in chunk {i}: must be integers 1-19")
+                return False
+        
+        # Validate optional fields
+        for table in data.get('tables', []):
+            if 'age_range' in table:
+                age_range = table['age_range']
+                if not isinstance(age_range, list) or len(age_range) != 2:
+                    logger.error("Invalid age_range in table")
+                    return False
+        
+        for figure in data.get('figures', []):
+            if 'age_range' in figure:
+                age_range = figure['age_range']
+                if not isinstance(age_range, list) or len(age_range) != 2:
+                    logger.error("Invalid age_range in figure")
+                    return False
+        
+        logger.info("Document format validation passed")
+        return True
+        
+    except Exception as e:
+        logger.error(f"Validation error: {e}")
+        return False
+
+def save_processed_document(doc_id, processed_data):
+    try:
+        embedding_model = get_embedding_model()
+        
+        document_title = processed_data.get('bai_info', {}).get('title', f'Tài liệu {doc_id}')
+        
+        # Chuẩn bị tất cả items để index
+        all_items = []
+        
+        # Xử lý chunks
+        for chunk in processed_data.get('chunks', []):
+            chunk_content = chunk.get('content', chunk.get('summary', ''))
+            if not chunk_content:
+                # Fallback nếu không có content
+                chunk_content = f"Tiêu đề: {chunk['title']}\nNội dung: {chunk.get('summary', '')}"
+            
+            # Chuẩn bị metadata theo format cần thiết
+            metadata = {
+                "chunk_id": chunk['id'],
+                "chapter": doc_id,
+                "title": chunk['title'],
+                "content_type": chunk['content_type'],
+                "age_range": f"{chunk['age_range'][0]}-{chunk['age_range'][1]}",
+                "age_min": chunk['age_range'][0],
+                "age_max": chunk['age_range'][1],
+                "summary": chunk['summary'],
+                "pages": chunk.get('pages', ''),
+                "related_chunks": ','.join(chunk.get('related_chunks', [])),
+                "word_count": chunk.get('word_count', 0),
+                "token_count": chunk.get('token_count', 0),
+                "contains_table": chunk.get('contains_table', False),
+                "contains_figure": chunk.get('contains_figure', False),
+                "created_at": datetime.datetime.now().isoformat(),
+                "document_source": document_title,
+                "document_title": document_title
+            }
+            
+            # Thêm vào danh sách
+            all_items.append({
+                "content": chunk_content,
+                "metadata": metadata,
+                "id": chunk['id']
+            })
+        
+        # Xử lý tables
+        for table in processed_data.get('tables', []):
+            table_content = table.get('content', f"Bảng: {table['title']}\nMô tả: {table.get('summary', '')}")
+            
+            metadata = {
+                "chunk_id": table['id'],
+                "chapter": doc_id,
+                "title": table['title'],
+                "content_type": "table",
+                "age_range": f"{table['age_range'][0]}-{table['age_range'][1]}",
+                "age_min": table['age_range'][0],
+                "age_max": table['age_range'][1],
+                "summary": table['summary'],
+                "pages": table.get('pages', ''),
+                "related_chunks": ','.join(table.get('related_chunks', [])),
+                "table_columns": ','.join(table.get('table_columns', [])),
+                "word_count": table.get('word_count', 0),
+                "token_count": table.get('token_count', 0),
+                "created_at": datetime.datetime.now().isoformat(),
+                "document_source": document_title,
+                "document_title": document_title  
+            }
+            
+            all_items.append({
+                "content": table_content,
+                "metadata": metadata,
+                "id": table['id']
+            })
+        
+        # Xử lý figures
+        for figure in processed_data.get('figures', []):
+            figure_content = figure.get('content', f"Hình: {figure['title']}\nMô tả: {figure.get('summary', '')}")
+            
+            metadata = {
+                "chunk_id": figure['id'],
+                "chapter": doc_id,
+                "title": figure['title'],
+                "content_type": "figure",
+                "age_range": f"{figure['age_range'][0]}-{figure['age_range'][1]}",
+                "age_min": figure['age_range'][0],
+                "age_max": figure['age_range'][1],
+                "summary": figure['summary'],
+                "pages": figure.get('pages', ''),
+                "related_chunks": ','.join(figure.get('related_chunks', [])),
+                "created_at": datetime.datetime.now().isoformat(),
+                "document_source": document_title, 
+                "document_title": document_title  
+            }
+            
+            all_items.append({
+                "content": figure_content,
+                "metadata": metadata,
+                "id": figure['id']
+            })
+        
+        # Sử dụng index_chunks để lưu tất cả items
+        if all_items:
+            success = embedding_model.index_chunks(all_items)
+            if success:
+                logger.info(f"Successfully indexed {len(all_items)} items for document {doc_id} (title: {document_title})")
+            else:
+                raise Exception("Failed to index chunks")
+        else:
+            logger.warning(f"No items to index for document {doc_id}")
+        
+    except Exception as e:
+        logger.error(f"Error in save_processed_document: {str(e)}")
+        raise
+
+@admin_routes.route('/documents/<doc_id>', methods=['DELETE'])
+@require_admin
+def delete_document(doc_id):
+    """Xóa document theo chapter"""
+    try:
+        embedding_model = get_embedding_model()
+        
+        # Lấy tất cả chunks của document - BỎ include=['ids']
+        results = embedding_model.collection.get(
+            where={"chapter": doc_id}
+            # Không cần include=['ids'] vì mặc định đã trả về ids
+        )
+        
+        if results and results.get('ids'):
+            # Xóa từng chunk
+            for chunk_id in results['ids']:
+                embedding_model.collection.delete(ids=[chunk_id])
+            
+            return jsonify({
+                "success": True,
+                "message": f"Đã xóa {len(results['ids'])} chunks của document {doc_id}"
+            })
+        else:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy document"
+            }), 404
+        
+    except Exception as e:
+        logger.error(f"Lỗi xóa document: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/documents/bulk-delete', methods=['POST'])
+@require_admin
+def bulk_delete_documents():
+    """Xóa nhiều documents"""
+    try:
+        data = request.json
+        doc_ids = data.get('doc_ids', [])
+        
+        if not doc_ids:
+            return jsonify({
+                "success": False,
+                "error": "Không có document nào được chọn"
+            }), 400
+        
+        embedding_model = get_embedding_model()
+        deleted_count = 0
+        
+        for doc_id in doc_ids:
+            try:
+                # SỬA: Bỏ include=['ids']
+                results = embedding_model.collection.get(
+                    where={"chapter": doc_id}
+                )
+                
+                if results and results.get('ids'):
+                    for chunk_id in results['ids']:
+                        embedding_model.collection.delete(ids=[chunk_id])
+                    deleted_count += 1
+                    
+            except Exception as e:
+                logger.error(f"Lỗi xóa document {doc_id}: {e}")
+                continue
+        
+        return jsonify({
+            "success": True,
+            "message": f"Đã xóa {deleted_count}/{len(doc_ids)} documents",
+            "deleted_count": deleted_count
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi xóa bulk documents: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+# ===== ANALYTICS ROUTES =====
+
+@admin_routes.route('/analytics/overview', methods=['GET'])
+@require_admin
+def get_analytics_overview():
+    """Lấy thống kê phân tích"""
+    try:
+        db = get_db()
+        
+        # Thống kê cơ bản
+        total_conversations = db.conversations.count_documents({})
+        total_users = db.users.count_documents({}) if hasattr(db, 'users') else 1
+        
+        # Thống kê theo tuần (7 ngày gần nhất)
+        daily_stats = []
+        for i in range(7):
+            day_start = datetime.datetime.now() - datetime.timedelta(days=6-i)
+            day_end = day_start + datetime.timedelta(days=1)
+            
+            daily_conversations = db.conversations.count_documents({
+                "created_at": {"$gte": day_start, "$lt": day_end}
+            })
+            
+            daily_stats.append({
+                "date": day_start.strftime("%Y-%m-%d"),
+                "label": day_start.strftime("%d/%m"),
+                "conversations": daily_conversations,
+                "users": 0  # Mock data
+            })
+        
+        # Thống kê theo độ tuổi
+        age_stats = list(db.conversations.aggregate([
+            {"$group": {"_id": "$age_context", "count": {"$sum": 1}}},
+            {"$sort": {"_id": 1}}
+        ]))
+        
+        return jsonify({
+            "success": True,
+            "overview": {
+                "totalUsers": total_users,
+                "activeUsers": total_users,
+                "totalConversations": total_conversations,
+                "avgMessagesPerConversation": 6.8,
+                "userGrowth": "+8.5%",
+                "conversationGrowth": "+12.3%"
+            },
+            "dailyStats": daily_stats,
+            "ageDistribution": [
+                {
+                    "age_group": f"{stat['_id']} tuổi" if stat['_id'] else "Không rõ",
+                    "count": stat["count"]
+                }
+                for stat in age_stats
+            ]
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy analytics: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/users/<user_id>', methods=['PUT'])
+@require_admin
+def update_user(user_id):
+    """Cập nhật thông tin người dùng"""
+    try:
+        data = request.json
+        
+        user = User.find_by_id(user_id)
+        if not user:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy người dùng"
+            }), 404
+        
+        # Cập nhật thông tin
+        if 'name' in data:
+            user.name = data['name']
+        
+        if 'gender' in data:
+            user.gender = data['gender']
+        
+        if 'role' in data:
+            user.role = data['role']
+        
+        # Lưu thay đổi
+        user.save()
+        
+        return jsonify({
+            "success": True,
+            "message": "Cập nhật người dùng thành công",
+            "user": {
+                "id": str(user.user_id),
+                "name": user.name,
+                "email": user.email,
+                "gender": user.gender,
+                "role": user.role
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi cập nhật user: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/feedback', methods=['GET'])
+@require_admin
+def get_all_feedback():
+    """API endpoint để admin xem tất cả feedback"""
+    try:
+        page = int(request.args.get('page', 1))
+        per_page = int(request.args.get('per_page', 20))
+        status_filter = request.args.get('status')
+        skip = (page - 1) * per_page
+        
+        feedbacks = Feedback.get_all_for_admin(limit=per_page, skip=skip, status_filter=status_filter)
+        
+        result = []
+        for feedback in feedbacks:
+            result.append({
+                "id": str(feedback.feedback_id),
+                "user_name": getattr(feedback, 'user_name', 'Ẩn danh'),
+                "user_email": getattr(feedback, 'user_email', ''),
+                "rating": feedback.rating,
+                "category": feedback.category,
+                "title": feedback.title,
+                "content": feedback.content,
+                "status": feedback.status,
+                "admin_response": feedback.admin_response,
+                "created_at": feedback.created_at.isoformat(),
+                "updated_at": feedback.updated_at.isoformat()
+            })
+        
+        return jsonify({
+            "success": True,
+            "feedbacks": result
+        })
+        
+    except Exception as e:
+        logger.error(f"Error getting feedback for admin: {e}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/feedback/stats', methods=['GET'])
+@require_admin
+def get_feedback_stats():
+    """API endpoint để lấy thống kê feedback"""
+    try:
+        stats = Feedback.get_stats()
+        return jsonify({
+            "success": True,
+            "stats": stats
+        })
+    except Exception as e:
+        logger.error(f"Error getting feedback stats: {e}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/feedback/<feedback_id>/respond', methods=['PUT'])
+@require_admin
+def respond_to_feedback(feedback_id):
+    """API endpoint để admin phản hồi feedback"""
+    try:
+        data = request.json
+        response_text = data.get('response', '')
+        new_status = data.get('status', 'reviewed')
+        
+        if not response_text.strip():
+            return jsonify({
+                "success": False,
+                "error": "Vui lòng nhập phản hồi"
+            }), 400
+        
+        feedback = Feedback.find_by_id(feedback_id)
+        if not feedback:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy feedback"
+            }), 404
+        
+        success = feedback.update_admin_response(response_text.strip(), new_status)
+        
+        if success:
+            return jsonify({
+                "success": True,
+                "message": "Đã phản hồi feedback thành công"
+            })
+        else:
+            return jsonify({
+                "success": False,
+                "error": "Không thể cập nhật phản hồi"
+            }), 500
+        
+    except Exception as e:
+        logger.error(f"Error responding to feedback: {e}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+# ===== SYSTEM SETTINGS ROUTES =====
+
+@admin_routes.route('/settings/system-config', methods=['GET'])
+@require_admin
+def get_system_config():
+    """Lấy cấu hình hệ thống thật"""
+    try:
+        import os
+        from config import EMBEDDING_MODEL, GEMINI_API_KEY, CHROMA_PERSIST_DIRECTORY, COLLECTION_NAME
+        from core.embedding_model import get_embedding_model
+        
+        # Thông tin database
+        db = get_db()
+        
+        # Thông tin Collections trong MongoDB
+        try:
+            mongo_collections = db.list_collection_names()
+            mongo_stats = {}
+            for collection_name in mongo_collections:
+                collection = db[collection_name]
+                mongo_stats[collection_name] = {
+                    "document_count": collection.count_documents({}),
+                    "estimated_size": collection.estimated_document_count()
+                }
+        except Exception as e:
+            mongo_collections = []
+            mongo_stats = {"error": str(e)}
+        
+        # Thông tin ChromaDB/Vector Database
+        try:
+            embedding_model = get_embedding_model()
+            vector_stats = embedding_model.get_stats()
+            chroma_status = "Connected"
+            vector_count = embedding_model.count()
+        except Exception as e:
+            vector_stats = {"error": str(e)}
+            chroma_status = "Error"
+            vector_count = 0
+        
+        # Thông tin Gemini API
+        gemini_status = "Connected" if GEMINI_API_KEY else "Not configured"
+        
+        # Thông tin hệ thống
+        import platform
+        import psutil
+        
+        system_info = {
+            "python_version": platform.python_version(),
+            "platform": platform.platform(),
+            "cpu_count": psutil.cpu_count(),
+            "memory_total": round(psutil.virtual_memory().total / (1024**3), 2),  # GB
+            "memory_available": round(psutil.virtual_memory().available / (1024**3), 2),  # GB
+            "disk_usage": round(psutil.disk_usage('/').percent, 2)
+        }
+        
+        # Cấu hình application
+        app_config = {
+            "debug_mode": os.getenv("FLASK_ENV") == "development",
+            "secret_key_configured": bool(os.getenv("JWT_SECRET_KEY")),
+            "mongodb_uri": os.getenv("MONGO_URI", "mongodb://localhost:27017/"),
+            "database_name": os.getenv("MONGO_DB_NAME", "nutribot_db"),
+            "embedding_model": EMBEDDING_MODEL,
+            "chroma_directory": CHROMA_PERSIST_DIRECTORY,
+            "collection_name": COLLECTION_NAME,
+            "gemini_configured": bool(GEMINI_API_KEY)
+        }
+        
+        return jsonify({
+            "success": True,
+            "system_config": {
+                "application": app_config,
+                "system": system_info,
+                "database": {
+                    "mongodb": {
+                        "status": "Connected",
+                        "collections": mongo_collections,
+                        "statistics": mongo_stats
+                    },
+                    "vector_db": {
+                        "status": chroma_status,
+                        "document_count": vector_count,
+                        "statistics": vector_stats
+                    }
+                },
+                "ai_services": {
+                    "gemini": {
+                        "status": gemini_status,
+                        "model": "gemini-2.0-flash"
+                    }
+                }
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy system config: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/settings/performance', methods=['GET'])
+@require_admin
+def get_performance_metrics():
+    """Lấy metrics hiệu năng hệ thống"""
+    try:
+        import psutil
+        import time
+        from datetime import datetime, timedelta
+        
+        # CPU và Memory hiện tại
+        cpu_percent = psutil.cpu_percent(interval=1)
+        memory = psutil.virtual_memory()
+        disk = psutil.disk_usage('/')
+        
+        # Thống kê database
+        db = get_db()
+        
+        # Thống kê MongoDB performance
+        try:
+            # Thời gian trung bình cho queries (mock data - MongoDB professional monitoring cần tools khác)
+            conversations_count = db.conversations.count_documents({})
+            users_count = db.users.count_documents({}) if hasattr(db, 'users') else 0
+            
+            # Tốc độ xử lý tin nhắn trong 24h qua
+            yesterday = datetime.now() - timedelta(days=1)
+            recent_conversations = db.conversations.count_documents({
+                "updated_at": {"$gte": yesterday}
+            })
+            
+            db_performance = {
+                "total_documents": conversations_count + users_count,
+                "query_speed": "~50ms",  # Mock data
+                "recent_activity": recent_conversations,
+                "index_efficiency": "95%"  # Mock data
+            }
+        except Exception as e:
+            db_performance = {"error": str(e)}
+        
+        # Vector DB performance
+        try:
+            from core.embedding_model import get_embedding_model
+            embedding_model = get_embedding_model()
+            vector_count = embedding_model.count()
+            
+            # Test search speed
+            start_time = time.time()
+            test_results = embedding_model.search("test query", top_k=5)
+            search_time = (time.time() - start_time) * 1000  # milliseconds
+            
+            vector_performance = {
+                "total_vectors": vector_count,
+                "search_speed_ms": round(search_time, 2),
+                "embedding_dimension": 768,  # multilingual-e5-base dimension
+                "retrieval_accuracy": "85%"  # Mock data - would need evaluation dataset
+            }
+        except Exception as e:
+            vector_performance = {"error": str(e)}
+        
+        # AI API performance
+        ai_performance = {
+            "average_response_time": "2.5s",  # Mock data
+            "success_rate": "98.5%",  # Mock data
+            "daily_requests": recent_conversations * 2,  # Estimate
+            "token_usage": "~150k tokens/day"  # Mock data
+        }
+        
+        return jsonify({
+            "success": True,
+            "performance": {
+                "system": {
+                    "cpu_usage": cpu_percent,
+                    "memory_usage": memory.percent,
+                    "memory_total_gb": round(memory.total / (1024**3), 2),
+                    "memory_used_gb": round(memory.used / (1024**3), 2),
+                    "disk_usage": disk.percent,
+                    "disk_total_gb": round(disk.total / (1024**3), 2),
+                    "uptime": "24h 15m"  # Mock data
+                },
+                "database": db_performance,
+                "vector_search": vector_performance,
+                "ai_generation": ai_performance
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy performance metrics: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/settings/logs', methods=['GET'])
+@require_admin  
+def get_system_logs():
+    """Lấy logs hệ thống"""
+    try:
+        import os
+        from datetime import datetime
+        
+        log_entries = []
+        
+        # Đọc logs từ file nếu có
+        log_files = [
+            "logs/app.log",
+            "logs/error.log", 
+            "embed_data.log"
+        ]
+        
+        for log_file in log_files:
+            if os.path.exists(log_file):
+                try:
+                    with open(log_file, 'r', encoding='utf-8') as f:
+                        lines = f.readlines()
+                        # Lấy 50 dòng cuối
+                        recent_lines = lines[-50:] if len(lines) > 50 else lines
+                        
+                        for line in recent_lines:
+                            if line.strip():
+                                log_entries.append({
+                                    "timestamp": datetime.now().isoformat(),
+                                    "level": "INFO",  # Parse từ log format thực tế
+                                    "source": log_file,
+                                    "message": line.strip()
+                                })
+                except Exception as e:
+                    log_entries.append({
+                        "timestamp": datetime.now().isoformat(),
+                        "level": "ERROR",
+                        "source": "system",
+                        "message": f"Cannot read {log_file}: {str(e)}"
+                    })
+        
+        # Nếu không có log files, tạo mock logs
+        if not log_entries:
+            log_entries = [
+                {
+                    "timestamp": datetime.now().isoformat(),
+                    "level": "INFO",
+                    "source": "system",
+                    "message": "Application started successfully"
+                },
+                {
+                    "timestamp": datetime.now().isoformat(),
+                    "level": "INFO", 
+                    "source": "database",
+                    "message": "MongoDB connection established"
+                },
+                {
+                    "timestamp": datetime.now().isoformat(),
+                    "level": "INFO",
+                    "source": "vector_db",
+                    "message": "ChromaDB initialized successfully"
+                }
+            ]
+        
+        # Sort by timestamp descending
+        log_entries.sort(key=lambda x: x["timestamp"], reverse=True)
+        
+        return jsonify({
+            "success": True,
+            "logs": log_entries[:100]  # Limit to 100 entries
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy system logs: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/settings/backup', methods=['POST'])
+@require_admin
+def create_backup():
+    """Tạo backup dữ liệu"""
+    try:
+        from datetime import datetime
+        import json
+        import os
+        
+        # Tạo thư mục backup nếu chưa có
+        backup_dir = "backups"
+        if not os.path.exists(backup_dir):
+            os.makedirs(backup_dir)
+        
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        # Backup MongoDB data
+        db = get_db()
+        backup_data = {
+            "timestamp": datetime.now().isoformat(),
+            "collections": {}
+        }
+        
+        # Export conversations
+        conversations = list(db.conversations.find({}))
+        for conv in conversations:
+            conv["_id"] = str(conv["_id"])  # Convert ObjectId to string
+            if "user_id" in conv:
+                conv["user_id"] = str(conv["user_id"])
+        backup_data["collections"]["conversations"] = conversations
+        
+        # Export users if exists
+        if hasattr(db, 'users'):
+            users = list(db.users.find({}))
+            for user in users:
+                user["_id"] = str(user["_id"])
+                # Remove password for security
+                if "password" in user:
+                    del user["password"]
+            backup_data["collections"]["users"] = users
+        
+        # Save backup file
+        backup_filename = f"backup_{timestamp}.json"
+        backup_path = os.path.join(backup_dir, backup_filename)
+        
+        with open(backup_path, 'w', encoding='utf-8') as f:
+            json.dump(backup_data, f, indent=2, default=str, ensure_ascii=False)
+        
+        # Get file size
+        file_size = os.path.getsize(backup_path)
+        file_size_mb = round(file_size / (1024 * 1024), 2)
+        
+        return jsonify({
+            "success": True,
+            "message": "Backup created successfully",
+            "backup": {
+                "filename": backup_filename,
+                "path": backup_path,
+                "size_mb": file_size_mb,
+                "timestamp": datetime.now().isoformat(),
+                "collections_count": len(backup_data["collections"]),
+                "total_documents": sum(len(coll) for coll in backup_data["collections"].values())
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi tạo backup: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@admin_routes.route('/settings/security', methods=['GET'])
+@require_admin
+def get_security_settings():
+    """Lấy cài đặt bảo mật"""
+    try:
+        import os
+        from datetime import datetime, timedelta
+        
+        # Kiểm tra cấu hình bảo mật
+        security_config = {
+            "jwt_configured": bool(os.getenv("JWT_SECRET_KEY")),
+            "admin_accounts": 1,  # Mock data
+            "password_policy": {
+                "min_length": 6,
+                "require_special_chars": False,
+                "require_numbers": False
+            },
+            "session_timeout": "24 hours",
+            "ssl_enabled": False,  # Mock data
+            "rate_limiting": False  # Mock data
+        }
+        
+        # Recent login attempts (mock data)
+        recent_logins = [
+            {
+                "timestamp": (datetime.now() - timedelta(hours=1)).isoformat(),
+                "user": "[email protected]", 
+                "ip": "127.0.0.1",
+                "status": "success"
+            },
+            {
+                "timestamp": (datetime.now() - timedelta(hours=3)).isoformat(),
+                "user": "[email protected]",
+                "ip": "127.0.0.1", 
+                "status": "success"
+            }
+        ]
+        
+        # Security recommendations
+        recommendations = [
+            {
+                "priority": "high",
+                "title": "Enable HTTPS",
+                "description": "Deploy with SSL certificate for production"
+            },
+            {
+                "priority": "medium", 
+                "title": "Implement Rate Limiting",
+                "description": "Add rate limiting to prevent abuse"
+            },
+            {
+                "priority": "low",
+                "title": "Strengthen Password Policy", 
+                "description": "Require stronger passwords for admin accounts"
+            }
+        ]
+        
+        return jsonify({
+            "success": True,
+            "security": {
+                "configuration": security_config,
+                "recent_logins": recent_logins,
+                "recommendations": recommendations
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy security settings: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500

api/auth.py

@@ -0,0 +1,508 @@
+from flask import Blueprint, request, jsonify, make_response
+import re
+import logging
+from models.user_model import User
+from flask_jwt_extended import create_access_token, get_jwt_identity, jwt_required, get_jwt
+import datetime
+from functools import wraps
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+# Tạo blueprint
+auth_routes = Blueprint('auth', __name__)
+
+def validate_email(email):
+    """Kiểm tra định dạng email"""
+    pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
+    return re.match(pattern, email) is not None
+
+def validate_password(password):
+    """Kiểm tra mật khẩu có đủ mạnh không"""
+    return len(password) >= 6
+
+# SỬA: Decorator đơn giản hơn để check admin
+def require_admin(f):
+    """Decorator đơn giản để kiểm tra admin"""
+    @wraps(f)
+    @jwt_required()
+    def decorated_function(*args, **kwargs):
+        try:
+            user_id = get_jwt_identity()
+            user = User.find_by_id(user_id)
+            
+            if not user:
+                return jsonify({
+                    "success": False,
+                    "error": "User không tồn tại"
+                }), 403
+            
+            # Kiểm tra có phải admin không
+            if not user.is_admin():
+                return jsonify({
+                    "success": False,
+                    "error": "Không có quyền truy cập admin"
+                }), 403
+            
+            # Thêm user vào request context
+            request.current_user = user
+            return f(*args, **kwargs)
+            
+        except Exception as e:
+            logger.error(f"Lỗi xác thực admin: {e}")
+            return jsonify({
+                "success": False,
+                "error": "Lỗi xác thực"
+            }), 500
+    return decorated_function
+
+def register_user(name, email, password, gender=None):
+    """Đăng ký người dùng mới"""
+    if not name or not email or not password:
+        return False, "Vui lòng nhập đầy đủ thông tin"
+    
+    if not validate_email(email):
+        return False, "Email không hợp lệ"
+    
+    if not validate_password(password):
+        return False, "Mật khẩu phải có ít nhất 6 ký tự"
+    
+    success, result = User.register(name, email, password, gender)
+    if success:
+        return True, {"user_id": result}
+    else:
+        return False, result
+
+def login_user(email, password):
+    """Đăng nhập người dùng"""
+    if not email or not password:
+        return False, "Vui lòng nhập đầy đủ thông tin đăng nhập"
+    
+    success, result = User.login(email, password)
+    if success:
+        user = result
+        
+        # Tạo JWT token với thời gian hết hạn 24 giờ
+        expires = datetime.timedelta(hours=24)
+        access_token = create_access_token(
+            identity=str(user.user_id), 
+            expires_delta=expires,
+            additional_claims={
+                "name": user.name,
+                "email": user.email,
+                "gender": user.gender,
+                "role": user.role,
+                "permissions": user.permissions,
+                "is_admin": user.is_admin()
+            }
+        )
+        
+        return True, {
+            "user_id": str(user.user_id),
+            "user": {
+                "id": str(user.user_id),
+                "name": user.name,
+                "email": user.email,
+                "gender": user.gender,
+                "role": user.role,
+                "permissions": user.permissions,
+                "is_admin": user.is_admin()
+            },
+            "access_token": access_token,
+            "expires_in": 86400
+        }
+    else:
+        return False, result
+
+@auth_routes.route('/register', methods=['POST'])
+def register():
+    """API endpoint để đăng ký người dùng mới"""
+    try:
+        data = request.json
+        
+        name = data.get('fullName')
+        email = data.get('email')
+        password = data.get('password')
+        gender = data.get('gender')
+        
+        success, result = register_user(name, email, password, gender)
+        
+        if success:
+            return jsonify({
+                "success": True,
+                "message": "Đăng ký thành công",
+                "user_id": result.get("user_id")
+            })
+        else:
+            return jsonify({
+                "success": False,
+                "error": result
+            }), 400
+            
+    except Exception as e:
+        logger.error(f"Lỗi đăng ký người dùng: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@auth_routes.route('/login', methods=['POST'])
+def login():
+    """API endpoint để đăng nhập"""
+    try:
+        data = request.json
+        
+        email = data.get('email')
+        password = data.get('password')
+        remember_me = data.get('rememberMe', False)
+        
+        success, result = login_user(email, password)
+        
+        if success:
+            access_token = result.get("access_token")
+            
+            response = make_response(jsonify({
+                "success": True,
+                "user_id": result.get("user_id"),
+                "user": result.get("user"),
+                "access_token": access_token,
+                "expires_in": result.get("expires_in")
+            }))
+            
+            cookie_max_age = 86400 if remember_me else None
+            response.set_cookie(
+                'access_token_cookie',
+                access_token,
+                max_age=cookie_max_age,
+                httponly=True,
+                path='/api',
+                samesite='Lax',
+                secure=False
+            )
+            
+            return response
+        else:
+            return jsonify({
+                "success": False,
+                "error": result
+            }), 401
+            
+    except Exception as e:
+        logger.error(f"Lỗi đăng nhập: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@auth_routes.route('/logout', methods=['POST'])
+def logout():
+    """API endpoint để đăng xuất"""
+    response = make_response(jsonify({
+        "success": True,
+        "message": "Đăng xuất thành công"
+    }))
+    response.delete_cookie('access_token_cookie', path='/api')
+    return response
+
+@auth_routes.route('/verify-token', methods=['POST'])
+@jwt_required()
+def verify_token():
+    """API endpoint để kiểm tra token có hợp lệ không"""
+    try:
+        current_user_id = get_jwt_identity()
+        
+        user = User.find_by_id(current_user_id)
+        if not user:
+            return jsonify({
+                "success": False,
+                "error": "User không tồn tại"
+            }), 401
+        
+        return jsonify({
+            "success": True,
+            "user_id": current_user_id,
+            "user": {
+                "id": str(user.user_id),
+                "name": user.name,
+                "email": user.email,
+                "gender": user.gender,
+                "role": user.role,
+                "permissions": user.permissions,
+                "is_admin": user.is_admin()
+            }
+        })
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 401
+
+@auth_routes.route('/profile', methods=['GET'])
+@jwt_required()
+def user_profile():
+    """API endpoint để lấy thông tin người dùng"""
+    try:
+        user_id = get_jwt_identity()
+        user = User.find_by_id(user_id)
+        
+        if user:
+            profile = {
+                "id": str(user.user_id),
+                "name": user.name,
+                "email": user.email,
+                "gender": user.gender,
+                "role": user.role,
+                "permissions": user.permissions,
+                "is_admin": user.is_admin(),
+                "created_at": user.created_at.isoformat() if user.created_at else None,
+                "updated_at": user.updated_at.isoformat() if user.updated_at else None,
+                "last_login": user.last_login.isoformat() if user.last_login else None
+            }
+            
+            return jsonify({
+                "success": True,
+                "user": profile
+            })
+        else:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy thông tin người dùng"
+            }), 404
+            
+    except Exception as e:
+        logger.error(f"Lỗi lấy thông tin người dùng: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@auth_routes.route('/profile', methods=['PUT'])
+@jwt_required()
+def update_profile():
+    """API endpoint để cập nhật thông tin người dùng"""
+    try:
+        data = request.json
+        user_id = get_jwt_identity()
+        
+        user = User.find_by_id(user_id)
+        if not user:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy người dùng"
+            }), 404
+        
+        if 'name' in data:
+            user.name = data['name']
+        
+        if 'gender' in data:
+            user.gender = data['gender']
+        
+        user.save()
+        
+        return jsonify({
+            "success": True,
+            "message": "Cập nhật thông tin thành công"
+        })
+            
+    except Exception as e:
+        logger.error(f"Lỗi cập nhật thông tin người dùng: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@auth_routes.route('/change-password', methods=['POST'])
+@jwt_required()
+def update_password():
+    """API endpoint để đổi mật khẩu"""
+    try:
+        data = request.json
+        user_id = get_jwt_identity()
+            
+        current_password = data.get('currentPassword')
+        new_password = data.get('newPassword')
+        
+        user = User.find_by_id(user_id)
+        if not user:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy người dùng"
+            }), 404
+        
+        if not User.check_password(user.password, current_password):
+            return jsonify({
+                "success": False,
+                "error": "Mật khẩu hiện tại không chính xác"
+            }), 400
+        
+        if not validate_password(new_password):
+            return jsonify({
+                "success": False,
+                "error": "Mật khẩu mới phải có ít nhất 6 ký tự"
+            }), 400
+        
+        user.password = User.hash_password(new_password)
+        user.save()
+        
+        return jsonify({
+            "success": True,
+            "message": "Đổi mật khẩu thành công"
+        })
+            
+    except Exception as e:
+        logger.error(f"Lỗi đổi mật khẩu: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+# === ADMIN ENDPOINTS - SỬA LẠI ĐỂ SỬ DỤNG CHUNG TOKEN ===
+
+@auth_routes.route('/admin/stats/overview', methods=['GET'])
+@require_admin
+def get_admin_overview_stats():
+    """API endpoint để lấy thống kê tổng quan cho admin"""
+    try:
+        from models.conversation_model import get_db
+        
+        db = get_db()
+        
+        # Đếm tổng conversations
+        total_conversations = db.conversations.count_documents({})
+        
+        # Conversations trong 24h qua
+        day_ago = datetime.datetime.now() - datetime.timedelta(days=1)
+        recent_conversations = db.conversations.count_documents({
+            "created_at": {"$gte": day_ago}
+        })
+        
+        # Đếm tổng tin nhắn
+        pipeline = [
+            {"$project": {"message_count": {"$size": "$messages"}}},
+            {"$group": {"_id": None, "total_messages": {"$sum": "$message_count"}}}
+        ]
+        message_result = list(db.conversations.aggregate(pipeline))
+        total_messages = message_result[0]["total_messages"] if message_result else 0
+        
+        # Mock users data (có thể thay bằng query thực tế)
+        total_users = db.users.count_documents({}) if hasattr(db, 'users') else 1
+        
+        return jsonify({
+            "success": True,
+            "stats": {
+                "users": {
+                    "total": total_users,
+                    "new_today": 0
+                },
+                "conversations": {
+                    "total": total_conversations,
+                    "recent": recent_conversations
+                },
+                "data": {
+                    "total_chunks": total_messages,
+                    "total_tables": 0,
+                    "total_figures": 0,
+                    "total_items": total_messages,
+                    "embeddings": 0
+                },
+                "admins": {
+                    "total": 1
+                }
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy thống kê admin: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@auth_routes.route('/admin/recent-activities', methods=['GET'])
+@require_admin
+def get_admin_recent_activities():
+    """API endpoint để lấy hoạt động gần đây cho admin"""
+    try:
+        limit = int(request.args.get('limit', 10))
+        
+        from models.conversation_model import get_db
+        db = get_db()
+        
+        # Lấy conversations gần đây
+        recent_conversations = list(db.conversations.find(
+            {},
+            {"title": 1, "created_at": 1, "updated_at": 1}
+        ).sort("updated_at", -1).limit(limit))
+        
+        activities = []
+        for conv in recent_conversations:
+            activities.append({
+                "type": "conversation_created",
+                "title": "Cuộc hội thoại mới",
+                "description": conv.get("title", "Cuộc hội thoại"),
+                "timestamp": conv.get("updated_at", datetime.datetime.now()).isoformat()
+            })
+        
+        return jsonify({
+            "success": True,
+            "activities": activities
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy hoạt động gần đây: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@auth_routes.route('/admin/alerts', methods=['GET'])
+@require_admin
+def get_admin_system_alerts():
+    """API endpoint để lấy cảnh báo hệ thống cho admin"""
+    try:
+        # Mock alerts - có thể thay bằng logic thực tế
+        alerts = [
+            {
+                "type": "info",
+                "title": "Hệ thống hoạt động bình thường",
+                "message": "Tất cả các dịch vụ đang chạy ổn định",
+                "severity": "low"
+            }
+        ]
+        
+        return jsonify({
+            "success": True,
+            "alerts": alerts
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy cảnh báo hệ thống: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@auth_routes.route('/init-admin', methods=['POST'])
+def init_admin():
+    """API endpoint để khởi tạo admin mặc định"""
+    try:
+        success, result = User.create_default_admin()
+        
+        if success:
+            return jsonify({
+                "success": True,
+                "message": "Khởi tạo admin thành công",
+                "data": result
+            })
+        else:
+            return jsonify({
+                "success": False,
+                "error": result
+            }), 400
+            
+    except Exception as e:
+        logger.error(f"Lỗi khởi tạo admin: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500

api/chat.py

@@ -0,0 +1,399 @@
+from flask import Blueprint, request, jsonify
+import logging
+from core.rag_pipeline import RAGPipeline
+from core.embedding_model import get_embedding_model
+from models.conversation_model import Conversation
+from flask_jwt_extended import jwt_required, get_jwt_identity
+import datetime
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+# Tạo blueprint
+chat_routes = Blueprint('chat', __name__)
+
+# Khởi tạo RAG Pipeline một lần duy nhất khi module được load
+rag_pipeline = None
+
+def get_rag_pipeline():
+    """Singleton pattern để tránh khởi tạo lại RAG Pipeline"""
+    global rag_pipeline
+    if rag_pipeline is None:
+        logger.info("Khởi tạo RAG Pipeline lần đầu")
+        rag_pipeline = RAGPipeline()
+    return rag_pipeline
+
+# Hàm tạo tiêu đề từ tin nhắn
+def create_title_from_message(message, max_length=50):
+    """Tạo tiêu đề cuộc trò chuyện từ tin nhắn đầu tiên của người dùng"""
+    message = message.strip().replace('\n', ' ')
+    if len(message) <= max_length:
+        return message
+    return message[:max_length-3] + "..."
+
+@chat_routes.route('/chat', methods=['POST'])
+@jwt_required()
+def chat():
+    """API endpoint để xử lý tin nhắn chat"""
+    try:
+        data = request.json
+        message = data.get('message')
+        age = data.get('age', 1)
+        conversation_id = data.get('conversation_id')
+        
+        user_id = get_jwt_identity()
+        
+        if not message:
+            return jsonify({
+                "success": False,
+                "error": "Vui lòng nhập tin nhắn"
+            }), 400
+        
+        logger.info(f"Nhận tin nhắn từ user {user_id}: {message[:50]}...")
+        
+        # Xử lý conversation
+        if conversation_id:
+            conversation = Conversation.find_by_id(conversation_id)
+            if not conversation or str(conversation.user_id) != user_id:
+                return jsonify({
+                    "success": False,
+                    "error": "Không tìm thấy cuộc trò chuyện"
+                }), 404
+            
+            if len(conversation.messages) == 0:
+                final_title = create_title_from_message(message, 50)
+                conversation.title = final_title
+                logger.info(f"Cập nhật title cho conversation {conversation_id}: '{final_title}'")
+        else:
+            final_title = create_title_from_message(message, 50)
+            conversation = Conversation.create(
+                user_id=user_id,
+                title=final_title,
+                age_context=age
+            )
+            logger.info(f"Tạo conversation mới với title: '{final_title}'")
+        
+        # Thêm tin nhắn của user
+        conversation.add_message("user", message)
+        
+        # Sử dụng RAG Pipeline để generate response
+        pipeline = get_rag_pipeline()
+        
+        # Generate response sử dụng RAG
+        logger.info("Bắt đầu generate response với RAG Pipeline")
+        response_data = pipeline.generate_response(message, age)
+        
+        if response_data.get("success"):
+            bot_response = response_data.get("response", "Xin lỗi, tôi không thể trả lời câu hỏi này.")
+            sources = response_data.get("sources", [])
+            
+            # Thêm tin nhắn bot vào conversation
+            conversation.add_message("bot", bot_response, sources=sources)
+            
+            logger.info(f"Đã generate response thành công cho conversation {conversation.conversation_id}")
+            
+            return jsonify({
+                "success": True,
+                "response": bot_response,
+                "sources": sources,
+                "conversation_id": str(conversation.conversation_id)
+            })
+        else:
+            error_msg = response_data.get("error", "Không thể tạo phản hồi")
+            logger.error(f"Lỗi generate response: {error_msg}")
+            
+            return jsonify({
+                "success": False,
+                "error": error_msg
+            }), 500
+            
+    except Exception as e:
+        logger.error(f"Lỗi xử lý chat: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Lỗi máy chủ: {str(e)}"
+        }), 500
+
+@chat_routes.route('/messages/<message_id>/edit', methods=['PUT'])
+@jwt_required()
+def edit_message(message_id):
+    """API endpoint để chỉnh sửa tin nhắn"""
+    try:
+        data = request.json
+        new_content = data.get('content')
+        conversation_id = data.get('conversation_id')
+        age = data.get('age', 1)
+        
+        user_id = get_jwt_identity()
+        
+        if not new_content or not conversation_id:
+            return jsonify({
+                "success": False,
+                "error": "Thiếu thông tin cần thiết"
+            }), 400
+        
+        logger.info(f"Edit message {message_id} in conversation {conversation_id}: {new_content[:50]}...")
+        
+        # Tìm conversation
+        conversation = Conversation.find_by_id(conversation_id)
+        if not conversation or str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc trò chuyện"
+            }), 404
+        
+        # Tìm message và kiểm tra quyền
+        message_found = False
+        for msg in conversation.messages:
+            if str(msg.get('_id', msg.get('id'))) == message_id:
+                if msg['role'] != 'user':
+                    return jsonify({
+                        "success": False,
+                        "error": "Chỉ có thể chỉnh sửa tin nhắn của người dùng"
+                    }), 400
+                message_found = True
+                break
+        
+        if not message_found:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy tin nhắn"
+            }), 404
+        
+        # Cập nhật tin nhắn và xóa tất cả tin nhắn sau nó
+        success, result_message = conversation.edit_message(message_id, new_content)
+        
+        if not success:
+            return jsonify({
+                "success": False,
+                "error": result_message
+            }), 400
+        
+        # Tạo phản hồi mới với RAG Pipeline
+        pipeline = get_rag_pipeline()
+        response_data = pipeline.generate_response(new_content, age)
+        
+        if response_data.get("success"):
+            bot_response = response_data.get("response", "Xin lỗi, tôi không thể trả lời câu hỏi này.")
+            sources = response_data.get("sources", [])
+            
+            # Thêm phản hồi bot mới
+            success, bot_message = conversation.regenerate_bot_response_after_edit(message_id, bot_response, sources)
+            
+            if success:
+                # Trả về conversation đã cập nhật
+                updated_conversation = Conversation.find_by_id(conversation_id)
+                logger.info(f"Successfully edited message and generated new response")
+                return jsonify({
+                    "success": True,
+                    "message": "Đã chỉnh sửa tin nhắn và tạo phản hồi mới",
+                    "conversation": updated_conversation.to_dict()
+                })
+            else:
+                return jsonify({
+                    "success": False,
+                    "error": bot_message
+                }), 500
+        else:
+            return jsonify({
+                "success": False,
+                "error": response_data.get("error", "Không thể tạo phản hồi mới")
+            }), 500
+            
+    except Exception as e:
+        logger.error(f"Lỗi chỉnh sửa tin nhắn: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Lỗi máy chủ: {str(e)}"
+        }), 500
+
+@chat_routes.route('/messages/<message_id>/regenerate', methods=['POST'])
+@jwt_required()
+def regenerate_response(message_id):
+    """API endpoint để tạo lại phản hồi"""
+    try:
+        data = request.json
+        conversation_id = data.get('conversation_id')
+        age = data.get('age', 1)
+        
+        user_id = get_jwt_identity()
+        
+        if not conversation_id:
+            return jsonify({
+                "success": False,
+                "error": "Thiếu conversation_id"
+            }), 400
+        
+        logger.info(f"Regenerate response for message {message_id} in conversation {conversation_id}")
+        
+        # Tìm conversation
+        conversation = Conversation.find_by_id(conversation_id)
+        if not conversation or str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc trò chuyện"
+            }), 404
+        
+        # Tìm tin nhắn và tin nhắn user trước đó
+        user_message = None
+        for i, msg in enumerate(conversation.messages):
+            if str(msg.get('_id', msg.get('id'))) == message_id:
+                if msg['role'] != 'bot':
+                    return jsonify({
+                        "success": False,
+                        "error": "Chỉ có thể regenerate phản hồi của bot"
+                    }), 400
+                # Tìm tin nhắn user trước đó
+                if i > 0 and conversation.messages[i-1]['role'] == 'user':
+                    user_message = conversation.messages[i-1]['content']
+                break
+        
+        if not user_message:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy tin nhắn người dùng tương ứng"
+            }), 404
+        
+        # Sử dụng RAG Pipeline để generate response mới
+        pipeline = get_rag_pipeline()
+        response_data = pipeline.generate_response(user_message, age)
+        
+        if response_data.get("success"):
+            bot_response = response_data.get("response", "Xin lỗi, tôi không thể trả lời câu hỏi này.")
+            sources = response_data.get("sources", [])
+            
+            success, result_message = conversation.regenerate_response(message_id, bot_response, sources)
+            
+            if success:
+                # Trả về conversation đã cập nhật
+                updated_conversation = Conversation.find_by_id(conversation_id)
+                logger.info(f"Successfully regenerated response")
+                return jsonify({
+                    "success": True,
+                    "conversation": updated_conversation.to_dict()
+                })
+            else:
+                return jsonify({
+                    "success": False,
+                    "error": result_message
+                }), 400
+        else:
+            return jsonify({
+                "success": False,
+                "error": response_data.get("error", "Không thể tạo phản hồi mới")
+            }), 500
+            
+    except Exception as e:
+        logger.error(f"Lỗi regenerate response: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Lỗi máy chủ: {str(e)}"
+        }), 500
+
+@chat_routes.route('/messages/<message_id>/versions/<int:version>', methods=['PUT'])
+@jwt_required()
+def switch_message_version(message_id, version):
+    """API endpoint để chuyển đổi version của tin nhắn"""
+    try:
+        data = request.json
+        conversation_id = data.get('conversation_id')
+        
+        user_id = get_jwt_identity()
+        
+        if not conversation_id:
+            return jsonify({
+                "success": False,
+                "error": "Thiếu conversation_id"
+            }), 400
+        
+        logger.info(f"Switching message {message_id} to version {version} in conversation {conversation_id}")
+        
+        # Tìm conversation
+        conversation = Conversation.find_by_id(conversation_id)
+        if not conversation or str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc trò chuyện"
+            }), 404
+        
+        # Debug: Log current conversation state before switch
+        logger.info(f"Before switch - Conversation has {len(conversation.messages)} messages")
+        for i, msg in enumerate(conversation.messages):
+            logger.info(f"  Message {i}: {msg['role']} - {msg['content'][:30]}... (current_version: {msg.get('current_version', 1)})")
+        
+        # Chuyển đổi version
+        success = conversation.switch_message_version(message_id, version)
+        
+        if success:
+            # Reload conversation để đảm bảo có dữ liệu mới nhất
+            updated_conversation = Conversation.find_by_id(conversation_id)
+            
+            # Debug: Log conversation state after switch
+            logger.info(f"After switch - Conversation has {len(updated_conversation.messages)} messages")
+            for i, msg in enumerate(updated_conversation.messages):
+                logger.info(f"  Message {i}: {msg['role']} - {msg['content'][:30]}... (current_version: {msg.get('current_version', 1)})")
+            
+            logger.info(f"Successfully switched message {message_id} to version {version}")
+            return jsonify({
+                "success": True,
+                "conversation": updated_conversation.to_dict()
+            })
+        else:
+            logger.error(f"Failed to switch message {message_id} to version {version}")
+            return jsonify({
+                "success": False,
+                "error": "Không thể chuyển đổi version"
+            }), 400
+            
+    except Exception as e:
+        logger.error(f"Lỗi chuyển đổi version: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Lỗi máy chủ: {str(e)}"
+        }), 500
+
+@chat_routes.route('/messages/<message_id>', methods=['DELETE'])
+@jwt_required()
+def delete_message_and_following(message_id):
+    """API endpoint để xóa tin nhắn và tất cả tin nhắn sau nó"""
+    try:
+        data = request.json
+        conversation_id = data.get('conversation_id')
+        
+        user_id = get_jwt_identity()
+        
+        if not conversation_id:
+            return jsonify({
+                "success": False,
+                "error": "Thiếu conversation_id"
+            }), 400
+        
+        # Tìm conversation
+        conversation = Conversation.find_by_id(conversation_id)
+        if not conversation or str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc trò chuyện"
+            }), 404
+        
+        # Xóa tin nhắn và các tin nhắn theo sau
+        success = conversation.delete_message_and_following(message_id)
+        
+        if success:
+            updated_conversation = Conversation.find_by_id(conversation_id)
+            return jsonify({
+                "success": True,
+                "conversation": updated_conversation.to_dict()
+            })
+        else:
+            return jsonify({
+                "success": False,
+                "error": "Không thể xóa tin nhắn"
+            }), 400
+            
+    except Exception as e:
+        logger.error(f"Lỗi xóa tin nhắn: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": f"Lỗi máy chủ: {str(e)}"
+        }), 500

api/data.py

@@ -0,0 +1,58 @@
+from flask import Blueprint, request, jsonify, send_from_directory
+import os
+import logging
+from core.data_processor import DataProcessor
+from flask_jwt_extended import jwt_required, get_jwt_identity
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+# Tạo blueprint
+data_routes = Blueprint('data', __name__)
+
+# Đường dẫn đến thư mục dữ liệu
+current_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+data_dir = os.path.join(current_dir, "..", "data")
+data_dir = os.path.abspath(data_dir)
+
+@data_routes.route('/figures/<path:bai_id>/<path:filename>', methods=['GET'])
+def serve_figure(bai_id, filename):
+    """API endpoint để phục vụ hình ảnh theo bài"""
+    try:
+        # Đường dẫn chính xác đến thư mục figures
+        figure_dir = os.path.join(data_dir, bai_id, 'figures')
+        figure_dir = os.path.abspath(figure_dir)
+        
+        # Kiểm tra xem thư mục có tồn tại không
+        if os.path.exists(figure_dir) and os.path.isdir(figure_dir):
+            for ext in ['', '.png', '.jpg', '.jpeg', '.gif', '.svg']:
+                # Kiểm tra với nhiều phần mở rộng khác nhau
+                file_to_check = os.path.join(figure_dir, filename + ext)
+                if os.path.exists(file_to_check):
+                    return send_from_directory(figure_dir, filename + ext)
+        
+        logger.error(f"Không tìm thấy hình ảnh: {os.path.join(figure_dir, filename)}")
+        return jsonify({"error": "Không tìm thấy hình ảnh"}), 404
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi tải hình ảnh: {str(e)}")
+        return jsonify({"error": f"Lỗi máy chủ: {str(e)}"}), 500
+
+@data_routes.route('/metadata', methods=['GET'])
+@jwt_required(optional=True)
+def get_metadata():
+    """API endpoint để lấy thông tin metadata của tài liệu"""
+    try:
+        # Tạo data_processor mới để lấy metadata
+        data_processor = DataProcessor(data_dir=data_dir)
+        metadata = data_processor.get_all_metadata()
+        return jsonify({
+            "success": True,
+            "metadata": metadata
+        })
+    except Exception as e:
+        logger.error(f"Lỗi khi lấy metadata: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500

api/feedback.py

@@ -0,0 +1,117 @@
+from flask import Blueprint, request, jsonify
+import logging
+from models.feedback_model import Feedback
+from models.user_model import User
+from flask_jwt_extended import jwt_required, get_jwt_identity
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+# Tạo blueprint
+feedback_routes = Blueprint('feedback', __name__)
+
+@feedback_routes.route('/feedback/categories', methods=['GET'])
+def get_feedback_categories():
+    """API endpoint để lấy danh sách categories"""
+    categories = [
+        {"value": "bug_report", "label": "Báo lỗi"},
+        {"value": "feature_request", "label": "Đề xuất tính năng"},
+        {"value": "content_feedback", "label": "Phản hồi nội dung"},
+        {"value": "user_experience", "label": "Trải nghiệm người dùng"},
+        {"value": "other", "label": "Khác"}
+    ]
+    
+    return jsonify({
+        "success": True,
+        "categories": categories
+    })
+
+@feedback_routes.route('/feedback', methods=['POST'])
+@jwt_required()
+def create_feedback():
+    """API endpoint để tạo feedback mới"""
+    try:
+        data = request.json
+        user_id = get_jwt_identity()
+        
+        rating = data.get('rating', 5)
+        category = data.get('category', '')
+        title = data.get('title', '')
+        content = data.get('content', '')
+        
+        if not category or not content.strip():
+            return jsonify({
+                "success": False,
+                "error": "Vui lòng điền đầy đủ thông tin"
+            }), 400
+        
+        if len(content.strip()) < 10:
+            return jsonify({
+                "success": False,
+                "error": "Nội dung phải có ít nhất 10 ký tự"
+            }), 400
+        
+        success, result = Feedback.create_feedback(
+            user_id=user_id,
+            rating=rating,
+            category=category,
+            title=title,
+            content=content
+        )
+        
+        if success:
+            return jsonify({
+                "success": True,
+                "message": "Đã gửi feedback thành công",
+                "feedback_id": result["feedback_id"]
+            })
+        else:
+            return jsonify({
+                "success": False,
+                "error": result
+            }), 500
+            
+    except Exception as e:
+        logger.error(f"Lỗi tạo feedback: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@feedback_routes.route('/feedback', methods=['GET'])
+@jwt_required()
+def get_user_feedback():
+    """API endpoint để lấy feedback của user hiện tại"""
+    try:
+        user_id = get_jwt_identity()
+        page = int(request.args.get('page', 1))
+        per_page = int(request.args.get('per_page', 10))
+        
+        skip = (page - 1) * per_page
+        feedbacks = Feedback.find_by_user(user_id, limit=per_page, skip=skip)
+        
+        result = []
+        for feedback in feedbacks:
+            result.append({
+                "id": str(feedback.feedback_id),
+                "rating": feedback.rating,
+                "category": feedback.category,
+                "title": feedback.title,
+                "content": feedback.content,
+                "status": feedback.status,
+                "admin_response": feedback.admin_response,
+                "created_at": feedback.created_at.isoformat(),
+                "updated_at": feedback.updated_at.isoformat()
+            })
+        
+        return jsonify({
+            "success": True,
+            "feedbacks": result
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi lấy feedback: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500

api/history.py

@@ -0,0 +1,777 @@
+from flask import Blueprint, request, jsonify
+import logging
+from bson.objectid import ObjectId
+from models.conversation_model import Conversation
+from models.user_model import User
+from flask_jwt_extended import jwt_required, get_jwt_identity
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+# Tạo blueprint
+history_routes = Blueprint('history', __name__)
+
+# Hàm đơn giản để tạo tiêu đề từ tin nhắn
+def create_title_from_message(message, max_length=50):
+    """Tạo tiêu đề cuộc trò chuyện từ tin nhắn đầu tiên của người dùng"""
+    # Loại bỏ ký tự xuống dòng và khoảng trắng thừa
+    message = message.strip().replace('\n', ' ')
+    
+    # Nếu tin nhắn đủ ngắn, sử dụng làm tiêu đề luôn
+    if len(message) <= max_length:
+        return message
+    
+    # Nếu tin nhắn quá dài, cắt ngắn và thêm dấu "..."
+    return message[:max_length-3] + "..."
+
+@history_routes.route('/conversations', methods=['GET'])
+@jwt_required()
+def get_conversations():
+    """API endpoint để lấy danh sách cuộc hội thoại của người dùng"""
+    try:
+        user_id = get_jwt_identity()
+        
+        # Lấy tham số phân trang từ query string
+        page = int(request.args.get('page', 1))
+        per_page = int(request.args.get('per_page', 50))  # ✅ TĂNG default per_page
+        include_archived = request.args.get('include_archived', 'false').lower() == 'true'
+        
+        # Tính toán offset
+        skip = (page - 1) * per_page
+        
+        logger.info(f"🔍 Getting conversations for user {user_id}, page {page}, per_page {per_page}, include_archived {include_archived}")
+        
+        # Lấy danh sách cuộc hội thoại
+        conversations = Conversation.find_by_user(
+            user_id=user_id,
+            limit=per_page,
+            skip=skip,
+            include_archived=include_archived
+        )
+        
+        # Đếm tổng số cuộc hội thoại
+        total_count = Conversation.count_by_user(
+            user_id=user_id,
+            include_archived=include_archived
+        )
+        
+        logger.info(f"📊 Found {len(conversations)} conversations, total: {total_count}")
+        
+        # Chuẩn bị dữ liệu phản hồi
+        result = []
+        for conversation in conversations:
+            # Chỉ lấy tin nhắn mới nhất để hiển thị xem trước
+            last_message = conversation.messages[-1]["content"] if conversation.messages else ""
+            message_count = len(conversation.messages)
+            
+            result.append({
+                "id": str(conversation.conversation_id),
+                "title": conversation.title,
+                "created_at": conversation.created_at.isoformat(),
+                "updated_at": conversation.updated_at.isoformat(),
+                "age_context": conversation.age_context,
+                "is_archived": conversation.is_archived,
+                "last_message": last_message[:100] + "..." if len(last_message) > 100 else last_message,
+                "message_count": message_count
+            })
+        
+        logger.info(f"✅ Returning {len(result)} conversations")
+        
+        # Tạo phản hồi với thông tin phân trang
+        return jsonify({
+            "success": True,
+            "conversations": result,
+            "pagination": {
+                "page": page,
+                "per_page": per_page,
+                "total": total_count,
+                "pages": (total_count + per_page - 1) // per_page  # Ceiling division
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"❌ Lỗi khi lấy danh sách cuộc hội thoại: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations/<conversation_id>', methods=['GET'])
+@jwt_required()
+def get_conversation_detail(conversation_id):
+    """API endpoint để lấy chi tiết một cuộc hội thoại"""
+    try:
+        user_id = get_jwt_identity()
+        
+        def safe_datetime_to_string(dt_obj):
+            """Safely convert datetime object to ISO string"""
+            if dt_obj is None:
+                return None
+            # Nếu đã là string, return nguyên
+            if isinstance(dt_obj, str):
+                return dt_obj
+            # Nếu là datetime object, convert sang string
+            if hasattr(dt_obj, 'isoformat'):
+                return dt_obj.isoformat()
+            # Fallback: convert to string
+            return str(dt_obj)
+        
+        # Lấy thông tin cuộc hội thoại
+        conversation = Conversation.find_by_id(conversation_id)
+        
+        if not conversation:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc hội thoại"
+            }), 404
+        
+        # Kiểm tra quy���n truy cập
+        if str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Bạn không có quyền truy cập cuộc hội thoại này"
+            }), 403
+        
+        conversation_data = {
+            "id": str(conversation.conversation_id),
+            "title": conversation.title,
+            "created_at": safe_datetime_to_string(conversation.created_at),
+            "updated_at": safe_datetime_to_string(conversation.updated_at), 
+            "age_context": conversation.age_context,
+            "is_archived": conversation.is_archived,
+            "messages": []
+        }
+        
+        for message in conversation.messages:
+            message_data = {
+                "id": str(message["_id"]),
+                "_id": str(message["_id"]),
+                "role": message["role"],
+                "content": message["content"],
+                "timestamp": safe_datetime_to_string(message.get("timestamp")),
+                "current_version": message.get("current_version", 1),
+                "is_edited": message.get("is_edited", False) 
+            }
+            
+            if "versions" in message and message["versions"]:
+                message_data["versions"] = []
+                for version in message["versions"]:
+                    version_data = {
+                        "content": version["content"],
+                        "timestamp": safe_datetime_to_string(version.get("timestamp")),
+                        "version": version["version"]
+                    }
+                    
+                    # Thêm sources cho version nếu có
+                    if "sources" in version:
+                        version_data["sources"] = version["sources"]
+                    
+                    # Thêm metadata cho version nếu có  
+                    if "metadata" in version:
+                        version_data["metadata"] = version["metadata"]
+                    
+                    # conversation_snapshot chỉ dùng để restore, không cần trả về frontend
+                    message_data["versions"].append(version_data)
+            else:
+                # Nếu không có versions, tạo default version
+                message_data["versions"] = [{
+                    "content": message["content"],
+                    "timestamp": safe_datetime_to_string(message.get("timestamp")),
+                    "version": 1
+                }]
+            
+            # Thêm sources nếu có
+            if "sources" in message:
+                message_data["sources"] = message["sources"]
+                
+            # Thêm metadata nếu có
+            if "metadata" in message:
+                message_data["metadata"] = message["metadata"]
+                
+            conversation_data["messages"].append(message_data)
+        
+        return jsonify({
+            "success": True,
+            "conversation": conversation_data
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi lấy chi tiết cuộc hội thoại: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations', methods=['POST'])
+@jwt_required()
+def create_conversation():
+    """API endpoint để tạo cuộc hội thoại mới"""
+    try:
+        data = request.json
+        user_id = get_jwt_identity()
+            
+        # Lấy thông tin user
+        user = User.find_by_id(user_id)
+        if not user:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy thông tin người dùng"
+            }), 404
+            
+        # Tạo cuộc hội thoại mới
+        title = data.get('title', 'Cuộc trò chuyện mới')
+        age_context = data.get('age_context')
+        
+        # ✅ SỬA: Sử dụng Conversation.create thay vì khởi tạo trực tiếp
+        conversation_id = Conversation.create(
+            user_id=user_id,
+            title=title,
+            age_context=age_context
+        )
+        
+        logger.info(f"✅ Created new conversation {conversation_id} for user {user_id}")
+        
+        return jsonify({
+            "success": True,
+            "message": "Đã tạo cuộc hội thoại mới",
+            "conversation_id": str(conversation_id)
+        })
+        
+    except Exception as e:
+        logger.error(f"❌ Lỗi khi tạo cuộc hội thoại mới: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations/<conversation_id>', methods=['PUT'])
+@jwt_required()
+def update_conversation(conversation_id):
+    """API endpoint để cập nhật thông tin cuộc hội thoại"""
+    try:
+        data = request.json
+        user_id = get_jwt_identity()
+        
+        # Lấy thông tin cuộc hội thoại
+        conversation = Conversation.find_by_id(conversation_id)
+        
+        if not conversation:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc hội thoại"
+            }), 404
+        
+        # Kiểm tra quyền truy cập
+        if str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Bạn không có quyền cập nhật cuộc hội thoại này"
+            }), 403
+        
+        # Cập nhật thông tin
+        if 'title' in data:
+            conversation.title = data['title']
+            
+        if 'age_context' in data:
+            conversation.age_context = data['age_context']
+            
+        if 'is_archived' in data:
+            conversation.is_archived = data['is_archived']
+        
+        # Lưu thay đổi
+        conversation.save()
+        
+        logger.info(f"✅ Updated conversation {conversation_id}")
+        
+        return jsonify({
+            "success": True,
+            "message": "Đã cập nhật thông tin cuộc hội thoại"
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi cập nhật thông tin cuộc hội thoại: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations/<conversation_id>', methods=['DELETE'])
+@jwt_required()
+def delete_conversation(conversation_id):
+    """API endpoint để xóa cuộc hội thoại"""
+    try:
+        user_id = get_jwt_identity()
+        
+        # Lấy thông tin cuộc hội thoại
+        conversation = Conversation.find_by_id(conversation_id)
+        
+        if not conversation:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc hội thoại"
+            }), 404
+        
+        # Kiểm tra quyền truy cập
+        if str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Bạn không có quyền xóa cuộc hội thoại này"
+            }), 403
+        
+        # Xóa cuộc hội thoại
+        conversation.delete()
+        
+        logger.info(f"✅ Deleted conversation {conversation_id}")
+        
+        return jsonify({
+            "success": True,
+            "message": "Đã xóa cuộc hội thoại"
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi xóa cuộc hội thoại: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations/<conversation_id>/archive', methods=['POST'])
+@jwt_required()
+def archive_conversation(conversation_id):
+    """API endpoint để lưu trữ cuộc hội thoại"""
+    try:
+        user_id = get_jwt_identity()
+        
+        # Lấy thông tin cuộc hội thoại
+        conversation = Conversation.find_by_id(conversation_id)
+        
+        if not conversation:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc hội thoại"
+            }), 404
+        
+        # Kiểm tra quyền truy cập
+        if str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Bạn không có quyền lưu trữ cuộc hội thoại này"
+            }), 403
+        
+        # Lưu trữ cuộc hội thoại
+        conversation.is_archived = True
+        conversation.save()
+        
+        return jsonify({
+            "success": True,
+            "message": "Đã lưu trữ cuộc hội thoại"
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi lưu trữ cuộc hội thoại: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations/<conversation_id>/unarchive', methods=['POST'])
+@jwt_required()
+def unarchive_conversation(conversation_id):
+    """API endpoint để hủy lưu trữ cuộc hội thoại"""
+    try:
+        user_id = get_jwt_identity()
+        
+        # Lấy thông tin cuộc hội thoại
+        conversation = Conversation.find_by_id(conversation_id)
+        
+        if not conversation:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc hội thoại"
+            }), 404
+        
+        # Kiểm tra quyền truy cập
+        if str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Bạn không có quyền hủy lưu trữ cuộc hội thoại này"
+            }), 403
+        
+        # Hủy lưu trữ cuộc hội thoại
+        conversation.is_archived = False
+        conversation.save()
+        
+        return jsonify({
+            "success": True,
+            "message": "Đã hủy lưu trữ cuộc hội thoại"
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi hủy lưu trữ cuộc hội thoại: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations/search', methods=['GET'])
+@jwt_required()
+def search_conversations():
+    """API endpoint để tìm kiếm cuộc hội thoại theo nội dung"""
+    try:
+        user_id = get_jwt_identity()
+        
+        # Lấy tham số từ query string
+        query = request.args.get('q', '')
+        page = int(request.args.get('page', 1))
+        per_page = int(request.args.get('per_page', 10))
+        
+        # Tính toán offset
+        skip = (page - 1) * per_page
+        
+        # Kiểm tra từ khóa tìm kiếm
+        if not query:
+            return jsonify({
+                "success": False,
+                "error": "Vui lòng nhập từ khóa tìm kiếm"
+            }), 400
+            
+        # Tìm kiếm cuộc hội thoại
+        conversations = Conversation.search_by_content(
+            user_id=user_id,
+            query=query,
+            limit=per_page,
+            skip=skip
+        )
+        
+        # Chuẩn bị dữ liệu phản hồi
+        result = []
+        for conversation in conversations:
+            # Tìm tin nhắn chứa từ khóa tìm kiếm
+            matching_messages = [m for m in conversation.messages if query.lower() in m["content"].lower()]
+            
+            result.append({
+                "id": str(conversation.conversation_id),
+                "title": conversation.title,
+                "created_at": conversation.created_at.isoformat(),
+                "updated_at": conversation.updated_at.isoformat(),
+                "age_context": conversation.age_context,
+                "is_archived": conversation.is_archived,
+                "message_count": len(conversation.messages),
+                "matching_messages": len(matching_messages),
+                "preview": matching_messages[0]["content"][:100] + "..." if matching_messages else ""
+            })
+        
+        return jsonify({
+            "success": True,
+            "conversations": result,
+            "query": query
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi tìm kiếm cuộc hội thoại: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations/<conversation_id>/messages', methods=['POST'])
+@jwt_required()
+def add_message(conversation_id):
+    """API endpoint để thêm tin nhắn mới vào cuộc hội thoại"""
+    try:
+        data = request.json
+        user_id = get_jwt_identity()
+        
+        # Lấy thông tin cuộc hội thoại
+        conversation = Conversation.find_by_id(conversation_id)
+        
+        if not conversation:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc hội thoại"
+            }), 404
+        
+        # Kiểm tra quyền truy cập
+        if str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Bạn không có quyền thêm tin nhắn vào cuộc hội thoại này"
+            }), 403
+        
+        # Lấy thông tin tin nhắn
+        role = data.get('role')
+        content = data.get('content')
+        sources = data.get('sources')
+        metadata = data.get('metadata')
+        
+        # Kiểm tra dữ liệu
+        if not role or not content:
+            return jsonify({
+                "success": False,
+                "error": "Vui lòng cung cấp role và content cho tin nhắn"
+            }), 400
+            
+        # Kiểm tra role hợp lệ
+        if role not in ["user", "bot"]:
+            return jsonify({
+                "success": False,
+                "error": "Role không hợp lệ, chỉ chấp nhận 'user' hoặc 'bot'"
+            }), 400
+        
+        # Thêm tin nhắn mới
+        message_id = conversation.add_message(
+            role=role,
+            content=content,
+            sources=sources,
+            metadata=metadata
+        )
+        
+        return jsonify({
+            "success": True,
+            "message": "Đã thêm tin nhắn mới",
+            "message_id": str(message_id)
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi thêm tin nhắn mới: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations/stats', methods=['GET'])
+@jwt_required()
+def get_user_conversation_stats():
+    """API endpoint để lấy thống kê cuộc hội thoại của người dùng"""
+    try:
+        user_id = get_jwt_identity()
+            
+        # Lấy tổng số cuộc hội thoại
+        total_conversations = Conversation.count_by_user(
+            user_id=user_id,
+            include_archived=True
+        )
+        
+        # Lấy số cuộc hội thoại đã lưu trữ
+        archived_conversations = Conversation.count_by_user(
+            user_id=user_id,
+            include_archived=True
+        ) - Conversation.count_by_user(
+            user_id=user_id,
+            include_archived=False
+        )
+        
+        # Lấy danh sách cuộc hội thoại để tính số tin nhắn
+        all_conversations = Conversation.find_by_user(
+            user_id=user_id,
+            limit=100,  # Giới hạn 100 cuộc hội thoại gần nhất để tính thống kê
+            skip=0,
+            include_archived=True
+        )
+        
+        # Tính số tin nhắn và số ngày
+        total_messages = 0
+        messages_by_date = {}
+        
+        for conversation in all_conversations:
+            total_messages += len(conversation.messages)
+            
+            # Đếm số tin nhắn theo ngày
+            for message in conversation.messages:
+                date_str = message["timestamp"].strftime("%Y-%m-%d")
+                if date_str not in messages_by_date:
+                    messages_by_date[date_str] = 0
+                messages_by_date[date_str] += 1
+        
+        # Sắp xếp ngày và lấy 7 ngày gần nhất
+        sorted_dates = sorted(messages_by_date.keys(), reverse=True)[:7]
+        recent_activity = {date: messages_by_date[date] for date in sorted_dates}
+        
+        # Tính trung bình số tin nhắn mỗi cuộc hội thoại
+        avg_messages = total_messages / total_conversations if total_conversations > 0 else 0
+        
+        return jsonify({
+            "success": True,
+            "stats": {
+                "total_conversations": total_conversations,
+                "archived_conversations": archived_conversations,
+                "total_messages": total_messages,
+                "avg_messages_per_conversation": round(avg_messages, 1),
+                "recent_activity": recent_activity
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi lấy thống kê cuộc hội thoại: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations/<conversation_id>/export', methods=['GET'])
+@jwt_required()
+def export_conversation(conversation_id):
+    """API endpoint để xuất cuộc hội thoại dưới dạng JSON"""
+    try:
+        user_id = get_jwt_identity()
+        
+        # Lấy thông tin cuộc hội thoại
+        conversation = Conversation.find_by_id(conversation_id)
+        
+        if not conversation:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc hội thoại"
+            }), 404
+        
+        # Kiểm tra quyền truy cập
+        if str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Bạn không có quyền xuất cuộc hội thoại này"
+            }), 403
+        
+        # Chuẩn bị dữ liệu xuất
+        export_data = {
+            "id": str(conversation.conversation_id),
+            "title": conversation.title,
+            "created_at": conversation.created_at.isoformat(),
+            "updated_at": conversation.updated_at.isoformat(),
+            "age_context": conversation.age_context,
+            "messages": []
+        }
+        
+        # Chuẩn bị danh sách tin nhắn
+        for message in conversation.messages:
+            message_data = {
+                "role": message["role"],
+                "content": message["content"],
+                "timestamp": message["timestamp"].isoformat()
+            }
+            
+            # Thêm sources nếu có
+            if "sources" in message:
+                message_data["sources"] = message["sources"]
+                
+            export_data["messages"].append(message_data)
+        
+        return jsonify(export_data)
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi xuất cuộc hội thoại: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations/bulk-delete', methods=['POST'])
+@jwt_required()
+def bulk_delete_conversations():
+    """API endpoint để xóa nhiều cuộc hội thoại cùng lúc"""
+    try:
+        data = request.json
+        user_id = get_jwt_identity()
+        
+        conversation_ids = data.get('conversation_ids', [])
+        
+        if not conversation_ids:
+            return jsonify({
+                "success": False,
+                "error": "Vui lòng cung cấp danh sách IDs cuộc hội thoại"
+            }), 400
+        
+        # Duyệt qua từng ID và xóa
+        deleted_count = 0
+        failed_ids = []
+        
+        for conv_id in conversation_ids:
+            try:
+                # Lấy thông tin cuộc hội thoại
+                conversation = Conversation.find_by_id(conv_id)
+                
+                # Kiểm tra quyền truy cập và xóa nếu hợp lệ
+                if conversation and str(conversation.user_id) == user_id:
+                    conversation.delete()
+                    deleted_count += 1
+                else:
+                    failed_ids.append(conv_id)
+            except Exception:
+                failed_ids.append(conv_id)
+                continue
+        
+        return jsonify({
+            "success": True,
+            "message": f"Đã xóa {deleted_count}/{len(conversation_ids)} cuộc hội thoại",
+            "deleted_count": deleted_count,
+            "failed_ids": failed_ids
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi xóa nhiều cuộc hội thoại: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+@history_routes.route('/conversations/<conversation_id>/generate-title', methods=['POST'])
+@jwt_required()
+def generate_title_for_conversation(conversation_id):
+    """API endpoint để tạo tự động tiêu đề cho cuộc hội thoại dựa trên nội dung"""
+    try:
+        user_id = get_jwt_identity()
+        
+        # Lấy thông tin cuộc hội thoại
+        conversation = Conversation.find_by_id(conversation_id)
+        
+        if not conversation:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy cuộc hội thoại"
+            }), 404
+        
+        # Kiểm tra quyền truy cập
+        if str(conversation.user_id) != user_id:
+            return jsonify({
+                "success": False,
+                "error": "Bạn không có quyền cập nhật cuộc hội thoại này"
+            }), 403
+            
+        # Kiểm tra số lượng tin nhắn
+        if len(conversation.messages) < 2:
+            return jsonify({
+                "success": False,
+                "error": "Cuộc hội thoại cần ít nhất 2 tin nhắn để tạo tiêu đề"
+            }), 400
+        
+        # Lấy nội dung tin nhắn đầu tiên của người dùng
+        first_user_message = None
+        for message in conversation.messages:
+            if message["role"] == "user":
+                first_user_message = message["content"]
+                break
+                
+        if not first_user_message:
+            return jsonify({
+                "success": False,
+                "error": "Không tìm thấy tin nhắn của người dùng"
+            }), 400
+            
+        # Tạo tiêu đề từ nội dung
+        title = create_title_from_message(first_user_message)
+            
+        # Cập nhật tiêu đề
+        conversation.title = title
+        conversation.save()
+        
+        return jsonify({
+            "success": True,
+            "message": "Đã tạo tiêu đề mới",
+            "title": title
+        })
+        
+    except Exception as e:
+        logger.error(f"Lỗi khi tạo tiêu đề: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500

app.py

@@ -0,0 +1,144 @@
+from flask import Flask, jsonify
+from flask_cors import CORS
+import logging
+import os
+from dotenv import load_dotenv
+from flask_jwt_extended import JWTManager
+import datetime
+from api.admin import admin_routes
+
+# Cấu hình logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Tải biến môi trường
+load_dotenv()
+
+# Khởi tạo Flask app
+app = Flask(__name__)
+
+# Cấu hình JWT - sử dụng environment variables
+app.config['JWT_SECRET_KEY'] = os.getenv("JWT_SECRET_KEY", "default-secret-key-change-in-production")
+app.config['JWT_ACCESS_TOKEN_EXPIRES'] = datetime.timedelta(hours=24)
+app.config['JWT_TOKEN_LOCATION'] = ['headers', 'cookies']
+app.config['JWT_COOKIE_SECURE'] = os.getenv("ENVIRONMENT") == "production"
+app.config['JWT_COOKIE_CSRF_PROTECT'] = False
+
+# Cấu hình upload files
+app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024  # 50MB
+
+jwt = JWTManager(app)
+
+# Cấu hình CORS cho production
+allowed_origins = os.getenv("ALLOWED_ORIGINS", "http://localhost:5173,http://localhost:3000").split(",")
+CORS(app, resources={
+    r"/api/*": {
+        "origins": allowed_origins + ["*"],  # Cho phép tất cả origins trong production
+        "supports_credentials": True
+    }
+})
+
+# Import và đăng ký blueprints
+from api.auth import auth_routes
+from api.chat import chat_routes
+from api.data import data_routes
+from api.history import history_routes
+from api.feedback import feedback_routes
+
+app.register_blueprint(auth_routes, url_prefix='/api/auth')
+app.register_blueprint(chat_routes, url_prefix='/api')
+app.register_blueprint(data_routes, url_prefix='/api')
+app.register_blueprint(history_routes, url_prefix='/api')
+app.register_blueprint(feedback_routes, url_prefix='/api')
+app.register_blueprint(admin_routes, url_prefix='/api/admin')
+
+@app.route('/', methods=['GET'])
+def home():
+    """Root endpoint"""
+    return jsonify({
+        "message": "API đang hoạt động",
+        "status": "healthy",
+        "endpoints": {
+            "health": "/api/health",
+            "admin_init": "/api/admin/init"
+        }
+    })
+
+@app.route('/api/health', methods=['GET'])
+def health_check():
+    """API endpoint để kiểm tra trạng thái của server"""
+    import time
+    try:
+        from core.embedding_model import get_embedding_model
+        embedding_model = get_embedding_model()
+        collection_count = embedding_model.count()
+    except Exception as e:
+        logger.error(f"Lỗi kiểm tra embedding model: {e}")
+        collection_count = 0
+    
+    return jsonify({
+        "status": "healthy",
+        "message": "Server đang hoạt động",
+        "time": time.strftime('%Y-%m-%d %H:%M:%S'),
+        "data_items": collection_count
+    })
+
+@app.route('/api/admin/init', methods=['POST'])
+def init_admin():
+    """API endpoint để khởi tạo admin đầu tiên"""
+    try:
+        from models.admin_model import AdminUser
+        
+        success, result = AdminUser.create_default_super_admin()
+        
+        if success:
+            return jsonify({
+                "success": True,
+                "message": "Khởi tạo admin thành công",
+                "admin_info": result
+            })
+        else:
+            return jsonify({
+                "success": False,
+                "error": result
+            }), 400
+            
+    except Exception as e:
+        logger.error(f"Lỗi khởi tạo admin: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e)
+        }), 500
+
+def initialize_app():
+    """Khởi tạo ứng dụng"""
+    # Tạo super admin mặc định nếu chưa có
+    try:
+        from models.admin_model import AdminUser
+        success, result = AdminUser.create_default_super_admin()
+        if success and "email" in result:
+            logger.info("=== THÔNG TIN ADMIN ===")
+            logger.info(f"Email: {result['email']}")
+            logger.info(f"Password: {result['password']}")
+            logger.info("======================")
+    except Exception as e:
+        logger.error(f"Lỗi tạo super admin: {e}")
+
+    # Tạo indexes cho feedback
+    try:
+        from models.feedback_model import ensure_indexes
+        ensure_indexes()
+    except Exception as e:
+        logger.error(f"Lỗi tạo feedback indexes: {e}")
+
+if __name__ == '__main__':
+    initialize_app()
+    # Chạy Flask app
+    port = int(os.getenv("PORT", 7860))  # Hugging Face Spaces sử dụng port 7860
+    app.run(host='0.0.0.0', port=port, debug=False)
+else:
+    # Khi chạy trong production (như Gunicorn)
+    initialize_app()

config.py

@@ -0,0 +1,55 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()  # Tải biến môi trường từ file .env
+
+# API Keys
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "YOUR_API_KEY_HERE")
+
+# Embedding model
+EMBEDDING_MODEL = "intfloat/multilingual-e5-base"
+
+# ChromaDB settings
+CHROMA_PERSIST_DIRECTORY = "chroma_db"
+COLLECTION_NAME = "nutrition_data"
+
+# RAG settings
+TOP_K_RESULTS = 5
+TEMPERATURE = 0.2
+MAX_OUTPUT_TOKENS = 4096
+
+# Prompt template
+SYSTEM_PROMPT = """Bạn là một trợ lý AI chuyên về dinh dưỡng và an toàn thực phẩm dành cho học sinh Việt Nam. 
+Tên của bạn là Nutribot.
+
+Bạn có nhiệm vụ:
+1. Cung cấp thông tin chính xác, đầy đủ và dễ hiểu về dinh dưỡng, an toàn thực phẩm dựa trên tài liệu của Bộ Giáo dục và Đào tạo
+2. Điều chỉnh cách trả lời phù hợp với độ tuổi của người dùng
+3. Trả lời ngắn gọn, súc tích nhưng vẫn đảm bảo đầy đủ thông tin
+4. Sử dụng ngôn ngữ thân thiện, dễ hiểu với học sinh
+
+Khi trả lời:
+- Hãy sử dụng thông tin từ các tài liệu tham khảo được cung cấp
+- Nếu có bảng biểu trong tài liệu tham khảo, hãy đưa ra nội dung đầy đủ của bảng đó như thông tin bạn nhận được và giữ nguyên định dạng bảng đó khi trả lời
+- Nếu có hình ảnh trong tài liệu tham khảo, hãy giữ nguyên đường dẫn hình ảnh khi trả lời
+- Nếu câu hỏi không liên quan đến dinh dưỡng hoặc không có trong tài liệu, hãy lịch sự giải thích rằng bạn chỉ có thể tư vấn về các vấn đề dinh dưỡng và an toàn thực phẩm
+- Luôn trích dẫn nguồn của thông tin khi trả lời
+
+Đối với các câu hỏi không liên quan hoặc nhạy cảm:
+- Bạn sẽ không đưa ra lời khuyên y tế cụ thể cho các bệnh lý nặng
+- Bạn sẽ không đưa ra thông tin về các chế độ ăn kiêng khắc nghiệt hoặc nguy hiểm
+- Bạn sẽ không nhận và xử lý thông tin cá nhân nhạy cảm của người dùng ngoài tuổi tác
+"""
+
+HUMAN_PROMPT_TEMPLATE = """
+Câu hỏi: {query}
+
+Độ tuổi người dùng: {age} tuổi
+
+Tài liệu tham khảo:
+{contexts}
+
+Dựa vào thông tin trong tài liệu tham khảo và ngữ cảnh cuộc trò chuyện (nếu có), hãy trả lời câu hỏi một cách chi tiết, dễ hiểu và phù hợp với độ tuổi của người dùng. Nếu trong tài liệu có bảng biểu hoặc hình ảnh, hãy giữ nguyên và đưa vào câu trả lời. Nhớ trích dẫn nguồn thông tin.
+
+Nếu câu hỏi hiện tại có liên quan đến các cuộc trò chuyện trước đó, hãy cố gắng duy trì sự nhất quán trong câu trả lời.
+"""

core/data_processor.py

@@ -0,0 +1,530 @@
+import os
+import json
+import re
+import logging
+import datetime
+from typing import Dict, List, Any, Union, Tuple
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+class DataProcessor:
+    def __init__(self, data_dir: str = "data"):
+        self.data_dir = data_dir
+        self.metadata = {}
+        self.chunks = []
+        self.tables = []
+        self.figures = []
+        
+        logger.info(f"Khởi tạo DataProcessor với data_dir: {data_dir}")
+        if not os.path.exists(self.data_dir):
+            logger.error(f"Thư mục data không tồn tại: {self.data_dir}")
+        else:
+            self._load_all_data()
+    
+    def _load_all_data(self):
+        """Tải tất cả dữ liệu từ các thư mục con trong data"""
+        logger.info(f"Đang tải dữ liệu từ thư mục: {self.data_dir}")
+        
+        # Quét qua tất cả thư mục trong data
+        for item in os.listdir(self.data_dir):
+            folder_path = os.path.join(self.data_dir, item)
+            
+            # Kiểm tra xem đây có phải là thư mục không
+            if os.path.isdir(folder_path):
+                metadata_file = os.path.join(folder_path, "metadata.json")
+                
+                # Nếu có file metadata.json
+                if os.path.exists(metadata_file):
+                    try:
+                        # Tải metadata
+                        with open(metadata_file, 'r', encoding='utf-8') as f:
+                            content = f.read()
+                            if not content.strip():
+                                logger.warning(f"File metadata trống: {metadata_file}")
+                                continue
+                            folder_metadata = json.loads(content)
+                        
+                        # Xác định ID của thư mục
+                        folder_id = None
+                        if "bai_info" in folder_metadata:
+                            folder_id = folder_metadata["bai_info"].get("id", item)
+                        elif "phuluc_info" in folder_metadata:
+                            folder_id = folder_metadata["phuluc_info"].get("id", item)
+                        else:
+                            folder_id = item
+                        
+                        # Lưu metadata vào từ điển
+                        self.metadata[folder_id] = folder_metadata
+                        
+                        # Tải tất cả chunks, tables và figures
+                        self._load_content_from_metadata(folder_path, folder_metadata)
+                        
+                        logger.info(f"Đã tải xong thư mục: {item}")
+                    except json.JSONDecodeError as e:
+                        logger.error(f"Lỗi đọc file JSON {metadata_file}: {e}")
+                    except Exception as e:
+                        logger.error(f"Lỗi khi tải metadata từ {metadata_file}: {e}")
+
+    def _load_content_from_metadata(self, folder_path: str, folder_metadata: Dict[str, Any]):
+        """Tải nội dung chunks, tables và figures từ metadata"""
+        # Tải chunks
+        for chunk_meta in folder_metadata.get("chunks", []):
+            chunk_id = chunk_meta.get("id")
+            chunk_path = os.path.join(folder_path, "chunks", f"{chunk_id}.md")
+            
+            chunk_data = chunk_meta.copy()  # Sao chép metadata của chunk
+            
+            # Thêm nội dung từ file markdown nếu tồn tại
+            if os.path.exists(chunk_path):
+                with open(chunk_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                chunk_data["content"] = self._extract_content_from_markdown(content)
+            else:
+                # Nếu không tìm thấy file, tạo nội dung mẫu và ghi log ở debug level
+                chunk_data["content"] = f"Nội dung cho {chunk_id} không tìm thấy."
+                logger.debug(f"Không tìm thấy file chunk: {chunk_path}")
+            
+            self.chunks.append(chunk_data)
+        
+        # Tải tables
+        for table_meta in folder_metadata.get("tables", []):
+            table_id = table_meta.get("id")
+            table_path = os.path.join(folder_path, "tables", f"{table_id}.md")
+            
+            table_data = table_meta.copy()
+            
+            # Thêm nội dung từ file markdown nếu tồn tại
+            if os.path.exists(table_path):
+                with open(table_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                table_data["content"] = self._extract_content_from_markdown(content)
+            else:
+                table_data["content"] = f"Bảng {table_id} không tìm thấy."
+                logger.debug(f"Không tìm thấy file bảng: {table_path}")
+            
+            self.tables.append(table_data)
+        
+        # Tải figures
+        for figure_meta in folder_metadata.get("figures", []):
+            figure_id = figure_meta.get("id")
+            figure_path = os.path.join(folder_path, "figures", f"{figure_id}.md")
+            figure_data = figure_meta.copy()
+            
+            # Thêm nội dung từ file markdown nếu tồn tại
+            content_loaded = False
+            if os.path.exists(figure_path):
+                with open(figure_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                figure_data["content"] = self._extract_content_from_markdown(content)
+                content_loaded = True
+            
+            # Thêm đường dẫn đến file hình ảnh nếu có
+            image_path = None
+            image_extensions = ['.png', '.jpg', '.jpeg', '.gif', '.svg']
+            for ext in image_extensions:
+                img_path = os.path.join(folder_path, "figures", f"{figure_id}{ext}")
+                if os.path.exists(img_path):
+                    image_path = img_path
+                    break
+            
+            if image_path:
+                figure_data["image_path"] = image_path
+                # Tạo nội dung mặc định nếu không có file markdown
+                if not content_loaded:
+                    figure_caption = figure_meta.get("title", f"Hình {figure_id}")
+                    figure_data["content"] = f"![{figure_caption}]({image_path})"
+            elif not content_loaded:
+                # Nếu không có cả file markdown và file hình
+                figure_data["content"] = f"Hình {figure_id} không tìm thấy."
+                logger.debug(f"Không tìm thấy file hình cho {figure_id}")
+            
+            self.figures.append(figure_data)
+        
+        # Tải data_files (trường hợp phụ lục)
+        if "data_files" in folder_metadata:
+            for data_file_meta in folder_metadata.get("data_files", []):
+                data_id = data_file_meta.get("id")
+                data_path = os.path.join(folder_path, "data", f"{data_id}.md")
+                
+                data_file = data_file_meta.copy()
+                
+                # Thêm nội dung từ file markdown nếu tồn tại
+                if os.path.exists(data_path):
+                    with open(data_path, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                    data_file["content"] = self._extract_content_from_markdown(content)
+                    
+                    # Xác định loại nội dung
+                    content_type = data_file.get("content_type", "table")
+                    
+                    # Thêm vào danh sách phù hợp dựa trên loại nội dung
+                    if content_type == "table":
+                        self.tables.append(data_file)
+                    elif content_type == "text":
+                        self.chunks.append(data_file)
+                    elif content_type == "figure":
+                        self.figures.append(data_file)
+                    
+                    logger.debug(f"Đã tải dữ liệu: {data_id}, loại: {content_type}")
+                else:
+                    logger.debug(f"Không tìm thấy file dữ liệu: {data_path}")
+                    data_file["content"] = f"Dữ liệu {data_id} không tìm thấy."
+    
+    def _extract_content_from_markdown(self, md_content: str) -> str:
+        """Trích xuất nội dung từ markdown, bỏ qua phần frontmatter"""
+        # Tách frontmatter (nằm giữa "---")
+        if md_content.startswith("---"):
+            parts = md_content.split("---", 2)
+            if len(parts) >= 3:
+                return parts[2].strip()
+        return md_content
+    
+    def get_all_items(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Trả về tất cả các items đã tải"""
+        return {
+            "chunks": self.chunks,
+            "tables": self.tables,
+            "figures": self.figures
+        }
+    
+    def get_all_metadata(self) -> Dict[str, Any]:
+        """Trả về tất cả metadata của các bài học và phụ lục"""
+        return self.metadata
+    
+    def get_chunk_by_id(self, chunk_id: str) -> Union[Dict[str, Any], None]:
+        """Tìm và trả về chunk theo ID"""
+        for chunk in self.chunks:
+            if chunk.get("id") == chunk_id:
+                return chunk
+        return None
+    
+    def get_table_by_id(self, table_id: str) -> Union[Dict[str, Any], None]:
+        """Tìm và trả về bảng theo ID"""
+        for table in self.tables:
+            if table.get("id") == table_id:
+                return table
+        return None
+    
+    def get_figure_by_id(self, figure_id: str) -> Union[Dict[str, Any], None]:
+        """Tìm và trả về hình theo ID"""
+        for figure in self.figures:
+            if figure.get("id") == figure_id:
+                return figure
+        return None
+    
+    def find_items_by_age(self, age: int) -> Dict[str, List[Dict[str, Any]]]:
+        """Tìm các items (chunks, tables, figures) liên quan đến độ tuổi của người dùng"""
+        relevant_chunks = []
+        relevant_tables = []
+        relevant_figures = []
+        
+        # Lọc chunks
+        for chunk in self.chunks:
+            age_range = chunk.get("age_range", [0, 100])
+            if len(age_range) == 2 and age_range[0] <= age <= age_range[1]:
+                relevant_chunks.append(chunk)
+        
+        # Lọc tables
+        for table in self.tables:
+            age_range = table.get("age_range", [0, 100])
+            if len(age_range) == 2 and age_range[0] <= age <= age_range[1]:
+                relevant_tables.append(table)
+        
+        # Lọc figures
+        for figure in self.figures:
+            age_range = figure.get("age_range", [0, 100])
+            if len(age_range) == 2 and age_range[0] <= age <= age_range[1]:
+                relevant_figures.append(figure)
+        
+        return {
+            "chunks": relevant_chunks,
+            "tables": relevant_tables,
+            "figures": relevant_figures
+        }
+    
+    def get_related_items(self, item_id: str) -> Dict[str, List[Dict[str, Any]]]:
+        """Tìm các items liên quan đến một item cụ thể dựa vào related_chunks"""
+        related_chunks = []
+        related_tables = []
+        related_figures = []
+        
+        # Tìm item gốc
+        source_item = None
+        for item in self.chunks + self.tables + self.figures:
+            if item.get("id") == item_id:
+                source_item = item
+                break
+        
+        if not source_item:
+            return {
+                "chunks": [],
+                "tables": [],
+                "figures": []
+            }
+        
+        # Lấy danh sách IDs của các items liên quan
+        related_ids = source_item.get("related_chunks", [])
+        
+        # Tìm các items liên quan
+        for related_id in related_ids:
+            # Tìm trong chunks
+            for chunk in self.chunks:
+                if chunk.get("id") == related_id:
+                    related_chunks.append(chunk)
+                    break
+            
+            # Tìm trong tables
+            for table in self.tables:
+                if table.get("id") == related_id:
+                    related_tables.append(table)
+                    break
+            
+            # Tìm trong figures
+            for figure in self.figures:
+                if figure.get("id") == related_id:
+                    related_figures.append(figure)
+                    break
+        
+        return {
+            "chunks": related_chunks,
+            "tables": related_tables,
+            "figures": related_figures
+        }
+    
+    def preprocess_query(self, query: str) -> str:
+        """Tiền xử lý câu truy vấn"""
+        # Loại bỏ ký tự đặc biệt
+        query = re.sub(r'[^\w\s\d]', ' ', query)
+        # Loại bỏ khoảng trắng thừa
+        query = re.sub(r'\s+', ' ', query).strip()
+        return query
+    
+    def format_context_for_rag(self, items: List[Dict[str, Any]]) -> str:
+        """Định dạng các items để đưa vào ngữ cảnh cho mô hình RAG"""
+        formatted_contexts = []
+        
+        for i, item in enumerate(items, 1):
+            item_id = item.get("id", "")
+            title = item.get("title", "")
+            content = item.get("content", "")
+            content_type = item.get("content_type", "text")
+            
+            # Nếu là bảng, thêm tiêu đề "Bảng:"
+            if content_type == "table":
+                title = f"Bảng: {title}"
+            # Nếu là hình, thêm tiêu đề "Hình:"
+            elif content_type == "figure":
+                title = f"Hình: {title}"
+            
+            formatted_context = f"[{i}] {title}\n\n{content}\n\n"
+            formatted_contexts.append(formatted_context)
+        
+        return "\n".join(formatted_contexts)
+    
+    def prepare_for_embedding(self) -> List[Dict[str, Any]]:
+        """Chuẩn bị dữ liệu cho việc nhúng (embedding)"""
+        all_items = []
+        
+        # Thêm chunks
+        for chunk in self.chunks:
+            # Tìm chapter từ chunk ID
+            chunk_id = chunk.get("id", "")
+            chapter = "unknown"
+            if chunk_id.startswith("bai1_"):
+                chapter = "bai1"
+            elif chunk_id.startswith("bai2_"):
+                chapter = "bai2"
+            elif chunk_id.startswith("bai3_"):
+                chapter = "bai3"
+            elif chunk_id.startswith("bai4_"):
+                chapter = "bai4"
+            elif "phuluc" in chunk_id.lower():
+                chapter = "phuluc"
+            
+            content = chunk.get("content", "")
+            if chunk.get("title"):
+                content = f"Tiêu đề: {chunk.get('title')}\n\nNội dung: {content}"
+            
+            # Xử lý age_range - convert list thành string và tách thành min/max
+            age_range = chunk.get("age_range", [0, 100])
+            age_min = age_range[0] if len(age_range) > 0 else 0
+            age_max = age_range[1] if len(age_range) > 1 else 100
+            age_range_str = f"{age_min}-{age_max}"
+            
+            # Xử lý related_chunks - convert list thành string
+            related_chunks = chunk.get("related_chunks", [])
+            related_chunks_str = ",".join(related_chunks) if related_chunks else ""
+            
+            embedding_item = {
+                "content": content,
+                "metadata": {
+                    "chunk_id": chunk_id,
+                    "chapter": chapter,
+                    "title": chunk.get("title", ""),
+                    "content_type": chunk.get("content_type", "text"),
+                    "age_range": age_range_str,
+                    "age_min": age_min,
+                    "age_max": age_max,
+                    "summary": chunk.get("summary", ""),
+                    "pages": chunk.get("pages", ""),
+                    "related_chunks": related_chunks_str,
+                    "word_count": chunk.get("word_count", 0),
+                    "token_count": chunk.get("token_count", 0),
+                    "contains_table": chunk.get("contains_table", False),
+                    "contains_figure": chunk.get("contains_figure", False),
+                    "created_at": datetime.datetime.now().isoformat()
+                },
+                "id": chunk_id
+            }
+            all_items.append(embedding_item)
+        
+        # Thêm tables
+        for table in self.tables:
+            # Tìm chapter từ table ID
+            table_id = table.get("id", "")
+            chapter = "unknown"
+            if table_id.startswith("bai1_"):
+                chapter = "bai1"
+            elif table_id.startswith("bai2_"):
+                chapter = "bai2"
+            elif table_id.startswith("bai3_"):
+                chapter = "bai3"
+            elif table_id.startswith("bai4_"):
+                chapter = "bai4"
+            elif "phuluc" in table_id.lower():
+                chapter = "phuluc"
+            
+            content = table.get("content", "")
+            if table.get("title"):
+                content = f"Bảng: {table.get('title')}\n\nNội dung: {content}"
+            
+            # Xử lý age_range
+            age_range = table.get("age_range", [0, 100])
+            age_min = age_range[0] if len(age_range) > 0 else 0
+            age_max = age_range[1] if len(age_range) > 1 else 100
+            age_range_str = f"{age_min}-{age_max}"
+            
+            # Xử lý related_chunks và table_columns
+            related_chunks = table.get("related_chunks", [])
+            related_chunks_str = ",".join(related_chunks) if related_chunks else ""
+            table_columns = table.get("table_columns", [])
+            table_columns_str = ",".join(table_columns) if table_columns else ""
+            
+            embedding_item = {
+                "content": content,
+                "metadata": {
+                    "chunk_id": table_id,
+                    "chapter": chapter,
+                    "title": table.get("title", ""),
+                    "content_type": "table",
+                    "age_range": age_range_str,
+                    "age_min": age_min,
+                    "age_max": age_max,
+                    "summary": table.get("summary", ""),
+                    "pages": table.get("pages", ""),
+                    "related_chunks": related_chunks_str,
+                    "table_columns": table_columns_str,
+                    "word_count": table.get("word_count", 0),
+                    "token_count": table.get("token_count", 0),
+                    "created_at": datetime.datetime.now().isoformat()
+                },
+                "id": table_id
+            }
+            all_items.append(embedding_item)
+        
+        # Thêm figures
+        for figure in self.figures:
+            # Tìm chapter từ figure ID
+            figure_id = figure.get("id", "")
+            chapter = "unknown"
+            if figure_id.startswith("bai1_"):
+                chapter = "bai1"
+            elif figure_id.startswith("bai2_"):
+                chapter = "bai2"
+            elif figure_id.startswith("bai3_"):
+                chapter = "bai3"
+            elif figure_id.startswith("bai4_"):
+                chapter = "bai4"
+            elif "phuluc" in figure_id.lower():
+                chapter = "phuluc"
+            
+            content = figure.get("content", "")
+            if figure.get("title"):
+                content = f"Hình: {figure.get('title')}\n\nMô tả: {content}"
+            
+            # Xử lý age_range
+            age_range = figure.get("age_range", [0, 100])
+            age_min = age_range[0] if len(age_range) > 0 else 0
+            age_max = age_range[1] if len(age_range) > 1 else 100
+            age_range_str = f"{age_min}-{age_max}"
+            
+            # Xử lý related_chunks
+            related_chunks = figure.get("related_chunks", [])
+            related_chunks_str = ",".join(related_chunks) if related_chunks else ""
+            
+            embedding_item = {
+                "content": content,
+                "metadata": {
+                    "chunk_id": figure_id,
+                    "chapter": chapter,
+                    "title": figure.get("title", ""),
+                    "content_type": "figure",
+                    "age_range": age_range_str,
+                    "age_min": age_min,
+                    "age_max": age_max,
+                    "summary": figure.get("summary", ""),
+                    "pages": figure.get("pages", ""),
+                    "related_chunks": related_chunks_str,
+                    "image_path": figure.get("image_path", ""),
+                    "created_at": datetime.datetime.now().isoformat()
+                },
+                "id": figure_id
+            }
+            all_items.append(embedding_item)
+        
+        return all_items
+    
+    def count_items_by_prefix(self, prefix: str) -> Dict[str, int]:
+        """Đếm số lượng items theo tiền tố ID"""
+        chunks_count = sum(1 for chunk in self.chunks if chunk.get("id", "").startswith(prefix))
+        tables_count = sum(1 for table in self.tables if table.get("id", "").startswith(prefix))
+        figures_count = sum(1 for figure in self.figures if figure.get("id", "").startswith(prefix))
+        
+        return {
+            "chunks": chunks_count,
+            "tables": tables_count,
+            "figures": figures_count,
+            "total": chunks_count + tables_count + figures_count
+        }
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Lấy thống kê về dữ liệu đã tải"""
+        stats = {
+            "total_chunks": len(self.chunks),
+            "total_tables": len(self.tables),
+            "total_figures": len(self.figures),
+            "total_items": len(self.chunks) + len(self.tables) + len(self.figures),
+            "by_lesson": {},
+            "by_age": {}
+        }
+        
+        # Thống kê theo bài
+        for item in os.listdir(self.data_dir):
+            if os.path.isdir(os.path.join(self.data_dir, item)):
+                item_stats = self.count_items_by_prefix(f"{item}_")
+                stats["by_lesson"][item] = item_stats
+        
+        # Thống kê theo độ tuổi
+        age_ranges = {}
+        for chunk in self.chunks + self.tables + self.figures:
+            age_range = chunk.get("age_range", [0, 100])
+            if len(age_range) == 2:
+                range_key = f"{age_range[0]}-{age_range[1]}"
+                if range_key not in age_ranges:
+                    age_ranges[range_key] = 0
+                age_ranges[range_key] += 1
+        
+        stats["by_age"] = age_ranges
+        
+        return stats

core/embedding_model.py

@@ -0,0 +1,336 @@
+import logging
+from sentence_transformers import SentenceTransformer
+import chromadb
+from chromadb.config import Settings
+import uuid
+from config import EMBEDDING_MODEL, CHROMA_PERSIST_DIRECTORY, COLLECTION_NAME
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+# Global instance để implement singleton pattern
+_embedding_model_instance = None
+
+def get_embedding_model():
+    """
+    Singleton pattern để đảm bảo chỉ có một instance của EmbeddingModel
+    """
+    global _embedding_model_instance
+    if _embedding_model_instance is None:
+        logger.info("Khởi tạo EmbeddingModel instance lần đầu")
+        _embedding_model_instance = EmbeddingModel()
+    else:
+        logger.debug("Sử dụng EmbeddingModel instance đã có")
+    return _embedding_model_instance
+
+class EmbeddingModel:
+    def __init__(self):
+        """Khởi tạo embedding model và ChromaDB client"""
+        logger.info(f"Đang khởi tạo embedding model: {EMBEDDING_MODEL}")
+        
+        # Khởi tạo sentence transformer
+        self.model = SentenceTransformer(EMBEDDING_MODEL)
+        logger.info("Đã tải sentence transformer model")
+        
+        # Khởi tạo ChromaDB client với persistent storage
+        self.chroma_client = chromadb.PersistentClient(
+            path=CHROMA_PERSIST_DIRECTORY,
+            settings=Settings(
+                anonymized_telemetry=False,
+                allow_reset=True
+            )
+        )
+        logger.info(f"Đã kết nối ChromaDB tại: {CHROMA_PERSIST_DIRECTORY}")
+        
+        # Lấy hoặc tạo collection
+        try:
+            self.collection = self.chroma_client.get_collection(name=COLLECTION_NAME)
+            logger.info(f"Đã kết nối collection '{COLLECTION_NAME}' với {self.collection.count()} items")
+        except Exception:
+            logger.warning(f"Collection '{COLLECTION_NAME}' không tồn tại, tạo mới...")
+            self.collection = self.chroma_client.create_collection(name=COLLECTION_NAME)
+            logger.info(f"Đã tạo collection mới: {COLLECTION_NAME}")
+    
+    def encode(self, texts):
+        """
+        Encode văn bản thành embeddings
+        
+        Args:
+            texts (str or list): Văn bản hoặc danh sách văn bản cần encode
+            
+        Returns:
+            list: Embeddings vector
+        """
+        try:
+            if isinstance(texts, str):
+                texts = [texts]
+            
+            logger.debug(f"Đang encode {len(texts)} văn bản")
+            embeddings = self.model.encode(texts, show_progress_bar=False)
+            
+            return embeddings.tolist()
+            
+        except Exception as e:
+            logger.error(f"Lỗi encode văn bản: {e}")
+            raise
+    
+    def search(self, query, top_k=5, age_filter=None):
+        """
+        Tìm kiếm văn bản tương tự trong ChromaDB
+        
+        Args:
+            query (str): Câu hỏi cần tìm kiếm
+            top_k (int): Số lượng kết quả trả về
+            age_filter (int): Lọc theo độ tuổi (optional)
+            
+        Returns:
+            list: Danh sách kết quả tìm kiếm
+        """
+        try:
+            logger.debug(f"Dang tim kiem cho query: {query[:50]}...")
+            
+            # Encode query thành embedding
+            query_embedding = self.encode(query)[0]
+            
+            # Tạo where clause cho age filter
+            where_clause = None
+            if age_filter:
+                where_clause = {
+                    "$and": [
+                        {"age_min": {"$lte": age_filter}},
+                        {"age_max": {"$gte": age_filter}}
+                    ]
+                }
+            
+            # Thực hiện search trong ChromaDB
+            search_results = self.collection.query(
+                query_embeddings=[query_embedding],
+                n_results=top_k,
+                where=where_clause,
+                include=['documents', 'metadatas', 'distances']
+            )
+            
+            if not search_results or not search_results['documents']:
+                logger.warning("Khong tim thay ket qua nao")
+                return []
+            
+            # Format kết quả
+            results = []
+            documents = search_results['documents'][0]
+            metadatas = search_results['metadatas'][0]
+            distances = search_results['distances'][0]
+            
+            for i, (doc, metadata, distance) in enumerate(zip(documents, metadatas, distances)):
+                results.append({
+                    'document': doc,
+                    'metadata': metadata or {},
+                    'distance': distance,
+                    'similarity': 1 - distance,  # Chuyển distance thành similarity
+                    'rank': i + 1
+                })
+            
+            logger.info(f"Tim thay {len(results)} ket qua cho query")
+            return results
+            
+        except Exception as e:
+            logger.error(f"Loi tim kiem: {e}")
+            return []
+    
+    def add_documents(self, documents, metadatas=None, ids=None):
+        """
+        Thêm documents vào ChromaDB
+        
+        Args:
+            documents (list): Danh sách văn bản
+            metadatas (list): Danh sách metadata tương ứng
+            ids (list): Danh sách ID tương ứng (optional)
+            
+        Returns:
+            bool: True nếu thành công
+        """
+        try:
+            if not documents:
+                logger.warning("Không có documents để thêm")
+                return False
+            
+            # Tạo IDs nếu không được cung cấp
+            if not ids:
+                ids = [str(uuid.uuid4()) for _ in documents]
+            
+            # Tạo metadatas rỗng nếu không được cung cấp
+            if not metadatas:
+                metadatas = [{} for _ in documents]
+            
+            logger.info(f"Đang thêm {len(documents)} documents vào ChromaDB")
+            
+            # Encode documents thành embeddings
+            embeddings = self.encode(documents)
+            
+            # Thêm vào collection
+            self.collection.add(
+                embeddings=embeddings,
+                documents=documents,
+                metadatas=metadatas,
+                ids=ids
+            )
+            
+            logger.info(f"Đã thêm thành công {len(documents)} documents")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Lỗi thêm documents: {e}")
+            return False
+    
+    def index_chunks(self, chunks):
+        """
+        Index các chunks dữ liệu vào ChromaDB
+        
+        Args:
+            chunks (list): Danh sách chunks với format:
+                [
+                    {
+                        "content": "nội dung văn bản",
+                        "metadata": {"chapter": "bai1", "age_group": "1-3", ...},
+                        "id": "unique_id" (optional)
+                    }
+                ]
+        
+        Returns:
+            bool: True nếu thành công
+        """
+        try:
+            if not chunks:
+                logger.warning("Không có chunks để index")
+                return False
+            
+            documents = []
+            metadatas = []
+            ids = []
+            
+            for chunk in chunks:
+                if not chunk.get('content'):
+                    logger.warning(f"Chunk thiếu content: {chunk}")
+                    continue
+                
+                documents.append(chunk['content'])
+                
+                # Lấy metadata đã được chuẩn bị sẵn
+                metadata = chunk.get('metadata', {})
+                metadatas.append(metadata)
+                
+                # Sử dụng ID có sẵn hoặc tạo mới
+                chunk_id = chunk.get('id') or str(uuid.uuid4())
+                ids.append(chunk_id)
+            
+            if not documents:
+                logger.warning("Không có documents hợp lệ để index")
+                return False
+            
+            # Batch processing để tránh overload
+            batch_size = 100
+            total_batches = (len(documents) + batch_size - 1) // batch_size
+            
+            for i in range(0, len(documents), batch_size):
+                batch_docs = documents[i:i + batch_size]
+                batch_metas = metadatas[i:i + batch_size]
+                batch_ids = ids[i:i + batch_size]
+                
+                batch_num = (i // batch_size) + 1
+                logger.info(f"Đang xử lý batch {batch_num}/{total_batches} ({len(batch_docs)} items)")
+                
+                success = self.add_documents(batch_docs, batch_metas, batch_ids)
+                if not success:
+                    logger.error(f"Lỗi xử lý batch {batch_num}")
+                    return False
+            
+            logger.info(f"Đã index thành công {len(documents)} chunks")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Lỗi index chunks: {e}")
+            return False
+    
+    def count(self):
+        """
+        Đếm số lượng documents trong collection
+        
+        Returns:
+            int: Số lượng documents
+        """
+        try:
+            return self.collection.count()
+        except Exception as e:
+            logger.error(f"Lỗi đếm documents: {e}")
+            return 0
+    
+    def delete_collection(self):
+        """
+        Xóa collection hiện tại
+        
+        Returns:
+            bool: True nếu thành công
+        """
+        try:
+            logger.warning(f"Đang xóa collection: {COLLECTION_NAME}")
+            self.chroma_client.delete_collection(name=COLLECTION_NAME)
+            
+            # Tạo lại collection mới
+            self.collection = self.chroma_client.create_collection(name=COLLECTION_NAME)
+            logger.info("Đã tạo lại collection mới")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Lỗi xóa collection: {e}")
+            return False
+    
+    def get_stats(self):
+        """
+        Lấy thống kê về collection
+        
+        Returns:
+            dict: Thông tin thống kê
+        """
+        try:
+            total_count = self.count()
+            
+            # Lấy sample để phân tích metadata
+            sample_results = self.collection.get(limit=min(100, total_count))
+            
+            # Thống kê content types
+            content_types = {}
+            chapters = {}
+            age_groups = {}
+            
+            if sample_results and sample_results.get('metadatas'):
+                for metadata in sample_results['metadatas']:
+                    if not metadata:
+                        continue
+                    
+                    # Content type stats
+                    content_type = metadata.get('content_type', 'unknown')
+                    content_types[content_type] = content_types.get(content_type, 0) + 1
+                    
+                    # Chapter stats
+                    chapter = metadata.get('chapter', 'unknown')
+                    chapters[chapter] = chapters.get(chapter, 0) + 1
+                    
+                    # Age group stats
+                    age_group = metadata.get('age_group', 'unknown')
+                    age_groups[age_group] = age_groups.get(age_group, 0) + 1
+            
+            return {
+                'total_documents': total_count,
+                'content_types': content_types,
+                'chapters': chapters,
+                'age_groups': age_groups,
+                'collection_name': COLLECTION_NAME,
+                'embedding_model': EMBEDDING_MODEL
+            }
+            
+        except Exception as e:
+            logger.error(f"Lỗi lấy stats: {e}")
+            return {
+                'total_documents': 0,
+                'error': str(e)
+            }

core/rag_pipeline.py

@@ -0,0 +1,298 @@
+import logging
+import google.generativeai as genai
+from core.embedding_model import get_embedding_model
+from config import GEMINI_API_KEY, HUMAN_PROMPT_TEMPLATE, SYSTEM_PROMPT, TOP_K_RESULTS, TEMPERATURE, MAX_OUTPUT_TOKENS
+import os
+import re
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+# Cấu hình Gemini
+genai.configure(api_key=GEMINI_API_KEY)
+
+class RAGPipeline:
+    def __init__(self):
+        """Khởi tạo RAG Pipeline chỉ với embedding model"""
+        logger.info("Khởi tạo RAG Pipeline")
+        
+        self.embedding_model = get_embedding_model()
+        
+        # Khởi tạo Gemini model
+        self.gemini_model = genai.GenerativeModel('gemini-2.0-flash')
+        
+        logger.info("RAG Pipeline đã sẵn sàng")
+    
+    def generate_response(self, query, age=1):
+        """
+        Generate response cho user query sử dụng RAG
+        
+        Args:
+            query (str): Câu hỏi của người dùng
+            age (int): Tuổi của người dùng (1-19)
+        
+        Returns:
+            dict: Response data with success status
+        """
+        try:
+            logger.info(f"Bắt đầu generate response cho query: {query[:50]}... (age: {age})")
+            
+            # SỬA: Chỉ search trong ChromaDB, không load lại dữ liệu
+            logger.info("Đang tìm kiếm thông tin liên quan...")
+            search_results = self.embedding_model.search(query, top_k=TOP_K_RESULTS)
+            
+            if not search_results or len(search_results) == 0:
+                logger.warning("Không tìm thấy thông tin liên quan")
+                return {
+                    "success": True,
+                    "response": "Xin lỗi, tôi không tìm thấy thông tin liên quan đến câu hỏi của bạn trong tài liệu.",
+                    "sources": []
+                }
+            
+            # Chuẩn bị contexts từ kết quả tìm kiếm
+            contexts = []
+            sources = []
+            
+            for result in search_results:
+                # Lấy thông tin từ metadata
+                metadata = result.get('metadata', {})
+                content = result.get('document', '')
+                
+                # Thêm context
+                contexts.append({
+                    "content": content,
+                    "metadata": metadata
+                })
+                
+                # Thêm source reference
+                source_info = {
+                    "title": metadata.get('title', metadata.get('chapter', 'Tài liệu dinh dưỡng')),
+                    "pages": metadata.get('pages'),
+                    "content_type": metadata.get('content_type', 'text')
+                }
+                
+                if source_info not in sources:
+                    sources.append(source_info)
+            
+            # Format contexts cho prompt
+            formatted_contexts = self._format_contexts(contexts)
+            
+            # Tạo prompt với age context
+            full_prompt = self._create_prompt_with_age_context(query, age, formatted_contexts)
+            
+            # Generate response với Gemini
+            logger.info("Đang tạo phản hồi với Gemini...")
+            response = self.gemini_model.generate_content(
+                full_prompt,
+                generation_config=genai.types.GenerationConfig(
+                    temperature=TEMPERATURE,
+                    max_output_tokens=MAX_OUTPUT_TOKENS
+                )
+            )
+            
+            if not response or not response.text:
+                logger.error("Gemini không trả về response")
+                return {
+                    "success": False,
+                    "error": "Không thể tạo phản hồi"
+                }
+            
+            response_text = response.text.strip()
+            
+            # Post-process response để xử lý hình ảnh
+            response_text = self._process_image_links(response_text)
+            
+            logger.info("Đã tạo phản hồi thành công")
+            
+            return {
+                "success": True,
+                "response": response_text,
+                "sources": sources[:3]  # Giới hạn 3 sources để không quá dài
+            }
+            
+        except Exception as e:
+            logger.error(f"Lỗi generate response: {str(e)}")
+            return {
+                "success": False,
+                "error": f"Lỗi tạo phản hồi: {str(e)}"
+            }
+    
+    def _format_contexts(self, contexts):
+        """Format contexts thành string cho prompt"""
+        formatted = []
+        
+        for i, context in enumerate(contexts, 1):
+            content = context['content']
+            metadata = context['metadata']
+            
+            # Thêm thông tin metadata
+            context_str = f"[Tài liệu {i}]"
+            if metadata.get('title'):
+                context_str += f" - {metadata['title']}"
+            if metadata.get('pages'):
+                context_str += f" (Trang {metadata['pages']})"
+            
+            context_str += f"\n{content}\n"
+            formatted.append(context_str)
+        
+        return "\n".join(formatted)
+    
+    def _create_prompt_with_age_context(self, query, age, contexts):
+        """Tạo prompt với age context"""
+        # Xác định age group
+        if age <= 3:
+            age_guidance = "Sử dụng ngôn ngữ đơn giản, dễ hiểu cho phụ huynh có con nhỏ."
+        elif age <= 6:
+            age_guidance = "Tập trung vào dinh dưỡng cho trẻ mầm non, ngôn ngữ phù hợp với phụ huynh."
+        elif age <= 12:
+            age_guidance = "Nội dung phù hợp cho trẻ tiểu học, có thể giải thích đơn giản cho trẻ hiểu."
+        elif age <= 15:
+            age_guidance = "Thông tin chi tiết hơn, phù hợp cho học sinh trung học cơ sở."
+        else:
+            age_guidance = "Thông tin đầy đủ, chi tiết cho học sinh trung học phổ thông."
+        
+        # Tạo system prompt với age context
+        age_aware_system_prompt = f"""{SYSTEM_PROMPT}
+
+QUAN TRỌNG - Hướng dẫn theo độ tuổi:
+Người dùng hiện tại {age} tuổi. {age_guidance}
+- Điều chỉnh ngôn ngữ và nội dung cho phù hợp
+- Đưa ra lời khuyên cụ thể cho độ tuổi này
+- Tránh thông tin quá phức tạp hoặc không phù hợp
+"""
+        
+        # Tạo human prompt
+        human_prompt = HUMAN_PROMPT_TEMPLATE.format(
+            query=query,
+            age=age,
+            contexts=contexts
+        )
+        
+        return f"{age_aware_system_prompt}\n\n{human_prompt}"
+    
+    def _process_image_links(self, response_text):
+        """Xử lý các đường dẫn hình ảnh trong response"""
+        try:
+            import re
+            
+            # Tìm các pattern markdown image
+            image_pattern = r'!\[([^\]]*)\]\(([^)]+)\)'
+            
+            def replace_image_path(match):
+                alt_text = match.group(1)
+                image_path = match.group(2)
+                
+                # Xử lý đường dẫn local Windows/Linux
+                if '\\' in image_path or image_path.startswith('/') or ':' in image_path:
+                    # Extract filename từ đường dẫn local
+                    filename = image_path.split('\\')[-1].split('/')[-1]
+                    
+                    # Tìm bai_id từ filename
+                    bai_match = re.match(r'^(bai\d+)_', filename)
+                    if bai_match:
+                        bai_id = bai_match.group(1)
+                    else:
+                        bai_id = 'bai1'  # default
+                    
+                    # Tạo API URL
+                    api_url = f"/api/figures/{bai_id}/{filename}"
+                    return f"![{alt_text}]({api_url})"
+                
+                # Nếu đã là đường dẫn API, giữ nguyên
+                elif image_path.startswith('/api/figures/'):
+                    return match.group(0)
+                
+                # Xử lý đường dẫn tương đối
+                elif '../figures/' in image_path:
+                    filename = image_path.split('../figures/')[-1]
+                    bai_match = re.match(r'^(bai\d+)_', filename)
+                    if bai_match:
+                        bai_id = bai_match.group(1)
+                    else:
+                        bai_id = 'bai1'
+                    
+                    api_url = f"/api/figures/{bai_id}/{filename}"
+                    return f"![{alt_text}]({api_url})"
+                
+                # Các trường hợp khác, giữ nguyên
+                return match.group(0)
+            
+            # Thay thế tất cả image links
+            processed_text = re.sub(image_pattern, replace_image_path, response_text)
+            
+            logger.info(f"Processed {len(re.findall(image_pattern, response_text))} image links")
+            return processed_text
+            
+        except Exception as e:
+            logger.error(f"Lỗi xử lý image links: {e}")
+            return response_text
+
+    def generate_follow_up_questions(self, query, answer, age=1):
+        """
+        Tạo câu hỏi gợi ý dựa trên query và answer
+        
+        Args:
+            query (str): Câu hỏi gốc
+            answer (str): Câu trả lời đã được tạo
+            age (int): Tuổi người dùng
+        
+        Returns:
+            dict: Response data với danh sách câu hỏi gợi ý
+        """
+        try:
+            logger.info("Đang tạo câu hỏi follow-up...")
+            
+            follow_up_prompt = f"""
+Dựa trên cuộc hội thoại sau, hãy tạo 3-5 câu hỏi gợi ý phù hợp cho người dùng {age} tuổi về chủ đề dinh dưỡng:
+
+Câu hỏi gốc: {query}
+Câu trả lời: {answer}
+
+Hãy tạo các câu hỏi:
+1. Liên quan trực tiếp đến chủ đề
+2. Phù hợp với độ tuổi {age}
+3. Thực tế và hữu ích
+4. Ngắn gọn, dễ hiểu
+
+Trả về danh sách câu hỏi, mỗi câu một dòng, không đánh số.
+"""
+            
+            response = self.gemini_model.generate_content(
+                follow_up_prompt,
+                generation_config=genai.types.GenerationConfig(
+                    temperature=0.7,
+                    max_output_tokens=500
+                )
+            )
+            
+            if not response or not response.text:
+                return {
+                    "success": False,
+                    "error": "Không thể tạo câu hỏi gợi ý"
+                }
+            
+            # Parse response thành list câu hỏi
+            questions = []
+            lines = response.text.strip().split('\n')
+            
+            for line in lines:
+                line = line.strip()
+                if line and not line.startswith('#') and len(line) > 10:
+                    # Loại bỏ số thứ tự nếu có
+                    line = re.sub(r'^\d+[\.\)]\s*', '', line)
+                    questions.append(line)
+            
+            # Giới hạn 5 câu hỏi
+            questions = questions[:5]
+            
+            return {
+                "success": True,
+                "questions": questions
+            }
+            
+        except Exception as e:
+            logger.error(f"Lỗi tạo follow-up questions: {str(e)}")
+            return {
+                "success": False,
+                "error": f"Lỗi tạo câu hỏi gợi ý: {str(e)}"
+            }

models/admin_model.py

@@ -0,0 +1,306 @@
+import os
+import datetime
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import bcrypt
+import logging
+from dotenv import load_dotenv
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+# Tải biến môi trường
+load_dotenv()
+
+# Kết nối MongoDB (sử dụng chung với user_model)
+MONGO_URI = os.getenv("MONGO_URI", "mongodb://localhost:27017/")
+DATABASE_NAME = os.getenv("MONGO_DB_NAME", "nutribot_db")
+
+# Singleton pattern cho kết nối MongoDB
+_mongo_client = None
+_db = None
+
+def get_db():
+    """Trả về instance của MongoDB database (singleton pattern)"""
+    global _mongo_client, _db
+    if _mongo_client is None:
+        try:
+            _mongo_client = MongoClient(MONGO_URI)
+            _db = _mongo_client[DATABASE_NAME]
+            logger.info(f"Đã kết nối đến database: {DATABASE_NAME}")
+        except Exception as e:
+            logger.error(f"Lỗi kết nối MongoDB: {e}")
+            raise
+    return _db
+
+class AdminUser:
+    def __init__(self, name, email, password, role="admin", permissions=None, 
+                 user_id=None, created_at=None, updated_at=None, last_login=None):
+        self.user_id = user_id
+        self.name = name
+        self.email = email
+        self.password = password  # Mật khẩu đã mã hóa
+        self.role = role  # admin, super_admin
+        self.permissions = permissions or self._get_default_permissions(role)
+        self.created_at = created_at or datetime.datetime.now()
+        self.updated_at = updated_at or datetime.datetime.now()
+        self.last_login = last_login
+        self.is_active = True
+
+    def _get_default_permissions(self, role):
+        """Lấy quyền mặc định theo role"""
+        if role == "super_admin":
+            return {
+                "users": {"read": True, "write": True, "delete": True},
+                "documents": {"read": True, "write": True, "delete": True},
+                "conversations": {"read": True, "write": True, "delete": True},
+                "system": {"read": True, "write": True, "delete": True},
+                "analytics": {"read": True, "write": True, "delete": True}
+            }
+        elif role == "admin":
+            return {
+                "users": {"read": True, "write": True, "delete": False},
+                "documents": {"read": True, "write": True, "delete": True},
+                "conversations": {"read": True, "write": False, "delete": True},
+                "system": {"read": True, "write": False, "delete": False},
+                "analytics": {"read": True, "write": False, "delete": False}
+            }
+        else:
+            return {}
+
+    @staticmethod
+    def hash_password(password):
+        """Mã hóa mật khẩu sử dụng bcrypt"""
+        salt = bcrypt.gensalt()
+        hashed_pw = bcrypt.hashpw(password.encode('utf-8'), salt)
+        return hashed_pw
+
+    @staticmethod
+    def check_password(hashed_password, password):
+        """Kiểm tra mật khẩu"""
+        return bcrypt.checkpw(password.encode('utf-8'), hashed_password)
+
+    def to_dict(self):
+        """Chuyển đổi thông tin admin thành dictionary"""
+        admin_dict = {
+            "name": self.name,
+            "email": self.email,
+            "password": self.password,
+            "role": self.role,
+            "permissions": self.permissions,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "last_login": self.last_login,
+            "is_active": self.is_active
+        }
+        if self.user_id:
+            admin_dict["_id"] = self.user_id
+        return admin_dict
+
+    @classmethod
+    def from_dict(cls, admin_dict):
+        """Tạo đối tượng AdminUser từ dictionary"""
+        if not admin_dict:
+            return None
+            
+        return cls(
+            user_id=admin_dict.get("_id"),
+            name=admin_dict.get("name"),
+            email=admin_dict.get("email"),
+            password=admin_dict.get("password"),
+            role=admin_dict.get("role", "admin"),
+            permissions=admin_dict.get("permissions"),
+            created_at=admin_dict.get("created_at"),
+            updated_at=admin_dict.get("updated_at"),
+            last_login=admin_dict.get("last_login")
+        )
+
+    @classmethod
+    def find_by_email(cls, email):
+        """Tìm admin theo email"""
+        try:
+            db = get_db()
+            admins_collection = db.admins
+            admin_data = admins_collection.find_one({"email": email, "is_active": True})
+            return cls.from_dict(admin_data)
+        except Exception as e:
+            logger.error(f"Lỗi tìm admin theo email: {e}")
+            return None
+
+    @classmethod
+    def find_by_id(cls, user_id):
+        """Tìm admin theo ID"""
+        try:
+            db = get_db()
+            admins_collection = db.admins
+            admin_data = admins_collection.find_one({"_id": ObjectId(user_id), "is_active": True})
+            return cls.from_dict(admin_data)
+        except Exception as e:
+            logger.error(f"Lỗi tìm admin theo ID: {e}")
+            return None
+
+    @classmethod
+    def get_all(cls, page=1, per_page=10):
+        """Lấy danh sách tất cả admin với phân trang"""
+        try:
+            db = get_db()
+            admins_collection = db.admins
+            
+            skip = (page - 1) * per_page
+            admins_data = admins_collection.find(
+                {"is_active": True}
+            ).sort("created_at", -1).skip(skip).limit(per_page)
+            
+            total = admins_collection.count_documents({"is_active": True})
+            
+            return [cls.from_dict(admin) for admin in admins_data], total
+        except Exception as e:
+            logger.error(f"Lỗi lấy danh sách admin: {e}")
+            return [], 0
+
+    def save(self):
+        """Lưu thông tin admin vào database"""
+        try:
+            db = get_db()
+            admins_collection = db.admins
+            
+            if not self.user_id:
+                # Đây là admin mới
+                insert_result = admins_collection.insert_one(self.to_dict())
+                self.user_id = insert_result.inserted_id
+                logger.info(f"Đã tạo admin mới với ID: {self.user_id}")
+                return self.user_id
+            else:
+                # Cập nhật admin đã tồn tại
+                self.updated_at = datetime.datetime.now()
+                admins_collection.update_one(
+                    {"_id": self.user_id}, 
+                    {"$set": self.to_dict()}
+                )
+                logger.info(f"Đã cập nhật thông tin admin: {self.user_id}")
+                return self.user_id
+        except Exception as e:
+            logger.error(f"Lỗi khi lưu thông tin admin: {e}")
+            raise
+
+    def update_last_login(self):
+        """Cập nhật thời gian đăng nhập cuối"""
+        try:
+            self.last_login = datetime.datetime.now()
+            self.save()
+        except Exception as e:
+            logger.error(f"Lỗi cập nhật last_login: {e}")
+
+    def has_permission(self, resource, action):
+        """Kiểm tra quyền truy cập"""
+        if not self.permissions:
+            return False
+        
+        resource_perms = self.permissions.get(resource, {})
+        return resource_perms.get(action, False)
+
+    def delete(self):
+        """Xóa mềm admin (đánh dấu is_active = False)"""
+        try:
+            self.is_active = False
+            self.save()
+            logger.info(f"Đã xóa admin: {self.user_id}")
+            return True
+        except Exception as e:
+            logger.error(f"Lỗi khi xóa admin: {e}")
+            return False
+
+    @staticmethod
+    def login(email, password):
+        """Đăng nhập admin"""
+        try:
+            if not email or not password:
+                return False, "Vui lòng nhập đầy đủ thông tin đăng nhập"
+            
+            admin = AdminUser.find_by_email(email)
+            if not admin:
+                return False, "Email không tồn tại hoặc không có quyền admin"
+            
+            if not AdminUser.check_password(admin.password, password):
+                return False, "Mật khẩu không chính xác"
+            
+            # Cập nhật thời gian đăng nhập
+            admin.update_last_login()
+            
+            return True, admin
+        except Exception as e:
+            logger.error(f"Lỗi đăng nhập admin: {e}")
+            return False, f"Lỗi đăng nhập: {str(e)}"
+
+    @staticmethod
+    def create_admin(name, email, password, role="admin", permissions=None):
+        """Tạo admin mới"""
+        try:
+            # Kiểm tra email đã tồn tại chưa
+            existing_admin = AdminUser.find_by_email(email)
+            if existing_admin:
+                return False, "Email đã được sử dụng"
+            
+            # Mã hóa mật khẩu
+            hashed_password = AdminUser.hash_password(password)
+            
+            # Tạo admin mới
+            new_admin = AdminUser(
+                name=name,
+                email=email,
+                password=hashed_password,
+                role=role,
+                permissions=permissions
+            )
+            
+            # Lưu vào database
+            admin_id = new_admin.save()
+            
+            return True, {"admin_id": str(admin_id)}
+        except Exception as e:
+            logger.error(f"Lỗi tạo admin: {e}")
+            return False, f"Lỗi tạo admin: {str(e)}"
+
+    @staticmethod
+    def create_default_super_admin():
+        """Tạo super admin mặc định nếu chưa có"""
+        try:
+            db = get_db()
+            admins_collection = db.admins
+            
+            # Kiểm tra xem đã có super admin chưa
+            existing_super_admin = admins_collection.find_one({
+                "role": "super_admin", 
+                "is_active": True
+            })
+            
+            if not existing_super_admin:
+                # Tạo super admin mặc định
+                default_email = "[email protected]"
+                default_password = "NutribotAdmin2024!"
+                
+                success, result = AdminUser.create_admin(
+                    name="Super Admin",
+                    email=default_email,
+                    password=default_password,
+                    role="super_admin"
+                )
+                
+                if success:
+                    logger.info(f"Đã tạo super admin mặc định: {default_email}")
+                    logger.info(f"Mật khẩu mặc định: {default_password}")
+                    return True, {
+                        "email": default_email,
+                        "password": default_password,
+                        "admin_id": result["admin_id"]
+                    }
+                else:
+                    logger.error(f"Lỗi tạo super admin mặc định: {result}")
+                    return False, result
+            else:
+                logger.info("Super admin đã tồn tại")
+                return True, {"message": "Super admin đã tồn tại"}
+                
+        except Exception as e:
+            logger.error(f"Lỗi tạo super admin mặc định: {e}")
+            return False, str(e)

models/conversation_model.py

@@ -0,0 +1,731 @@
+import os
+import datetime
+from bson.objectid import ObjectId
+import logging
+from pymongo import MongoClient, DESCENDING
+from dotenv import load_dotenv
+import copy
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+# Tải biến môi trường
+load_dotenv()
+
+# Kết nối MongoDB
+MONGO_URI = os.getenv("MONGO_URI", "mongodb://localhost:27017/")
+DATABASE_NAME = os.getenv("MONGO_DB_NAME", "nutribot_db")
+
+# Singleton pattern cho kết nối MongoDB
+_mongo_client = None
+_db = None
+
+def get_db():
+    """Trả về instance của MongoDB database (singleton pattern)"""
+    global _mongo_client, _db
+    if _mongo_client is None:
+        try:
+            _mongo_client = MongoClient(MONGO_URI)
+            _db = _mongo_client[DATABASE_NAME]
+            logger.info(f"Đã kết nối đến database: {DATABASE_NAME}")
+        except Exception as e:
+            logger.error(f"Lỗi kết nối MongoDB: {e}")
+            raise
+    return _db
+
+def safe_isoformat(timestamp_obj):
+    """Safely convert timestamp to isoformat string"""
+    if timestamp_obj is None:
+        return None
+    
+    if isinstance(timestamp_obj, str):
+        return timestamp_obj
+    
+    if hasattr(timestamp_obj, 'isoformat'):
+        return timestamp_obj.isoformat()
+    
+    try:
+        return str(timestamp_obj)
+    except:
+        return None
+
+def safe_datetime(timestamp_obj):
+    """Safely convert various timestamp formats to datetime object"""
+    if timestamp_obj is None:
+        return datetime.datetime.now()
+    
+    if isinstance(timestamp_obj, datetime.datetime):
+        return timestamp_obj
+    
+    if isinstance(timestamp_obj, str):
+        try:
+            return datetime.datetime.fromisoformat(timestamp_obj.replace('Z', '+00:00'))
+        except:
+            return datetime.datetime.now()
+    
+    return datetime.datetime.now()
+
+class Conversation:
+    def __init__(self, user_id=None, title="Cuộc trò chuyện mới", age_context=None,
+                 created_at=None, updated_at=None, is_archived=False, messages=None,
+                 conversation_id=None):
+        self.conversation_id = conversation_id
+        self.user_id = user_id
+        self.title = title
+        self.age_context = age_context
+        self.created_at = safe_datetime(created_at)
+        self.updated_at = safe_datetime(updated_at)
+        self.is_archived = is_archived
+        self.messages = messages or []
+
+    @classmethod
+    def create(cls, user_id, title="Cuộc trò chuyện mới", age_context=None):
+        """Tạo và lưu conversation mới vào database"""
+        try:
+            if isinstance(user_id, str):
+                user_id = ObjectId(user_id)
+            
+            conversation = cls(
+                user_id=user_id,
+                title=title,
+                age_context=age_context
+            )
+            
+            conversation_id = conversation.save()
+            conversation.conversation_id = conversation_id
+            
+            logger.info(f"Created new conversation: {conversation_id}")
+            return conversation_id
+            
+        except Exception as e:
+            logger.error(f"Error creating conversation: {e}")
+            raise
+
+    def serialize_message_for_following(self, message):
+        """Serialize message để lưu vào following_messages"""
+        serialized = {
+            "role": message["role"],
+            "content": message["content"],
+            "timestamp": safe_datetime(message.get("timestamp")),
+            "current_version": message.get("current_version", 1),
+            "is_edited": message.get("is_edited", False)
+        }
+        
+        if "sources" in message:
+            serialized["sources"] = message["sources"]
+        if "metadata" in message:
+            serialized["metadata"] = message["metadata"]
+        
+        # Serialize versions
+        if "versions" in message and message["versions"]:
+            serialized["versions"] = []
+            for version in message["versions"]:
+                version_data = {
+                    "version": version["version"],
+                    "content": version["content"],
+                    "timestamp": safe_datetime(version.get("timestamp")),
+                    "following_messages": version.get("following_messages", [])
+                }
+                if "sources" in version:
+                    version_data["sources"] = version["sources"]
+                if "metadata" in version:
+                    version_data["metadata"] = version["metadata"]
+                serialized["versions"].append(version_data)
+        
+        return serialized
+
+    def deserialize_message_from_following(self, serialized_message):
+        """Deserialize message từ following_messages"""
+        message = {
+            "_id": ObjectId(),
+            "role": serialized_message["role"],
+            "content": serialized_message["content"],
+            "timestamp": safe_datetime(serialized_message.get("timestamp")),
+            "current_version": serialized_message.get("current_version", 1),
+            "is_edited": serialized_message.get("is_edited", False)
+        }
+        
+        if "sources" in serialized_message:
+            message["sources"] = serialized_message["sources"]
+        if "metadata" in serialized_message:
+            message["metadata"] = serialized_message["metadata"]
+        
+        # Deserialize versions
+        if "versions" in serialized_message and serialized_message["versions"]:
+            message["versions"] = []
+            for version_data in serialized_message["versions"]:
+                version = {
+                    "version": version_data["version"],
+                    "content": version_data["content"],
+                    "timestamp": safe_datetime(version_data.get("timestamp")),
+                    "following_messages": version_data.get("following_messages", [])
+                }
+                if "sources" in version_data:
+                    version["sources"] = version_data["sources"]
+                if "metadata" in version_data:
+                    version["metadata"] = version_data["metadata"]
+                message["versions"].append(version)
+        else:
+            # Tạo version mặc định
+            message["versions"] = [{
+                "version": 1,
+                "content": message["content"],
+                "timestamp": message["timestamp"],
+                "following_messages": []
+            }]
+            if "sources" in message:
+                message["versions"][0]["sources"] = message["sources"]
+            if "metadata" in message:
+                message["versions"][0]["metadata"] = message["metadata"]
+        
+        return message
+
+    def capture_following_messages(self, from_message_index):
+        """Capture tất cả messages sau from_message_index"""
+        following_messages = []
+        
+        for i in range(from_message_index + 1, len(self.messages)):
+            message = self.messages[i]
+            serialized = self.serialize_message_for_following(message)
+            following_messages.append(serialized)
+        
+        logger.info(f"Captured {len(following_messages)} following messages from index {from_message_index}")
+        return following_messages
+
+    def restore_following_messages(self, target_message_index, following_messages):
+        """Restore following messages sau target_message_index"""
+        # Cắt conversation tại target message
+        self.messages = self.messages[:target_message_index + 1]
+        
+        # Restore messages
+        restored_count = 0
+        for serialized_message in following_messages:
+            message = self.deserialize_message_from_following(serialized_message)
+            self.messages.append(message)
+            restored_count += 1
+        
+        logger.info(f"Restored {restored_count} following messages after index {target_message_index}")
+        return restored_count
+
+    def to_dict(self):
+        """Convert conversation object sang dictionary cho JSON serialization"""
+        try:
+            result = {
+                "id": str(self.conversation_id),
+                "user_id": str(self.user_id),
+                "title": self.title,
+                "age_context": self.age_context,
+                "created_at": self.created_at.isoformat() if self.created_at else None,
+                "updated_at": self.updated_at.isoformat() if self.updated_at else None,
+                "is_archived": self.is_archived,
+                "messages": []
+            }
+
+            for message in self.messages:
+                timestamp_str = None
+                if "timestamp" in message:
+                    if hasattr(message["timestamp"], 'isoformat'):
+                        timestamp_str = message["timestamp"].isoformat()
+                    else:
+                        timestamp_str = str(message["timestamp"])
+                
+                message_data = {
+                    "id": str(message["_id"]),
+                    "_id": str(message["_id"]),
+                    "role": message["role"],
+                    "content": message["content"],
+                    "timestamp": timestamp_str,
+                    "current_version": message.get("current_version", 1),
+                    "is_edited": message.get("is_edited", False)
+                }
+                
+                if "versions" in message and message["versions"]:
+                    message_data["versions"] = []
+                    for version in message["versions"]:
+                        version_timestamp = None
+                        if "timestamp" in version:
+                            if hasattr(version["timestamp"], 'isoformat'):
+                                version_timestamp = version["timestamp"].isoformat()
+                            else:
+                                version_timestamp = str(version["timestamp"])
+                        
+                        version_data = {
+                            "content": version["content"],
+                            "timestamp": version_timestamp,
+                            "version": version["version"]
+                        }
+                        if "sources" in version:
+                            version_data["sources"] = version["sources"]
+                        message_data["versions"].append(version_data)
+                
+                if "sources" in message:
+                    message_data["sources"] = message["sources"]
+                
+                result["messages"].append(message_data)
+
+            return result
+        except Exception as e:
+            logger.error(f"Lỗi khi convert conversation to dict: {e}")
+            return None
+
+    @classmethod
+    def from_dict(cls, conversation_dict):
+        """Tạo đối tượng Conversation từ dictionary"""
+        if not conversation_dict:
+            return None
+            
+        return cls(
+            conversation_id=conversation_dict.get("_id"),
+            user_id=conversation_dict.get("user_id"),
+            title=conversation_dict.get("title"),
+            age_context=conversation_dict.get("age_context"),
+            created_at=conversation_dict.get("created_at"),
+            updated_at=conversation_dict.get("updated_at"),
+            is_archived=conversation_dict.get("is_archived", False),
+            messages=conversation_dict.get("messages", [])
+        )
+
+    def save(self):
+        """Lưu thông tin cuộc hội thoại vào database"""
+        try:
+            db = get_db()
+            conversations_collection = db.conversations
+            
+            self.updated_at = datetime.datetime.now()
+            
+            save_dict = {
+                "user_id": self.user_id,
+                "title": self.title,
+                "age_context": self.age_context,
+                "created_at": self.created_at,
+                "updated_at": self.updated_at,
+                "is_archived": self.is_archived,
+                "messages": []
+            }
+            
+            for message in self.messages:
+                message_copy = message.copy()
+                message_copy["timestamp"] = safe_datetime(message_copy.get("timestamp"))
+                
+                if "versions" in message_copy:
+                    for version in message_copy["versions"]:
+                        version["timestamp"] = safe_datetime(version.get("timestamp"))
+                
+                save_dict["messages"].append(message_copy)
+            
+            if not self.conversation_id:
+                insert_result = conversations_collection.insert_one(save_dict)
+                self.conversation_id = insert_result.inserted_id
+                logger.info(f"Saved new conversation with ID: {self.conversation_id}")
+                return self.conversation_id
+            else:
+                conversations_collection.update_one(
+                    {"_id": self.conversation_id}, 
+                    {"$set": save_dict}
+                )
+                logger.info(f"Updated conversation: {self.conversation_id}")
+                return self.conversation_id
+        except Exception as e:
+            logger.error(f"Error saving conversation: {e}")
+            raise
+
+    def add_message(self, role, content, sources=None, metadata=None, parent_message_id=None):
+        """Thêm tin nhắn mới vào cuộc hội thoại"""
+        timestamp = datetime.datetime.now()
+        
+        message = {
+            "_id": ObjectId(),
+            "role": role,
+            "content": content,
+            "timestamp": timestamp,
+            "versions": [{
+                "content": content,
+                "timestamp": timestamp,
+                "version": 1,
+                "following_messages": []
+            }],
+            "current_version": 1,
+            "parent_message_id": parent_message_id,
+            "is_edited": False
+        }
+        
+        if sources:
+            message["sources"] = sources
+            message["versions"][0]["sources"] = sources
+            
+        if metadata:
+            message["metadata"] = metadata
+            message["versions"][0]["metadata"] = metadata
+
+        self.messages.append(message)
+        self.updated_at = timestamp
+        self.save()
+        
+        logger.info(f"Added message to conversation {self.conversation_id}")
+        return message["_id"]
+
+    def edit_message(self, message_id, new_content):
+        """Chỉnh sửa tin nhắn và lưu following messages vào version hiện tại"""
+        try:
+            message_index = None
+            for i, message in enumerate(self.messages):
+                if str(message["_id"]) == str(message_id):
+                    message_index = i
+                    break
+            
+            if message_index is None:
+                return False, "Không tìm thấy tin nhắn"
+            
+            message = self.messages[message_index]
+            
+            if message["role"] != "user":
+                return False, "Chỉ có thể chỉnh sửa tin nhắn của người dùng"
+            
+            timestamp = datetime.datetime.now()
+            
+            # Capture following messages cho version hiện tại
+            following_messages = self.capture_following_messages(message_index)
+            
+            # Khởi tạo versions nếu chưa có
+            if "versions" not in message:
+                message["versions"] = [{
+                    "content": message["content"],
+                    "timestamp": safe_datetime(message.get("timestamp", timestamp)),
+                    "version": 1,
+                    "following_messages": following_messages
+                }]
+                if "sources" in message:
+                    message["versions"][0]["sources"] = message["sources"]
+                if "metadata" in message:
+                    message["versions"][0]["metadata"] = message["metadata"]
+            else:
+                # Cập nhật following_messages cho version hiện tại
+                current_version_index = message.get("current_version", 1) - 1
+                if current_version_index < len(message["versions"]):
+                    message["versions"][current_version_index]["following_messages"] = following_messages
+            
+            # Tạo version mới
+            new_version = len(message["versions"]) + 1
+            new_version_data = {
+                "content": new_content,
+                "timestamp": timestamp,
+                "version": new_version,
+                "following_messages": []
+            }
+            
+            message["versions"].append(new_version_data)
+            message["current_version"] = new_version
+            message["content"] = new_content
+            message["is_edited"] = True
+            
+            # Xóa tất cả messages sau message được edit
+            self.messages = self.messages[:message_index + 1]
+            
+            self.updated_at = timestamp
+            self.save()
+            
+            logger.info(f"Edited message {message_id}, created version {new_version} with {len(following_messages)} following messages")
+            return True, "Đã chỉnh sửa tin nhắn thành công"
+            
+        except Exception as e:
+            logger.error(f"Error editing message: {e}")
+            return False, f"Lỗi: {str(e)}"
+
+    def regenerate_bot_response_after_edit(self, user_message_id, new_response, sources=None):
+        """Thêm phản hồi bot mới sau khi edit tin nhắn user"""
+        try:
+            user_message_index = None
+            for i, message in enumerate(self.messages):
+                if str(message["_id"]) == str(user_message_id):
+                    user_message_index = i
+                    break
+            
+            if user_message_index is None:
+                return False, "Không tìm thấy tin nhắn user"
+            
+            timestamp = datetime.datetime.now()
+            bot_message = {
+                "_id": ObjectId(),
+                "role": "bot",
+                "content": new_response,
+                "timestamp": timestamp,
+                "versions": [{
+                    "content": new_response,
+                    "timestamp": timestamp,
+                    "version": 1,
+                    "following_messages": []
+                }],
+                "current_version": 1,
+                "parent_message_id": self.messages[user_message_index]["_id"],
+                "is_edited": False
+            }
+            
+            if sources:
+                bot_message["sources"] = sources
+                bot_message["versions"][0]["sources"] = sources
+            
+            self.messages.append(bot_message)
+            
+            # Cập nhật following_messages cho version hiện tại của user message
+            user_message = self.messages[user_message_index]
+            if "versions" in user_message:
+                current_version_index = user_message.get("current_version", 1) - 1
+                if current_version_index < len(user_message["versions"]):
+                    # Capture lại following messages bao gồm bot response mới
+                    following_messages = self.capture_following_messages(user_message_index)
+                    user_message["versions"][current_version_index]["following_messages"] = following_messages
+            
+            self.updated_at = timestamp
+            self.save()
+            
+            logger.info(f"Added bot response after edit for user message {user_message_id}")
+            return True, "Đã tạo phản hồi mới"
+            
+        except Exception as e:
+            logger.error(f"Error adding bot response: {e}")
+            return False, f"Lỗi: {str(e)}"
+
+    def regenerate_response(self, message_id, new_response, sources=None):
+        """Tạo version mới cho phản hồi bot"""
+        try:
+            message_index = None
+            for i, message in enumerate(self.messages):
+                if str(message["_id"]) == str(message_id):
+                    message_index = i
+                    break
+            
+            if message_index is None:
+                return False, "Không tìm thấy tin nhắn"
+            
+            message = self.messages[message_index]
+            
+            if message["role"] != "bot":
+                return False, "Chỉ có thể regenerate phản hồi của bot"
+            
+            timestamp = datetime.datetime.now()
+            
+            # Capture following messages cho version hiện tại
+            following_messages = self.capture_following_messages(message_index)
+            
+            # Khởi tạo versions nếu chưa có
+            if "versions" not in message:
+                message["versions"] = [{
+                    "content": message["content"],
+                    "timestamp": safe_datetime(message.get("timestamp", timestamp)),
+                    "version": 1,
+                    "sources": message.get("sources", []),
+                    "following_messages": following_messages
+                }]
+                if "metadata" in message:
+                    message["versions"][0]["metadata"] = message["metadata"]
+            else:
+                # Cập nhật following_messages cho version hiện tại
+                current_version_index = message.get("current_version", 1) - 1
+                if current_version_index < len(message["versions"]):
+                    message["versions"][current_version_index]["following_messages"] = following_messages
+            
+            # Tạo version mới
+            new_version = len(message["versions"]) + 1
+            new_version_data = {
+                "content": new_response,
+                "timestamp": timestamp,
+                "version": new_version,
+                "following_messages": []
+            }
+            
+            if sources:
+                new_version_data["sources"] = sources
+            
+            message["versions"].append(new_version_data)
+            message["current_version"] = new_version
+            message["content"] = new_response
+            message["is_edited"] = True
+            
+            if sources:
+                message["sources"] = sources
+            
+            # Xóa tất cả messages sau regenerate message
+            self.messages = self.messages[:message_index + 1]
+            
+            self.updated_at = datetime.datetime.now()
+            self.save()
+            
+            logger.info(f"Regenerated response for message {message_id}, version {new_version} with {len(following_messages)} following messages")
+            return True, "Đã tạo phản hồi mới thành công"
+            
+        except Exception as e:
+            logger.error(f"Error regenerating response: {e}")
+            return False, f"Lỗi: {str(e)}"
+
+    def switch_message_version(self, message_id, version_number):
+        """Chuyển đổi version của tin nhắn và restore following messages"""
+        try:
+            message_index = None
+            for i, message in enumerate(self.messages):
+                if str(message["_id"]) == str(message_id):
+                    message_index = i
+                    break
+            
+            if message_index is None:
+                logger.error(f"Message not found: {message_id}")
+                return False
+            
+            message = self.messages[message_index]
+            
+            if not message.get("versions") or version_number > len(message["versions"]) or version_number < 1:
+                logger.error(f"Version {version_number} not found for message {message_id}")
+                return False
+            
+            current_version = message.get("current_version", 1)
+            logger.info(f"Switching message {message_id} from version {current_version} to version {version_number}")
+            
+            selected_version = message["versions"][version_number - 1]
+            
+            # Update message content to selected version
+            message["current_version"] = version_number
+            message["content"] = selected_version["content"]
+            
+            # Update sources and metadata
+            if "sources" in selected_version:
+                message["sources"] = selected_version["sources"]
+            elif "sources" in message:
+                del message["sources"]
+                    
+            if "metadata" in selected_version:
+                message["metadata"] = selected_version["metadata"]
+            elif "metadata" in message:
+                del message["metadata"]
+            
+            # Restore following messages từ version được chọn
+            following_messages = selected_version.get("following_messages", [])
+            if following_messages:
+                restored_count = self.restore_following_messages(message_index, following_messages)
+                logger.info(f"Restored {restored_count} following messages from version {version_number}")
+            else:
+                # Nếu không có following messages, chỉ cắt conversation tại message này
+                self.messages = self.messages[:message_index + 1]
+                logger.info(f"No following messages in version {version_number}, truncated conversation at message index {message_index}")
+            
+            self.updated_at = datetime.datetime.now()
+            self.save()
+            
+            logger.info(f"Successfully switched to version {version_number} for message {message_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error switching message version: {e}")
+            return False
+
+    def delete_message_and_following(self, message_id):
+        """Xóa tin nhắn và tất cả tin nhắn sau nó"""
+        try:
+            message_index = None
+            for i, message in enumerate(self.messages):
+                if str(message["_id"]) == str(message_id):
+                    message_index = i
+                    break
+            
+            if message_index is None:
+                return False, "Không tìm thấy tin nhắn"
+            
+            self.messages = self.messages[:message_index]
+            self.updated_at = datetime.datetime.now()
+            self.save()
+            
+            return True, "Đã xóa tin nhắn và các tin nhắn sau nó"
+            
+        except Exception as e:
+            logger.error(f"Error deleting message: {e}")
+            return False, f"Lỗi: {str(e)}"
+        
+    def delete(self):
+        """Xóa cuộc hội thoại từ database"""
+        try:
+            if self.conversation_id:
+                db = get_db()
+                conversations_collection = db.conversations
+                conversations_collection.delete_one({"_id": self.conversation_id})
+                logger.info(f"Đã xóa cuộc hội thoại: {self.conversation_id}")
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"Lỗi khi xóa cuộc hội thoại: {e}")
+            return False
+
+    @classmethod
+    def find_by_id(cls, conversation_id):
+        """Tìm cuộc hội thoại theo ID"""
+        try:
+            db = get_db()
+            conversations_collection = db.conversations
+            
+            if isinstance(conversation_id, str):
+                conversation_id = ObjectId(conversation_id)
+                
+            conversation_dict = conversations_collection.find_one({"_id": conversation_id})
+            
+            if conversation_dict:
+                return cls.from_dict(conversation_dict)
+            return None
+        except Exception as e:
+            logger.error(f"Lỗi khi tìm cuộc hội thoại: {e}")
+            return None
+
+    @classmethod
+    def find_by_user(cls, user_id, limit=50, skip=0, include_archived=False):
+        """Tìm cuộc hội thoại theo user_id"""
+        try:
+            db = get_db()
+            conversations_collection = db.conversations
+            
+            if isinstance(user_id, str):
+                user_id = ObjectId(user_id)
+            
+            query_filter = {"user_id": user_id}
+            if not include_archived:
+                query_filter["is_archived"] = {"$ne": True}
+            
+            logger.info(f"Querying conversations with filter: {query_filter}, limit: {limit}, skip: {skip}")
+            
+            conversations_cursor = conversations_collection.find(query_filter)\
+                .sort("updated_at", DESCENDING)\
+                .skip(skip)\
+                .limit(limit)
+            
+            conversations_list = list(conversations_cursor)
+            logger.info(f"Found {len(conversations_list)} conversations for user {user_id}")
+            
+            result = []
+            for conv_dict in conversations_list:
+                conv_obj = cls.from_dict(conv_dict)
+                if conv_obj:
+                    result.append(conv_obj)
+            
+            logger.info(f"Returning {len(result)} conversation objects")
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error finding conversations by user: {e}")
+            return []
+
+    @classmethod
+    def count_by_user(cls, user_id, include_archived=False):
+        """Đếm số cuộc hội thoại của user"""
+        try:
+            db = get_db()
+            conversations_collection = db.conversations
+            
+            if isinstance(user_id, str):
+                user_id = ObjectId(user_id)
+            
+            query_filter = {"user_id": user_id}
+            if not include_archived:
+                query_filter["is_archived"] = {"$ne": True}
+                
+            count = conversations_collection.count_documents(query_filter)
+            logger.info(f"User {user_id} has {count} conversations (include_archived: {include_archived})")
+            
+            return count
+        except Exception as e:
+            logger.error(f"Error counting conversations: {e}")
+            return 0

models/feedback_model.py

@@ -0,0 +1,299 @@
+import os
+import datetime
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import logging
+from dotenv import load_dotenv
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+# Tải biến môi trường
+load_dotenv()
+
+# Kết nối MongoDB
+MONGO_URI = os.getenv("MONGO_URI", "mongodb://localhost:27017/")
+DATABASE_NAME = os.getenv("MONGO_DB_NAME", "nutribot_db")
+
+# Singleton pattern cho kết nối MongoDB
+_mongo_client = None
+_db = None
+
+def get_db():
+    """Trả về instance của MongoDB database (singleton pattern)"""
+    global _mongo_client, _db
+    if _mongo_client is None:
+        try:
+            _mongo_client = MongoClient(MONGO_URI)
+            _db = _mongo_client[DATABASE_NAME]
+            logger.info(f"Đã kết nối đến database: {DATABASE_NAME}")
+        except Exception as e:
+            logger.error(f"Lỗi kết nối MongoDB: {e}")
+            raise
+    return _db
+
+def ensure_indexes():
+    """Tạo các index cần thiết cho feedback collection"""
+    try:
+        db = get_db()
+        feedback_collection = db.feedback
+        
+        # Index cho user_id
+        feedback_collection.create_index("user_id")
+        
+        # Index cho status
+        feedback_collection.create_index("status")
+        
+        # Index cho category
+        feedback_collection.create_index("category")
+        
+        # Index cho created_at (để sắp xếp)
+        feedback_collection.create_index([("created_at", -1)])
+        
+        logger.info("Đã tạo indexes cho feedback collection")
+        
+    except Exception as e:
+        logger.error(f"Lỗi tạo indexes: {e}")
+
+class Feedback:
+    def __init__(self, user_id=None, rating=5, category='', title='', content='',
+                 status='pending', admin_response='', created_at=None, updated_at=None,
+                 feedback_id=None):
+        self.feedback_id = feedback_id
+        self.user_id = user_id
+        self.rating = rating
+        self.category = category
+        self.title = title
+        self.content = content
+        self.status = status  # pending, reviewed, resolved
+        self.admin_response = admin_response
+        self.created_at = created_at or datetime.datetime.now()
+        self.updated_at = updated_at or datetime.datetime.now()
+
+    def to_dict(self):
+        """Chuyển đổi thông tin feedback thành dictionary"""
+        feedback_dict = {
+            "user_id": self.user_id,
+            "rating": self.rating,
+            "category": self.category,
+            "title": self.title,
+            "content": self.content,
+            "status": self.status,
+            "admin_response": self.admin_response,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at
+        }
+        if self.feedback_id:
+            feedback_dict["_id"] = self.feedback_id
+        return feedback_dict
+
+    @classmethod
+    def from_dict(cls, feedback_dict):
+        """Tạo đối tượng Feedback từ dictionary"""
+        if not feedback_dict:
+            return None
+            
+        return cls(
+            feedback_id=feedback_dict.get("_id"),
+            user_id=feedback_dict.get("user_id"),
+            rating=feedback_dict.get("rating", 5),
+            category=feedback_dict.get("category", ""),
+            title=feedback_dict.get("title", ""),
+            content=feedback_dict.get("content", ""),
+            status=feedback_dict.get("status", "pending"),
+            admin_response=feedback_dict.get("admin_response", ""),
+            created_at=feedback_dict.get("created_at"),
+            updated_at=feedback_dict.get("updated_at")
+        )
+
+    def save(self):
+        """Lưu thông tin feedback vào database"""
+        try:
+            db = get_db()
+            feedback_collection = db.feedback
+            
+            self.updated_at = datetime.datetime.now()
+            
+            if not self.feedback_id:
+                insert_result = feedback_collection.insert_one(self.to_dict())
+                self.feedback_id = insert_result.inserted_id
+                logger.info(f"Đã tạo feedback mới với ID: {self.feedback_id}")
+                return self.feedback_id
+            else:
+                feedback_collection.update_one(
+                    {"_id": self.feedback_id}, 
+                    {"$set": self.to_dict()}
+                )
+                logger.info(f"Đã cập nhật feedback: {self.feedback_id}")
+                return self.feedback_id
+        except Exception as e:
+            logger.error(f"Lỗi khi lưu feedback: {e}")
+            raise
+
+    @classmethod
+    def find_by_id(cls, feedback_id):
+        """Tìm feedback theo ID"""
+        try:
+            db = get_db()
+            feedback_collection = db.feedback
+            
+            if isinstance(feedback_id, str):
+                feedback_id = ObjectId(feedback_id)
+                
+            feedback_dict = feedback_collection.find_one({"_id": feedback_id})
+            
+            if feedback_dict:
+                return cls.from_dict(feedback_dict)
+            return None
+        except Exception as e:
+            logger.error(f"Lỗi khi tìm feedback: {e}")
+            return None
+
+    @classmethod
+    def find_by_user(cls, user_id, limit=10, skip=0):
+        """Tìm feedback theo user_id"""
+        try:
+            db = get_db()
+            feedback_collection = db.feedback
+            
+            if isinstance(user_id, str):
+                user_id = ObjectId(user_id)
+            
+            feedbacks_cursor = feedback_collection.find({"user_id": user_id})\
+                .sort("created_at", -1)\
+                .skip(skip)\
+                .limit(limit)
+            
+            result = []
+            for feedback_dict in feedbacks_cursor:
+                feedback_obj = cls.from_dict(feedback_dict)
+                if feedback_obj:
+                    result.append(feedback_obj)
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Lỗi tìm feedback theo user: {e}")
+            return []
+
+    @classmethod
+    def get_all_for_admin(cls, limit=20, skip=0, status_filter=None):
+        """Lấy tất cả feedback cho admin với join user info"""
+        try:
+            db = get_db()
+            feedback_collection = db.feedback
+            
+            # Tạo query filter
+            query_filter = {}
+            if status_filter:
+                query_filter["status"] = status_filter
+            
+            # Aggregate để join với user collection
+            pipeline = [
+                {"$match": query_filter},
+                {
+                    "$lookup": {
+                        "from": "users",
+                        "localField": "user_id",
+                        "foreignField": "_id",
+                        "as": "user_info"
+                    }
+                },
+                {"$sort": {"created_at": -1}},
+                {"$skip": skip},
+                {"$limit": limit}
+            ]
+            
+            result = []
+            for feedback_doc in feedback_collection.aggregate(pipeline):
+                feedback = cls.from_dict(feedback_doc)
+                
+                # Thêm thông tin user nếu có
+                if feedback and feedback_doc.get("user_info"):
+                    user_info = feedback_doc["user_info"][0]
+                    feedback.user_name = user_info.get("name", "Ẩn danh")
+                    feedback.user_email = user_info.get("email", "")
+                else:
+                    feedback.user_name = "Ẩn danh"
+                    feedback.user_email = ""
+                
+                result.append(feedback)
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Lỗi lấy feedback cho admin: {e}")
+            return []
+
+    def update_admin_response(self, response, status):
+        """Cập nhật phản hồi từ admin"""
+        try:
+            self.admin_response = response
+            self.status = status
+            self.save()
+            return True
+        except Exception as e:
+            logger.error(f"Lỗi cập nhật admin response: {e}")
+            return False
+
+    @staticmethod
+    def get_stats():
+        """Lấy thống kê về feedback"""
+        try:
+            db = get_db()
+            feedback_collection = db.feedback
+            
+            # Tổng số feedback
+            total_feedback = feedback_collection.count_documents({})
+            
+            # Feedback pending
+            pending_feedback = feedback_collection.count_documents({"status": "pending"})
+            
+            # Feedback trong tháng này
+            now = datetime.datetime.now()
+            month_start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+            this_month_feedback = feedback_collection.count_documents({
+                "created_at": {"$gte": month_start}
+            })
+            
+            # Đánh giá trung bình
+            pipeline = [
+                {"$group": {"_id": None, "avg_rating": {"$avg": "$rating"}}}
+            ]
+            rating_result = list(feedback_collection.aggregate(pipeline))
+            average_rating = rating_result[0]["avg_rating"] if rating_result else 0
+            
+            return {
+                "total_feedback": total_feedback,
+                "pending_feedback": pending_feedback,
+                "this_month_feedback": this_month_feedback,
+                "average_rating": average_rating
+            }
+            
+        except Exception as e:
+            logger.error(f"Lỗi lấy thống kê feedback: {e}")
+            return {
+                "total_feedback": 0,
+                "pending_feedback": 0,
+                "this_month_feedback": 0,
+                "average_rating": 0
+            }
+
+    @staticmethod
+    def create_feedback(user_id, rating, category, title, content):
+        """Tạo feedback mới"""
+        try:
+            feedback = Feedback(
+                user_id=ObjectId(user_id) if isinstance(user_id, str) else user_id,
+                rating=rating,
+                category=category,
+                title=title,
+                content=content
+            )
+            
+            feedback_id = feedback.save()
+            return True, {"feedback_id": str(feedback_id)}
+            
+        except Exception as e:
+            logger.error(f"Lỗi tạo feedback: {e}")
+            return False, str(e)

models/user_model.py

@@ -0,0 +1,349 @@
+import os
+import datetime
+from pymongo import MongoClient
+from bson.objectid import ObjectId
+import bcrypt
+import logging
+from dotenv import load_dotenv
+
+# Cấu hình logging
+logger = logging.getLogger(__name__)
+
+# Tải biến môi trường
+load_dotenv()
+
+# Kết nối MongoDB
+MONGO_URI = os.getenv("MONGO_URI", "mongodb://localhost:27017/")
+DATABASE_NAME = os.getenv("MONGO_DB_NAME", "nutribot_db")
+
+# Singleton pattern cho kết nối MongoDB
+_mongo_client = None
+_db = None
+
+def get_db():
+    """Trả về instance của MongoDB database (singleton pattern)"""
+    global _mongo_client, _db
+    if _mongo_client is None:
+        try:
+            _mongo_client = MongoClient(MONGO_URI)
+            _db = _mongo_client[DATABASE_NAME]
+            logger.info(f"Đã kết nối đến database: {DATABASE_NAME}")
+        except Exception as e:
+            logger.error(f"Lỗi kết nối MongoDB: {e}")
+            raise
+    return _db
+
+class User:
+    def __init__(self, name, email, password, gender=None, role="user", permissions=None,
+                 user_id=None, created_at=None, updated_at=None, last_login=None):
+        self.user_id = user_id
+        self.name = name
+        self.email = email
+        self.password = password  # Mật khẩu đã mã hóa
+        self.gender = gender
+        self.role = role  # "user" hoặc "admin"
+        self.permissions = permissions or self._get_default_permissions(role)
+        self.created_at = created_at or datetime.datetime.now()
+        self.updated_at = updated_at or datetime.datetime.now()
+        self.last_login = last_login
+
+    def _get_default_permissions(self, role):
+        """Lấy quyền mặc định theo role"""
+        if role == "admin":
+            return {
+                "users": {"read": True, "write": True, "delete": True},
+                "documents": {"read": True, "write": True, "delete": True},
+                "conversations": {"read": True, "write": True, "delete": True},
+                "system": {"read": True, "write": True, "delete": False},
+                "analytics": {"read": True, "write": False, "delete": False}
+            }
+        else:  # role == "user"
+            return {
+                "conversations": {"read": True, "write": True, "delete": True},
+                "profile": {"read": True, "write": True, "delete": False}
+            }
+
+    @staticmethod
+    def hash_password(password):
+        """Mã hóa mật khẩu sử dụng bcrypt"""
+        salt = bcrypt.gensalt()
+        hashed_pw = bcrypt.hashpw(password.encode('utf-8'), salt)
+        return hashed_pw
+
+    @staticmethod
+    def check_password(hashed_password, password):
+        """Kiểm tra mật khẩu"""
+        return bcrypt.checkpw(password.encode('utf-8'), hashed_password)
+
+    def is_admin(self):
+        """Kiểm tra xem user có phải admin không"""
+        return self.role == "admin"
+
+    def has_permission(self, resource, action):
+        """Kiểm tra quyền truy cập"""
+        if not self.permissions:
+            return False
+        
+        resource_perms = self.permissions.get(resource, {})
+        return resource_perms.get(action, False)
+
+    def to_dict(self):
+        """Chuyển đổi thông tin user thành dictionary"""
+        user_dict = {
+            "name": self.name,
+            "email": self.email,
+            "password": self.password,
+            "gender": self.gender,
+            "role": self.role,
+            "permissions": self.permissions,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "last_login": self.last_login
+        }
+        if self.user_id:
+            user_dict["_id"] = self.user_id
+        return user_dict
+
+    @classmethod
+    def from_dict(cls, user_dict):
+        """Tạo đối tượng User từ dictionary"""
+        if not user_dict:
+            return None
+            
+        return cls(
+            user_id=user_dict.get("_id"),
+            name=user_dict.get("name"),
+            email=user_dict.get("email"),
+            password=user_dict.get("password"),
+            gender=user_dict.get("gender"),
+            role=user_dict.get("role", "user"),  # Mặc định là user
+            permissions=user_dict.get("permissions"),
+            created_at=user_dict.get("created_at"),
+            updated_at=user_dict.get("updated_at"),
+            last_login=user_dict.get("last_login")
+        )
+
+    @classmethod
+    def find_by_email(cls, email):
+        """Tìm người dùng theo email"""
+        try:
+            db = get_db()
+            users_collection = db.users
+            user_data = users_collection.find_one({"email": email})
+            return cls.from_dict(user_data)
+        except Exception as e:
+            logger.error(f"Lỗi tìm người dùng theo email: {e}")
+            return None
+
+    @classmethod
+    def find_by_id(cls, user_id):
+        """Tìm người dùng theo ID"""
+        try:
+            db = get_db()
+            users_collection = db.users
+            user_data = users_collection.find_one({"_id": ObjectId(user_id)})
+            return cls.from_dict(user_data)
+        except Exception as e:
+            logger.error(f"Lỗi tìm người dùng theo ID: {e}")
+            return None
+
+    @classmethod
+    def get_all_admins(cls, page=1, per_page=10):
+        """Lấy danh sách tất cả admin với phân trang"""
+        try:
+            db = get_db()
+            users_collection = db.users
+            
+            skip = (page - 1) * per_page
+            admins_data = users_collection.find(
+                {"role": "admin"}
+            ).sort("created_at", -1).skip(skip).limit(per_page)
+            
+            total = users_collection.count_documents({"role": "admin"})
+            
+            return [cls.from_dict(admin) for admin in admins_data], total
+        except Exception as e:
+            logger.error(f"Lỗi lấy danh sách admin: {e}")
+            return [], 0
+
+    def save(self):
+        """Lưu thông tin người dùng vào database"""
+        try:
+            db = get_db()
+            users_collection = db.users
+            
+            if not self.user_id:
+                # Đây là người dùng mới
+                insert_result = users_collection.insert_one(self.to_dict())
+                self.user_id = insert_result.inserted_id
+                logger.info(f"Đã tạo người dùng mới với ID: {self.user_id}")
+                return self.user_id
+            else:
+                # Cập nhật người dùng đã tồn tại
+                self.updated_at = datetime.datetime.now()
+                users_collection.update_one(
+                    {"_id": self.user_id}, 
+                    {"$set": self.to_dict()}
+                )
+                logger.info(f"Đã cập nhật thông tin người dùng: {self.user_id}")
+                return self.user_id
+        except Exception as e:
+            logger.error(f"Lỗi khi lưu thông tin người dùng: {e}")
+            raise
+
+    def update_last_login(self):
+        """Cập nhật thời gian đăng nhập cuối"""
+        try:
+            self.last_login = datetime.datetime.now()
+            self.save()
+        except Exception as e:
+            logger.error(f"Lỗi cập nhật last_login: {e}")
+
+    def delete(self):
+        """Xóa người dùng từ database"""
+        try:
+            if self.user_id:
+                db = get_db()
+                users_collection = db.users
+                users_collection.delete_one({"_id": self.user_id})
+                logger.info(f"Đã xóa người dùng: {self.user_id}")
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"Lỗi khi xóa người dùng: {e}")
+            return False
+
+    @staticmethod
+    def register(name, email, password, gender=None, role="user"):
+        """Đăng ký người dùng mới"""
+        try:
+            # Kiểm tra email đã tồn tại chưa
+            existing_user = User.find_by_email(email)
+            if existing_user:
+                return False, "Email đã được sử dụng"
+            
+            # Mã hóa mật khẩu
+            hashed_password = User.hash_password(password)
+            
+            # Tạo người dùng mới
+            new_user = User(
+                name=name,
+                email=email,
+                password=hashed_password,
+                gender=gender,
+                role=role
+            )
+            
+            # Lưu vào database
+            user_id = new_user.save()
+            
+            return True, {"user_id": str(user_id)}
+        except Exception as e:
+            logger.error(f"Lỗi đăng ký người dùng: {e}")
+            return False, f"Lỗi đăng ký: {str(e)}"
+
+    @staticmethod
+    def login(email, password):
+        """Đăng nhập người dùng"""
+        try:
+            if not email or not password:
+                return False, "Vui lòng nhập đầy đủ thông tin đăng nhập"
+            
+            user = User.find_by_email(email)
+            if not user:
+                return False, "Email không tồn tại"
+            
+            if not User.check_password(user.password, password):
+                return False, "Mật khẩu không chính xác"
+            
+            # Cập nhật thời gian đăng nhập
+            user.update_last_login()
+            
+            return True, user
+        except Exception as e:
+            logger.error(f"Lỗi đăng nhập: {e}")
+            return False, f"Lỗi đăng nhập: {str(e)}"
+
+    @staticmethod
+    def create_admin(name, email, password, gender=None):
+        """Tạo admin mới"""
+        return User.register(name, email, password, gender, role="admin")
+
+    @staticmethod
+    def create_default_admin():
+        """Tạo admin mặc định nếu chưa có"""
+        try:
+            db = get_db()
+            users_collection = db.users
+            
+            # Kiểm tra xem đã có admin chưa
+            existing_admin = users_collection.find_one({"role": "admin"})
+            
+            if not existing_admin:
+                # Tạo admin mặc định
+                default_email = "[email protected]"
+                default_password = "NutribotAdmin2024!"
+                
+                success, result = User.create_admin(
+                    name="Administrator",
+                    email=default_email,
+                    password=default_password
+                )
+                
+                if success:
+                    logger.info(f"Đã tạo admin mặc định: {default_email}")
+                    logger.info(f"Mật khẩu mặc định: {default_password}")
+                    return True, {
+                        "email": default_email,
+                        "password": default_password,
+                        "user_id": result["user_id"]
+                    }
+                else:
+                    logger.error(f"Lỗi tạo admin mặc định: {result}")
+                    return False, result
+            else:
+                logger.info("Admin đã tồn tại")
+                return True, {"message": "Admin đã tồn tại"}
+                
+        except Exception as e:
+            logger.error(f"Lỗi tạo admin mặc định: {e}")
+            return False, str(e)
+
+    @staticmethod
+    def get_stats():
+        """Lấy thống kê về users"""
+        try:
+            db = get_db()
+            users_collection = db.users
+            
+            # Tổng số users
+            total_users = users_collection.count_documents({})
+            
+            # Số admin
+            total_admins = users_collection.count_documents({"role": "admin"})
+            
+            # Users đăng ký hôm nay
+            today_start = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+            new_users_today = users_collection.count_documents({
+                "created_at": {"$gte": today_start}
+            })
+            
+            # Users có hoạt động (có last_login)
+            active_users = users_collection.count_documents({
+                "last_login": {"$exists": True}
+            })
+            
+            return {
+                "total_users": total_users,
+                "total_admins": total_admins,
+                "active_users": active_users,
+                "new_users_today": new_users_today
+            }
+        except Exception as e:
+            logger.error(f"Lỗi lấy thống kê users: {e}")
+            return {
+                "total_users": 0,
+                "total_admins": 0,
+                "active_users": 0,
+                "new_users_today": 0
+            }

scripts/embed_data.py

@@ -0,0 +1,112 @@
+import os
+import sys
+import time
+import argparse
+import logging
+
+# Set UTF-8 encoding cho console
+os.environ['PYTHONIOENCODING'] = 'utf-8'
+
+# Thêm thư mục cha vào sys.path để import các module từ thư mục backend
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from core.data_processor import DataProcessor
+from core.embedding_model import get_embedding_model
+
+# Cấu hình logging với UTF-8
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler("embed_data.log", encoding='utf-8')
+    ]
+)
+logger = logging.getLogger("embed_data")
+
+def embed_all_data(data_dir, force=False):
+    """
+    Embedding tất cả dữ liệu từ thư mục data
+    
+    Args:
+        data_dir: Đường dẫn đến thư mục chứa dữ liệu
+        force: Nếu True, sẽ xóa và tạo lại chỉ mục hiện có
+    """
+    logger.info(f"Bat dau qua trinh embedding du lieu tu {data_dir}")
+    start_time = time.time()
+    
+    # Khởi tạo các components
+    data_processor = DataProcessor(data_dir=data_dir)
+    embedding_model = get_embedding_model()
+    
+    # Kiểm tra xem có chỉ mục hiện có không
+    collection_size = embedding_model.count()
+    if collection_size > 0 and not force:
+        logger.info(f"Da ton tai chi muc voi {collection_size} items")
+        end_time = time.time()
+        logger.info(f"Hoan thanh kiem tra chi muc trong {end_time - start_time:.2f} giay")
+        logger.info("Su dung --force de tao lai chi muc")
+        return
+    
+    # Nếu buộc tạo lại hoặc chưa có chỉ mục, tạo mới
+    if force:
+        logger.info("Xoa chi muc cu va tao lai...")
+        try:
+            embedding_model.chroma_client.delete_collection(name=embedding_model.collection.name)
+            # Tạo lại collection mới
+            embedding_model.collection = embedding_model.chroma_client.create_collection(name=embedding_model.collection.name)
+            logger.info("Da xoa va tao lai collection")
+        except Exception as e:
+            logger.error(f"Loi khi xoa collection: {e}")
+    
+    # Chuẩn bị dữ liệu cho embedding
+    logger.info("Dang chuan bi du lieu cho qua trinh embedding...")
+    all_items = data_processor.prepare_for_embedding()
+    logger.info(f"Da chuan bi {len(all_items)} items de embedding")
+    
+    # Thống kê các loại dữ liệu
+    text_chunks = len([item for item in all_items if item.get("metadata", {}).get("content_type") == "text"])
+    tables = len([item for item in all_items if item.get("metadata", {}).get("content_type") == "table"])
+    figures = len([item for item in all_items if item.get("metadata", {}).get("content_type") == "figure"])
+    
+    logger.info(f"Bao gom: {text_chunks} van ban, {tables} bang bieu, {figures} hinh anh")
+    
+    # Thực hiện embedding
+    logger.info("Bat dau qua trinh embedding...")
+    batch_size = 50  # Batch size phù hợp, tùy chỉnh nếu cần
+    
+    # Chia thành các batch nhỏ để xử lý
+    for i in range(0, len(all_items), batch_size):
+        batch = all_items[i:i + batch_size]
+        logger.info(f"Dang xu ly batch {i//batch_size + 1}/{(len(all_items) + batch_size - 1)//batch_size}, kich thuoc: {len(batch)}")
+        success = embedding_model.index_chunks(batch)
+        if not success:
+            logger.error(f"Loi xu ly batch {i//batch_size + 1}")
+            return
+    
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+    
+    # Kiểm tra kết quả cuối cùng
+    final_count = embedding_model.count()
+    logger.info(f"Hoan thanh qua trinh embedding {final_count} items trong {elapsed_time:.2f} giay")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Embedding du lieu cho he thong Nutribot")
+    parser.add_argument("--data-dir", type=str, default="data", 
+                        help="Duong dan den thu muc chua du lieu (mac dinh: data)")
+    parser.add_argument("--force", action="store_true", 
+                        help="Xoa va tao lai chi muc neu da ton tai")
+    
+    args = parser.parse_args()
+    
+    # Chuẩn hóa đường dẫn
+    data_dir = os.path.abspath(args.data_dir)
+    
+    # Kiểm tra thư mục data có tồn tại không
+    if not os.path.exists(data_dir):
+        logger.error(f"Thu muc {data_dir} khong ton tai!")
+        sys.exit(1)
+    
+    # Thực hiện embedding
+    embed_all_data(data_dir, args.force)

scripts/init_admin.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+Script khởi tạo admin mặc định cho hệ thống Nutribot
+Chạy script này để tạo tài khoản admin đầu tiên
+"""
+
+import os
+import sys
+import logging
+
+# Thêm thư mục cha vào sys.path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from models.user_model import User
+
+# Cấu hình logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+def create_default_admin():
+    """Tạo admin mặc định"""
+    try:
+        print("=" * 50)
+        print("KHỞI TẠO ADMIN NUTRIBOT")
+        print("=" * 50)
+        
+        # Kiểm tra xem đã có admin chưa
+        from models.user_model import get_db
+        db = get_db()
+        existing_admin = db.users.find_one({"role": "admin"})
+        
+        if existing_admin:
+            print("❌ Đã có admin trong hệ thống!")
+            print(f"Admin hiện tại: {existing_admin.get('name')} ({existing_admin.get('email')})")
+            
+            choice = input("\nBạn có muốn tạo admin mới không? (y/N): ").lower().strip()
+            if choice != 'y':
+                print("Hủy bỏ tạo admin.")
+                return
+        
+        # Nhập thông tin admin
+        print("\nNhập thông tin cho admin mới:")
+        
+        name = input("Họ tên: ").strip()
+        if not name:
+            name = "Administrator"
+            print(f"Sử dụng tên mặc định: {name}")
+        
+        email = input("Email: ").strip()
+        if not email:
+            email = "[email protected]"
+            print(f"Sử dụng email mặc định: {email}")
+        
+        # Kiểm tra email đã tồn tại
+        if User.find_by_email(email):
+            print(f"❌ Email {email} đã được sử dụng!")
+            return
+        
+        password = input("Mật khẩu (tối thiểu 6 ký tự): ").strip()
+        if not password or len(password) < 6:
+            password = "Admin123!"
+            print(f"Sử dụng mật khẩu mặc định: {password}")
+        
+        gender = input("Giới tính (male/female/other, có thể bỏ trống): ").strip()
+        if gender and gender not in ['male', 'female', 'other']:
+            gender = None
+        
+        # Tạo admin
+        print("\nĐang tạo admin...")
+        success, result = User.create_admin(name, email, password, gender)
+        
+        if success:
+            print("✅ Tạo admin thành công!")
+            print("\n" + "=" * 50)
+            print("THÔNG TIN ĐĂNG NHẬP ADMIN")
+            print("=" * 50)
+            print(f"Email: {email}")
+            print(f"Mật khẩu: {password}")
+            print(f"Tên: {name}")
+            print(f"ID: {result['user_id']}")
+            print("=" * 50)
+            print("\n⚠️  LƯU Ý:")
+            print("- Hãy ghi nhớ thông tin đăng nhập này")
+            print("- Nên đổi mật khẩu sau lần đăng nhập đầu tiên")
+            print("- Truy cập admin panel tại: http://localhost:5173/admin")
+            print()
+        else:
+            print(f"❌ Lỗi tạo admin: {result}")
+            
+    except Exception as e:
+        logger.error(f"Lỗi tạo admin: {e}")
+        print(f"❌ Có lỗi xảy ra: {e}")
+
+def main():
+    """Hàm main"""
+    try:
+        create_default_admin()
+    except KeyboardInterrupt:
+        print("\n\nĐã hủy bỏ tạo admin.")
+    except Exception as e:
+        print(f"\nLỗi: {e}")
+
+if __name__ == "__main__":
+    main()

testapi.py

@@ -0,0 +1,17 @@
+from openai import OpenAI
+import os
+from dotenv import load_dotenv
+load_dotenv()
+OPENAI_API_KEY=os.getenv("OPENAI_API_KEY")
+client = OpenAI(
+api_key = OPENAI_API_KEY
+)
+completion = client.chat.completions.create(
+  model="gpt-4o-mini",
+  store=True,
+  messages=[
+    {"role": "user", "content": "What is the capital of Vietnam?"}
+  ]
+)
+
+print(completion.choices[0].message)