refactor : refactor all codebase

.gitignore

@@ -36,6 +36,9 @@ backend/.venv/
 backend/__pycache__/
 backend/*.pyc
 
+# Preference folder (development/temporary)
+preference/
+
 # OS
 .DS_Store
 Thumbs.db

backend/Makefile

@@ -3,7 +3,7 @@
 .PHONY: up down restart logs build ps clean setup-nginx monitor-up monitor-down
 
 up:
-	suod docker compose up -d --build
+	sudo docker compose up -d --build
 
 down:
 	docker-compose down

backend/agent/controller.py

@@ -46,47 +46,56 @@ async def chat_controller(
     # Init ConversationManager (Singleton)
     memory = await get_conversation_manager()
 
-    # LOAD HISTORY & Prepare State
+    # LOAD HISTORY & Prepare State (Optimize: history logic remains solid)
     history_dicts = await memory.get_chat_history(user_id, limit=20)
 
-    # Convert to BaseMessage objects
     history = []
     for h in reversed(history_dicts): 
-        if h["is_human"]:
-            history.append(HumanMessage(content=h["message"]))
-        else:
-            history.append(AIMessage(content=h["message"]))
+        msg_cls = HumanMessage if h["is_human"] else AIMessage
+        history.append(msg_cls(content=h["message"]))
 
     initial_state, exec_config = _prepare_execution_context(
         query=query, user_id=user_id, history=history, images=images
     )
+    
     try:
+        # TỐI ƯU: Chạy Graph
         result = await graph.ainvoke(initial_state, config=exec_config)
-        # logger.info(f"Answer result from ai: {result}")
 
-        # take ai message from result
-        final_ai_message = result.get("ai_response")
+        # TỐI ƯU: Extract IDs từ Tool Messages một lần duy nhất
+        all_product_ids = _extract_product_ids(result.get("messages", []))
 
-        # Extract product IDs from tool messages
-        product_ids = _extract_product_ids(result.get("messages", []))
+        # TỐI ƯU: Xử lý AI Response
+        ai_raw_content = result.get("ai_response").content if result.get("ai_response") else ""
+        logger.info(f"💾 [RAW AI OUTPUT]:\n{ai_raw_content}")
 
-        # Save to DB in background after response is sent
+        # Chỉ parse JSON một lần để lấy Explicit IDs từ AI (Nếu có)
+        try:
+            # Vì json_mode=True, OpenAI sẽ nhả raw JSON, không cần regex rườm rà
+            ai_json = json.loads(ai_raw_content)
+            explicit_ids = ai_json.get("product_ids", [])
+            if explicit_ids:
+                all_product_ids = list(set(all_product_ids + explicit_ids))
+        except (json.JSONDecodeError, Exception):
+            # Nếu AI trả về text thường (hiếm khi xảy ra trong JSON mode) thì ignore
+            pass
+
+        # BACKGROUND TASK: Lưu history nhanh gọn
         background_tasks.add_task(
             _handle_post_chat_async,
             memory=memory,
             user_id=user_id,
             human_query=query,
-            ai_msg=final_ai_message,
+            ai_msg=AIMessage(content=ai_raw_content),
         )
 
-        logger.info(f"✅ Request completed for user {user_id} with {len(product_ids)} products")
         return {
-            "ai_response": final_ai_message.content if final_ai_message else "",
-            "product_ids": product_ids,
+            "ai_response": ai_raw_content,
+            "product_ids": all_product_ids,
         }
 
     except Exception as e:
-        logger.error(f"💥 Chat error: {e}", exc_info=True)
+        logger.error(f"💥 Chat error for user {user_id}: {e}", exc_info=True)
         raise
 
 

backend/agent/graph.py

@@ -45,7 +45,7 @@ class CANIFAGraph:
         self.collection_tools = get_collection_tools()  # Vẫn lấy list name để routing
         self.retrieval_tools = self.all_tools
 
-        self.llm_with_tools = self.llm.bind_tools(self.all_tools)
+        self.llm_with_tools = self.llm.bind_tools(self.all_tools, strict=True)
         self.system_prompt = get_system_prompt()
         self.prompt_template = ChatPromptTemplate.from_messages(
             [

backend/agent/tools/customer_info_tool.py

@@ -12,7 +12,7 @@ logger = logging.getLogger(__name__)
 
 
 @tool
-async def collect_customer_info(name: str, phone: str, email: str | None = None) -> str:
+async def collect_customer_info(name: str, phone: str, email: str | None) -> str:
     """
     Sử dụng tool này để ghi lại thông tin khách hàng khi họ muốn tư vấn sâu hơn,
     nhận khuyến mãi hoặc đăng ký mua hàng.

backend/agent/tools/product_search_helpers.py

 import logging
 
-from common.embedding_service import create_embedding
+from common.embedding_service import create_embedding_async
 
 logger = logging.getLogger(__name__)
 
@@ -14,7 +14,7 @@ def _get_where_clauses(params) -> list[str]:
     """Xây dựng danh sách các điều kiện lọc từ params."""
     clauses = []
     clauses.extend(_get_price_clauses(params))
-    clauses.extend(_get_exact_match_clauses(params))
+    clauses.extend(_get_metadata_clauses(params))
     clauses.extend(_get_special_clauses(params))
     return clauses
 
@@ -31,12 +31,23 @@ def _get_price_clauses(params) -> list[str]:
     return clauses
 
 
-def _get_exact_match_clauses(params) -> list[str]:
-    """Các trường lọc chính xác (Exact match)."""
+def _get_metadata_clauses(params) -> list[str]:
+    """Xây dựng điều kiện lọc từ metadata (Phối hợp Exact và Partial)."""
     clauses = []
-    exact_filters = [
+    
+    # 1. Exact Match (Giới tính, Độ tuổi) - Các trường này cần độ chính xác tuyệt đối
+    exact_fields = [
         ("gender_by_product", "gender_by_product"),
         ("age_by_product", "age_by_product"),
+    ]
+    for param_name, col_name in exact_fields:
+        val = getattr(params, param_name, None)
+        if val:
+            clauses.append(f"{col_name} = '{_escape(val)}'")
+
+    # 2. Partial Match (LIKE) - Giúp map text linh hoạt hơn (Chất liệu, Dòng SP, Phong cách...)
+    # Cái này giúp map: "Yarn" -> "Yarn - Sợi", "Knit" -> "Knit - Dệt Kim"
+    partial_fields = [
         ("season", "season"),
         ("material_group", "material_group"),
         ("product_line_vn", "product_line_vn"),
@@ -45,21 +56,24 @@ def _get_exact_match_clauses(params) -> list[str]:
         ("form_neckline", "form_neckline"),
         ("form_sleeve", "form_sleeve"),
     ]
-    for param_name, col_name in exact_filters:
+    for param_name, col_name in partial_fields:
         val = getattr(params, param_name, None)
         if val:
-            clauses.append(f"{col_name} = '{_escape(val)}'")
+            v = _escape(val).lower()
+            # Dùng LOWER + LIKE để cân mọi loại ký tự thừa hoặc hoa/thường
+            clauses.append(f"LOWER({col_name}) LIKE '%{v}%'")
+            
     return clauses
 
 
 def _get_special_clauses(params) -> list[str]:
     """Các trường hợp đặc biệt: Mã sản phẩm, Màu sắc."""
     clauses = []
-    # Mã sản phẩm
-    ref_code = getattr(params, "internal_ref_code", None)
-    if ref_code:
-        r = _escape(ref_code)
-        clauses.append(f"(internal_ref_code = '{r}' OR magento_ref_code = '{r}')")
+    # Mã sản phẩm / SKU
+    m_code = getattr(params, "magento_ref_code", None)
+    if m_code:
+        m = _escape(m_code)
+        clauses.append(f"(magento_ref_code = '{m}' OR internal_ref_code = '{m}')")
 
     # Màu sắc
     color = getattr(params, "master_color", None)
@@ -69,7 +83,7 @@ def _get_special_clauses(params) -> list[str]:
     return clauses
 
 
-def build_starrocks_query(params, query_vector: list[float] | None = None) -> str:
+async def build_starrocks_query(params, query_vector: list[float] | None = None) -> str:
     """
     Build SQL Hybrid tối ưu:
     1. Pre-filtering (Metadata)
@@ -80,7 +94,7 @@ def build_starrocks_query(params, query_vector: list[float] | None = None) -> st
     # --- Process vector in query field ---
     query_text = getattr(params, "query", None)
     if query_text and query_vector is None:
-        query_vector = create_embedding(query_text)
+        query_vector = await create_embedding_async(query_text)
 
     # --- Build filter clauses ---
     where_clauses = _get_where_clauses(params)
@@ -144,7 +158,7 @@ def build_starrocks_query(params, query_vector: list[float] | None = None) -> st
         FROM top_sku_candidates
         GROUP BY internal_ref_code
         ORDER BY max_score DESC
-        LIMIT 5
+        LIMIT 10
         """  # noqa: S608
     else:
         # FALLBACK: Keyword search - MAXIMALLY OPTIMIZED (No CTE overhead)
@@ -181,7 +195,7 @@ def build_starrocks_query(params, query_vector: list[float] | None = None) -> st
         GROUP BY internal_ref_code
         HAVING COUNT(*) > 0
         ORDER BY sale_price ASC
-        LIMIT 5
+        LIMIT 10
         """  # noqa: S608
 
     logger.info(f"📊 Query Mode: {'Vector' if query_vector else 'Keyword'}")

backend/api/test_route.py

+"""
+Test API Routes - Tất cả endpoints cho testing (isolated)
+KHÔNG ĐỘNG VÀO chatbot_route.py chính!
+"""
+
+import asyncio
+import logging
+import random
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from agent.models import QueryRequest
+from common.load_test_manager import get_load_test_manager
+
+router = APIRouter(prefix="/test", tags=["Testing & Load Test"])
+logger = logging.getLogger(__name__)
+
+
+# ==================== MOCK CHAT ENDPOINT ====================
+
+@router.post("/chat-mock", summary="Mock Chat API (for Load Testing)")
+async def mock_chat(req: QueryRequest):
+    """
+    Endpoint MOCK để test performance KHÔNG tốn tiền OpenAI.
+    Trả về response giả lập với latency ngẫu nhiên.
+    
+    ⚠️ CHỈ DÙNG CHO LOAD TESTING!
+    """
+    # Giả lập latency của real API (100-500ms)
+    await asyncio.sleep(random.uniform(0.1, 0.5))
+    
+    # Mock responses
+    mock_responses = [
+        "Dạ em đã tìm được một số mẫu áo sơ mi nam đẹp cho anh/chị ạ. Anh/chị có thể xem các sản phẩm sau đây.",
+        "Em xin gợi ý một số mẫu áo thun nam phù hợp với yêu cầu của anh/chị.",
+        "Dạ, em có tìm thấy một số mẫu quần jean nam trong khoảng giá anh/chị yêu cầu ạ.",
+        "Em xin giới thiệu các mẫu áo khoác nam đang có khuyến mãi tốt ạ.",
+        "Anh/chị có thể tham khảo các mẫu giày thể thao nam đang được ưa chuộng nhất.",
+    ]
+    
+    # Mock product IDs
+    mock_product_ids = [
+        f"MOCK_PROD_{random.randint(1000, 9999)}" 
+        for _ in range(random.randint(2, 5))
+    ]
+    
+    return {
+        "status": "success",
+        "ai_response": random.choice(mock_responses),
+        "product_ids": mock_product_ids,
+        "_mock": True,  # Flag để biết đây là mock response
+        "_latency_ms": random.randint(100, 500)
+    }
+
+
+@router.post("/db-search", summary="DB Search Mock (Test StarRocks Performance)")
+async def mock_db_search(req: QueryRequest):
+    """
+    Endpoint để test PERFORMANCE của StarRocks DB query.
+    Hỗ trợ Multi-Search (Parallel).
+    """
+    from agent.tools.data_retrieval_tool import data_retrieval_tool
+    
+    try:
+        # Mock Multi-Search call (Parallel)
+        tool_result = await data_retrieval_tool.ainvoke({
+            "searches": [
+                {
+                    "keywords": "áo sơ mi",
+                    "gender_by_product": "male",
+                    "price_max": 500000
+                },
+                {
+                    "keywords": "quần jean",
+                    "gender_by_product": "male",
+                    "price_max": 800000
+                }
+            ]
+        })
+        
+        # Parse result
+        import json
+        result_data = json.loads(tool_result)
+        
+        # Collect all product IDs from all search results
+        all_product_ids = []
+        if result_data.get("status") == "success":
+            for res in result_data.get("results", []):
+                ids = [p.get("internal_ref_code", "") for p in res.get("products", [])]
+                all_product_ids.extend(ids)
+        
+        return {
+            "status": "success",
+            "ai_response": "Kết quả Multi-Search Parallel từ DB",
+            "product_ids": list(set(all_product_ids)),
+            "_db_test": True,
+            "_queries_count": len(result_data.get("results", [])),
+            "_total_products": len(all_product_ids)
+        }
+        
+    except Exception as e:
+        logger.error(f"DB multi-search error: {e}")
+        return {
+            "status": "error",
+            "ai_response": f"Lỗi: {str(e)}",
+            "product_ids": [],
+            "_error": str(e)
+        }
+
+
+# ==================== LOAD TEST CONTROL ====================
+
+class StartTestRequest(BaseModel):
+    """Request body để start test"""
+    target_url: str = Field(default="http://localhost:5000", description="Base URL của target")
+    num_users: int = Field(default=10, ge=1, le=1000, description="Số lượng concurrent users")
+    spawn_rate: int = Field(default=2, ge=1, le=100, description="Tốc độ spawn users (users/second)")
+    duration_seconds: int = Field(default=60, ge=10, le=600, description="Thời gian chạy test (giây)")
+    test_type: str = Field(default="chat_mock", description="chat_mock | chat_real | history")
+
+
+@router.post("/loadtest/start", summary="Bắt đầu Load Test")
+async def start_load_test(req: StartTestRequest):
+    """
+    Bắt đầu load test với config được chỉ định.
+    
+    **test_type options:**
+    - `chat_mock`: Test mock chat API (KHÔNG tốn tiền) ⭐ Khuyên dùng
+    - `chat_real`: Test real chat API (TỐN TIỀN OpenAI!)
+    - `history`: Test history API (không tốn tiền LLM)
+    """
+    try:
+        manager = get_load_test_manager()
+        
+        config_dict = req.model_dump()
+        result = manager.start_test(config_dict)
+        
+        if "error" in result:
+            raise HTTPException(status_code=400, detail=result["error"])
+        
+        return {
+            "status": "success",
+            "message": "Load test started",
+            "data": result
+        }
+    
+    except Exception as e:
+        logger.error(f"Error starting load test: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/loadtest/stop", summary="Dừng Load Test")
+async def stop_load_test():
+    """Dừng load test đang chạy"""
+    try:
+        manager = get_load_test_manager()
+        result = manager.stop_test()
+        
+        if "error" in result:
+            raise HTTPException(status_code=400, detail=result["error"])
+        
+        return {
+            "status": "success",
+            "message": "Load test stopped",
+            "data": result
+        }
+    
+    except Exception as e:
+        logger.error(f"Error stopping load test: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/loadtest/metrics", summary="Lấy Metrics Realtime")
+async def get_load_test_metrics():
+    """
+    Lấy metrics realtime của load test.
+    Frontend poll endpoint này mỗi 2 giây.
+    """
+    try:
+        manager = get_load_test_manager()
+        metrics = manager.get_metrics()
+        
+        return {
+            "status": "success",
+            "data": metrics
+        }
+    
+    except Exception as e:
+        logger.error(f"Error getting metrics: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/loadtest/status", summary="Check Test Status")
+async def get_load_test_status():
+    """Check xem load test có đang chạy không"""
+    try:
+        manager = get_load_test_manager()
+        
+        return {
+            "status": "success",
+            "data": {
+                "is_running": manager.is_running(),
+                "current_status": manager.status
+            }
+        }
+    
+    except Exception as e:
+        logger.error(f"Error getting status: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

backend/common/llm_factory.py

@@ -64,27 +64,10 @@ class LLMFactory:
         json_mode: bool = False,
         api_key: str | None = None,
     ) -> BaseChatModel:
-        """
-        Create and cache a new OpenAI LLM instance.
-
-        Args:
-            model_name: Clean model identifier
-            streaming: Enable streaming
-            json_mode: Enable JSON mode
-            api_key: Optional API key override
-
-        Returns:
-            Configured LLM instance
-
-        Raises:
-            ValueError: If API key is missing
-        """
+        """Create and cache a new OpenAI LLM instance."""
         try:
-            llm = self._create_openai(model_name, streaming, api_key)
-
-            if json_mode:
-                llm = self._enable_json_mode(llm, model_name)
-
+            llm = self._create_openai(model_name, streaming, json_mode, api_key)
+            
             cache_key = (model_name, streaming, json_mode, api_key)
             self._cache[cache_key] = llm
             return llm
@@ -93,19 +76,26 @@ class LLMFactory:
             logger.error(f"❌ Failed to create model {model_name}: {e}")
             raise
 
-    def _create_openai(self, model_name: str, streaming: bool, api_key: str | None) -> BaseChatModel:
+    def _create_openai(self, model_name: str, streaming: bool, json_mode: bool, api_key: str | None) -> BaseChatModel:
         """Create OpenAI model instance."""
         key = api_key or OPENAI_API_KEY
 
         if not key:
             raise ValueError("OPENAI_API_KEY is required")
 
-        llm = ChatOpenAI(
-            model=model_name,
-            streaming=streaming,
-            api_key=key,
-            temperature=0,
-        )
+        llm_kwargs = {
+            "model": model_name,
+            "streaming": streaming,
+            "api_key": key,
+            "temperature": 0,
+        }
+        
+        # Nếu bật json_mode, tiêm trực tiếp vào constructor
+        if json_mode:
+            llm_kwargs["model_kwargs"] = {"response_format": {"type": "json_object"}}
+            logger.info(f"⚙️ Initializing OpenAI in JSON mode: {model_name}")
+
+        llm = ChatOpenAI(**llm_kwargs)
         logger.info(f"✅ Created OpenAI: {model_name}")
         return llm
 

backend/common/starrocks_connection.py

@@ -4,6 +4,7 @@ Based on chatbot-rsa pattern
 """
 
 import logging
+import asyncio
 from typing import Any
 
 import aiomysql
@@ -109,25 +110,29 @@ class StarRocksConnection:
 
     # Async pool shared
     _shared_pool = None
+    _pool_lock = asyncio.Lock()
 
     async def get_pool(self):
         """
-        Get or create shared async connection pool
+        Get or create shared async connection pool (Thread-safe singleton)
         """
         if StarRocksConnection._shared_pool is None:
-            logger.info(f"🔌 Creating Async Pool to {self.host}:{self.port}...")
-            StarRocksConnection._shared_pool = await aiomysql.create_pool(
-                host=self.host,
-                port=self.port,
-                user=self.user,
-                password=self.password,
-                db=self.database,
-                charset="utf8mb4",
-                cursorclass=aiomysql.DictCursor,
-                minsize=100,
-                maxsize=200,  # Max Ping: Mở 2000 slot - Đủ cân 500k users (với cơ chế pooling)
-                connect_timeout=10,
-            )
+            async with StarRocksConnection._pool_lock:
+                # Double-check inside lock to prevent multiple pools
+                if StarRocksConnection._shared_pool is None:
+                    logger.info(f"🔌 Creating Async Pool to {self.host}:{self.port}...")
+                    StarRocksConnection._shared_pool = await aiomysql.create_pool(
+                        host=self.host,
+                        port=self.port,
+                        user=self.user,
+                        password=self.password,
+                        db=self.database,
+                        charset="utf8mb4",
+                        cursorclass=aiomysql.DictCursor,
+                        minsize=10,   # Sẵn sàng 10 kết nối ngay lập tức (Cực nhanh cho Prod)
+                        maxsize=50,   # Tối đa 50 kết nối (Đủ cân hàng nghìn users, an toàn trên Windows)
+                        connect_timeout=10,
+                    )
         return StarRocksConnection._shared_pool
 
     async def execute_query_async(self, query: str, params: tuple | None = None) -> list[dict[str, Any]]:

backend/config.py

@@ -84,7 +84,7 @@ LANGFUSE_PUBLIC_KEY: str | None = os.getenv("LANGFUSE_PUBLIC_KEY")
 LANGFUSE_BASE_URL: str | None = os.getenv("LANGFUSE_BASE_URL", "https://cloud.langfuse.com")
 
 # ====================== LANGSMITH CONFIGURATION ======================
-LANGSMITH_TRACING = os.getenv("LANGSMITH_TRACING", "true")
+LANGSMITH_TRACING = os.getenv("LANGSMITH_TRACING", "false")
 LANGSMITH_ENDPOINT = os.getenv("LANGSMITH_ENDPOINT", "https://api.smith.langchain.com")
 LANGSMITH_API_KEY = os.getenv("LANGSMITH_API_KEY")
 LANGSMITH_PROJECT = os.getenv("LANGSMITH_PROJECT")

backend/locust/api_server_perf.py

@@ -172,43 +172,44 @@ async def startup_event():
 @app.post("/test/db-search")
 async def test_db_search(request: SearchRequest):
     """
-    Test StarRocks DB Search.
-    KHÔNG GỌI OPENAI - Chỉ test DB.
+    Test StarRocks DB Multi-Search Parallel.
     """
+    import asyncio
     start_time = time.time()
 
     try:
-        params = MockParams(query_text=request.query, limit=request.limit)
-        sql = build_starrocks_query(params)
+        # Giả lập Multi-Search với 2 query song song
+        params1 = MockParams(query_text=request.query)
+        params2 = MockParams(query_text=request.query + " nam") # Truy vấn phái sinh
+
+        # Launch parallel task creation
+        tasks = [build_starrocks_query(params1), build_starrocks_query(params2)]
+        sqls = await asyncio.gather(*tasks)
 
         db = StarRocksConnection()
-        products = await db.execute_query_async(sql)
-
-        # Filter fields
-        limited_products = products[:5]
-        ALLOWED_FIELDS = {
-            "product_name",
-            "sale_price",
-            "original_price",
-            "product_image_url_thumbnail",
-            "product_web_url",
-            "master_color",
-            "product_color_name",
-            "material",
-            "internal_ref_code",
-        }
-        clean_products = [{k: v for k, v in p.items() if k in ALLOWED_FIELDS} for p in limited_products]
+        
+        # Parallel DB fetching
+        db_tasks = [db.execute_query_async(sql) for sql in sqls]
+        results = await asyncio.gather(*db_tasks)
+
+        # Trích xuất và làm sạch dữ liệu
+        ALLOWED_FIELDS = {"product_name", "sale_price", "internal_ref_code", "product_image_url_thumbnail"}
+        all_products = []
+        for products in results:
+            clean = [{k: v for k, v in p.items() if k in ALLOWED_FIELDS} for p in products[:5]]
+            all_products.extend(clean)
 
         process_time = time.time() - start_time
         return {
             "status": "success",
-            "count": len(clean_products),
+            "count": len(all_products),
             "process_time_seconds": round(process_time, 4),
-            "products": clean_products,
+            "products": all_products,
+            "_queries_run": len(sqls)
         }
 
     except Exception as e:
-        logger.error(f"DB Search Error: {e}")
+        logger.error(f"DB Multi-Search Error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 

backend/server.py

@@ -10,6 +10,10 @@ if platform.system() == "Windows":
     print("🔧 Windows detected: Applying SelectorEventLoopPolicy globally...")
     asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
+# Tạm thời tắt LangChain Tracing để tránh lỗi recursion (Đúng ý bro)
+os.environ["LANGCHAIN_TRACING_V2"] = "false"
+os.environ["LANGCHAIN_API_KEY"] = ""
+
 # Sau khi fix xong mới import tiếp
 import logging
 
@@ -21,6 +25,7 @@ from fastapi.staticfiles import StaticFiles  # Import cái này để mount HTML
 # Updated APIs (Import sau cùng để DB nhận cấu hình fix ở trên)
 from api.chatbot_route import router as chatbot_router
 from api.conservation_route import router as conservation_router
+from api.test_route import router as test_router  # ← Test API (isolated)
 from config import PORT
 
 # Configure Logging
@@ -46,6 +51,7 @@ app.add_middleware(
 
 app.include_router(conservation_router)
 app.include_router(chatbot_router, prefix="/api/agent")
+app.include_router(test_router, prefix="/api")  # ← Test routes
 
 # ==========================================
 # 🟢 ĐOẠN MOUNT STATIC HTML CỦA BRO ĐÂY 🟢