Upload 16 files

.gitattributes

@@ -479,3 +479,4 @@ HVU_QA/40k_train.json filter=lfs diff=lfs merge=lfs -text
 40k_train.json filter=lfs diff=lfs merge=lfs -text
 HVU_QA/t5-viet-qg-finetuned/best-model/model.safetensors filter=lfs diff=lfs merge=lfs -text
 HVU_QA/t5-viet-qg-finetuned/best-model/spiece.model filter=lfs diff=lfs merge=lfs -text
+HVU_QA/HVU.png filter=lfs diff=lfs merge=lfs -text

HVU_QA/HVU_QA_end_to_end_guide.ipynb

@@ -0,0 +1,643 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# HVU_QA - Notebook h??ng d?n s? d?ng\n",
+    "\n",
+    "Notebook n?y ???c t?ch th?nh **2 lu?ng r? r?ng**:\n",
+    "- **Ph?n A - Full project**: d?nh cho ng??i t?i to?n b? source code ?? d?ng v? ph?t tri?n ti?p.\n",
+    "- **Ph?n B - Ch?y nhanh b?ng tool**: d?nh cho ng??i ch? d?ng `HVU_QA_tool.py` ho?c `HVU_QA_tool.bat` ?? d?ng runtime v? ch?y m? h?nh sinh c?u h?i.\n",
+    "\n",
+    "Notebook ???c vi?t ?? ch?y t? th? m?c g?c c?a repo `HVU_QA`.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 0. Chu?n b? helper d?ng chung\n",
+    "\n",
+    "Cell d??i ??y s?:\n",
+    "- t?m th? m?c g?c project\n",
+    "- chu?n h?a ???ng d?n `venv`\n",
+    "- cung c?p h?m ch?y l?nh shell t? notebook\n",
+    "- cung c?p h?m ch? server ph?n h?i ?n ??nh\n",
+    "- cung c?p th? m?c demo cho ph?n `Quick tool`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "from __future__ import annotations\n",
+    "\n",
+    "import json\n",
+    "import os\n",
+    "import platform\n",
+    "import shutil\n",
+    "import subprocess\n",
+    "import sys\n",
+    "import time\n",
+    "import urllib.request\n",
+    "from pathlib import Path\n",
+    "\n",
+    "\n",
+    "def find_project_root(start: Path) -> Path:\n",
+    "    current = start.resolve()\n",
+    "    while True:\n",
+    "        markers = [\n",
+    "            current / 'main.py',\n",
+    "            current / 'requirements.txt',\n",
+    "            current / 'backend' / 'app.py',\n",
+    "            current / 'frontend' / 'index.html',\n",
+    "            current / 'HVU_QA_tool.py',\n",
+    "        ]\n",
+    "        if all(marker.exists() for marker in markers):\n",
+    "            return current\n",
+    "        if current.parent == current:\n",
+    "            raise FileNotFoundError('Kh?ng t?m th?y th? m?c g?c c?a project HVU_QA t? notebook hi?n t?i.')\n",
+    "        current = current.parent\n",
+    "\n",
+    "\n",
+    "PROJECT_ROOT = find_project_root(Path.cwd())\n",
+    "os.chdir(PROJECT_ROOT)\n",
+    "\n",
+    "IS_WINDOWS = platform.system().lower().startswith('win')\n",
+    "VENV_DIR = PROJECT_ROOT / 'venv'\n",
+    "VENV_PYTHON = VENV_DIR / ('Scripts/python.exe' if IS_WINDOWS else 'bin/python')\n",
+    "WEB_LOG_FILE = PROJECT_ROOT / 'hvu_qa_web.log'\n",
+    "QUICK_TOOL_DIR = PROJECT_ROOT / '_notebook_quick_tool'\n",
+    "QUICK_TOOL_RUNTIME = QUICK_TOOL_DIR / 'HVU_QA_runtime'\n",
+    "\n",
+    "\n",
+    "def print_title(title: str) -> None:\n",
+    "    print(f'\\n=== {title} ===')\n",
+    "\n",
+    "\n",
+    "def run_command(command: list[str], *, cwd: Path | None = None, env: dict[str, str] | None = None, check: bool = True):\n",
+    "    print_title('Ch?y l?nh')\n",
+    "    print(' '.join(command))\n",
+    "    result = subprocess.run(\n",
+    "        command,\n",
+    "        cwd=str(cwd or PROJECT_ROOT),\n",
+    "        env=env,\n",
+    "        text=True,\n",
+    "        encoding='utf-8',\n",
+    "        capture_output=True,\n",
+    "    )\n",
+    "    if result.stdout:\n",
+    "        print(result.stdout)\n",
+    "    if result.stderr:\n",
+    "        print(result.stderr)\n",
+    "    if check and result.returncode != 0:\n",
+    "        raise RuntimeError(f'L?nh th?t b?i v?i m? l?i {result.returncode}')\n",
+    "    return result\n",
+    "\n",
+    "\n",
+    "def wait_for_json(url: str, timeout: int = 45):\n",
+    "    deadline = time.time() + timeout\n",
+    "    last_error = None\n",
+    "    while time.time() < deadline:\n",
+    "        try:\n",
+    "            with urllib.request.urlopen(url, timeout=3) as response:\n",
+    "                return json.loads(response.read().decode('utf-8'))\n",
+    "        except Exception as exc:  # noqa: BLE001\n",
+    "            last_error = exc\n",
+    "            time.sleep(1)\n",
+    "    raise RuntimeError(f'Kh?ng nh?n ???c ph?n h?i JSON t? {url} sau {timeout} gi?y. L?i cu?i: {last_error}')\n",
+    "\n",
+    "\n",
+    "def read_log_tail(path: Path, lines: int = 40) -> str:\n",
+    "    if not path.exists():\n",
+    "        return '(Ch?a c? log server.)'\n",
+    "    content = path.read_text(encoding='utf-8', errors='ignore').splitlines()\n",
+    "    if not content:\n",
+    "        return '(Log server ?ang tr?ng.)'\n",
+    "    return '\\n'.join(content[-lines:])\n",
+    "\n",
+    "\n",
+    "print_title('Th?ng tin m?i tr??ng')\n",
+    "print('PROJECT_ROOT =', PROJECT_ROOT)\n",
+    "print('Notebook Python =', sys.executable)\n",
+    "print('VENV_PYTHON =', VENV_PYTHON)\n",
+    "print('IS_WINDOWS =', IS_WINDOWS)\n",
+    "print('WEB_LOG_FILE =', WEB_LOG_FILE)\n",
+    "print('QUICK_TOOL_DIR =', QUICK_TOOL_DIR)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Ph?n A - Full project\n",
+    "\n",
+    "Ph?n n?y d?nh cho tr??ng h?p b?n ?? t?i **to?n b? project `HVU_QA`** v? mu?n d?ng ho?c ph?t tri?n ti?p.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A1. Ki?m tra c?u tr?c project\n",
+    "\n",
+    "Cell n?y x?c nh?n nhanh c?c file quan tr?ng ?? c? trong repo.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "important_paths = [\n",
+    "    'main.py',\n",
+    "    'HVU_QA_tool.py',\n",
+    "    'requirements.txt',\n",
+    "    'backend/app.py',\n",
+    "    'backend/__init__.py',\n",
+    "    'frontend/index.html',\n",
+    "    'frontend/app.js',\n",
+    "    'frontend/style.css',\n",
+    "    'generate_question.py',\n",
+    "    'fine_tune_qg.py',\n",
+    "]\n",
+    "\n",
+    "print_title('Ki?m tra file quan tr?ng')\n",
+    "for item in important_paths:\n",
+    "    path = PROJECT_ROOT / item\n",
+    "    print(f'{item:30} ->', 'OK' if path.exists() else 'THI?U')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A2. T?o m?i tr??ng ?o `venv`\n",
+    "\n",
+    "Cell n?y s? t?o `venv` n?u ch?a c?.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "if VENV_PYTHON.exists():\n",
+    "    print('venv ?? t?n t?i:', VENV_DIR)\n",
+    "else:\n",
+    "    run_command([sys.executable, '-m', 'venv', str(VENV_DIR)])\n",
+    "    print('?? t?o xong venv t?i:', VENV_DIR)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A3. C?i dependencies t? `requirements.txt`\n",
+    "\n",
+    "Cell n?y d?ng cho **full project**. N?u b?n ch? d?ng launcher m?t file th? sang **Ph?n B**.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "run_command([str(VENV_PYTHON), '-m', 'pip', 'install', '--upgrade', 'pip'])\n",
+    "run_command([str(VENV_PYTHON), '-m', 'pip', 'install', '-r', str(PROJECT_ROOT / 'requirements.txt')])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A4. T?i ho?c ??ng b? model b?ng `HVU_QA_tool.py`\n",
+    "\n",
+    "Notebook g?i tool ? **ch? ?? full project** ?? ??ng b? model n?u c?n.\n",
+    "\n",
+    "- `BEST_MODEL_ONLY = False`: t?i model g?c theo repo hi?n t?i.\n",
+    "- `BEST_MODEL_ONLY = True`: ch? d?ng khi repo tr?n Hugging Face th?t s? c? th? m?c `best-model`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "BEST_MODEL_ONLY = False\n",
+    "full_project_tool_command = [str(VENV_PYTHON), str(PROJECT_ROOT / 'HVU_QA_tool.py'), '--skip-run']\n",
+    "if BEST_MODEL_ONLY:\n",
+    "    full_project_tool_command.append('--best-model-only')\n",
+    "run_command(full_project_tool_command)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A5. Ki?m tra model local sau khi t?i\n",
+    "\n",
+    "N?u ? b??c tr?n d?ng `BEST_MODEL_ONLY = True`, notebook s? ch? b?t bu?c ki?m tra `best-model`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "model_root = PROJECT_ROOT / 't5-viet-qg-finetuned'\n",
+    "best_model_only = bool(globals().get('BEST_MODEL_ONLY', False))\n",
+    "\n",
+    "root_required_files = [\n",
+    "    model_root / 'config.json',\n",
+    "    model_root / 'generation_config.json',\n",
+    "    model_root / 'model.safetensors',\n",
+    "    model_root / 'tokenizer_config.json',\n",
+    "    model_root / 'special_tokens_map.json',\n",
+    "    model_root / 'spiece.model',\n",
+    "]\n",
+    "\n",
+    "best_required_files = [\n",
+    "    model_root / 'best-model' / 'config.json',\n",
+    "    model_root / 'best-model' / 'generation_config.json',\n",
+    "    model_root / 'best-model' / 'model.safetensors',\n",
+    "    model_root / 'best-model' / 'tokenizer_config.json',\n",
+    "    model_root / 'best-model' / 'special_tokens_map.json',\n",
+    "    model_root / 'best-model' / 'spiece.model',\n",
+    "]\n",
+    "\n",
+    "print_title('Ki?m tra model local')\n",
+    "required_sets = [('best-model', best_required_files)] if best_model_only else [\n",
+    "    ('model g?c', root_required_files),\n",
+    "    ('best-model', best_required_files),\n",
+    "]\n",
+    "\n",
+    "for label, files in required_sets:\n",
+    "    print(f'\\n{label}:')\n",
+    "    for item in files:\n",
+    "        print(item.relative_to(PROJECT_ROOT), '->', 'OK' if item.exists() else 'THI?U')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A6. Ch?y web app b?ng `main.py`\n",
+    "\n",
+    "Cell n?y s? ch?y Flask server ? background, **kh?ng t? m? tr?nh duy?t**, v? ghi log v?o `hvu_qa_web.log`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "WEB_HOST = '127.0.0.1'\n",
+    "WEB_PORT = '5000'\n",
+    "base_url = f'http://{WEB_HOST}:{WEB_PORT}'\n",
+    "\n",
+    "if 'web_process' in globals() and web_process and web_process.poll() is None:\n",
+    "    print('Web app ?ang ch?y r?i. PID =', web_process.pid)\n",
+    "    print('URL =', base_url)\n",
+    "else:\n",
+    "    web_env = os.environ.copy()\n",
+    "    web_env['HVU_HOST'] = WEB_HOST\n",
+    "    web_env['HVU_PORT'] = WEB_PORT\n",
+    "    web_env['HVU_OPEN_BROWSER'] = '0'\n",
+    "\n",
+    "    if WEB_LOG_FILE.exists():\n",
+    "        WEB_LOG_FILE.unlink()\n",
+    "\n",
+    "    with WEB_LOG_FILE.open('w', encoding='utf-8') as log_stream:\n",
+    "        web_process = subprocess.Popen(\n",
+    "            [str(VENV_PYTHON), str(PROJECT_ROOT / 'main.py')],\n",
+    "            cwd=str(PROJECT_ROOT),\n",
+    "            env=web_env,\n",
+    "            stdout=log_stream,\n",
+    "            stderr=subprocess.STDOUT,\n",
+    "        )\n",
+    "\n",
+    "    try:\n",
+    "        info_payload = wait_for_json(base_url + '/api/info', timeout=45)\n",
+    "    except Exception as exc:  # noqa: BLE001\n",
+    "        return_code = web_process.poll()\n",
+    "        raise RuntimeError(\n",
+    "            'Web app kh?ng kh?i ??ng th?nh c?ng. '\n",
+    "            f'returncode={return_code}\\n\\nLog g?n nh?t:\\n{read_log_tail(WEB_LOG_FILE, lines=80)}'\n",
+    "        ) from exc\n",
+    "\n",
+    "    print('?? kh?i ??ng web app. PID =', web_process.pid)\n",
+    "    print('URL =', base_url)\n",
+    "    print('Model ?ang ch?n =', info_payload.get('selected_model_id'))\n",
+    "    print('T?n model hi?n th? =', info_payload.get('model_name'))\n",
+    "    print('Log server =', WEB_LOG_FILE)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A7. G?i th? API backend\n",
+    "\n",
+    "Cell n?y g?i `GET /api/info`, `POST /api/generate`, v? th? `POST /api/model` n?u c? nhi?u h?n m?t model kh? d?ng.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "def http_get_json(url: str):\n",
+    "    with urllib.request.urlopen(url) as response:\n",
+    "        return json.loads(response.read().decode('utf-8'))\n",
+    "\n",
+    "\n",
+    "def http_post_json(url: str, payload: dict):\n",
+    "    data = json.dumps(payload, ensure_ascii=False).encode('utf-8')\n",
+    "    request = urllib.request.Request(url, data=data, headers={'Content-Type': 'application/json'})\n",
+    "    with urllib.request.urlopen(request) as response:\n",
+    "        return json.loads(response.read().decode('utf-8'))\n",
+    "\n",
+    "\n",
+    "info_payload = http_get_json(base_url + '/api/info')\n",
+    "print_title('GET /api/info')\n",
+    "print(json.dumps(info_payload, ensure_ascii=False, indent=2))\n",
+    "\n",
+    "generate_payload = {\n",
+    "    'text': 'C? s? gi?o d?c ??i h?c c? nhi?m v? t? ch?c ??o t?o, nghi?n c?u khoa h?c v? ph?c v? c?ng ??ng.',\n",
+    "    'num_questions': 3,\n",
+    "}\n",
+    "generate_result = http_post_json(base_url + '/api/generate', generate_payload)\n",
+    "print_title('POST /api/generate')\n",
+    "print(json.dumps(generate_result, ensure_ascii=False, indent=2))\n",
+    "\n",
+    "available_models = info_payload.get('available_models', [])\n",
+    "print_title('Danh s?ch model kh? d?ng')\n",
+    "print(json.dumps(available_models, ensure_ascii=False, indent=2))\n",
+    "\n",
+    "if len(available_models) < 2:\n",
+    "    print('Ch? c? m?t model kh? d?ng n?n b? qua b??c chuy?n model.')\n",
+    "else:\n",
+    "    current_model_id = info_payload.get('selected_model_id')\n",
+    "    target_model_id = next(item['id'] for item in available_models if item['id'] != current_model_id)\n",
+    "    switched_payload = http_post_json(base_url + '/api/model', {'model_id': target_model_id})\n",
+    "    print_title('POST /api/model')\n",
+    "    print(json.dumps(switched_payload, ensure_ascii=False, indent=2))\n",
+    "\n",
+    "    restored_payload = http_post_json(base_url + '/api/model', {'model_id': current_model_id})\n",
+    "    print_title('Kh?i ph?c model ban ??u')\n",
+    "    print(json.dumps(restored_payload, ensure_ascii=False, indent=2))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A8. Ch?y `generate_question.py` b?ng CLI\n",
+    "\n",
+    "Cell n?y minh h?a c?ch ch?y CLI tr?c ti?p m? kh?ng c?n m? giao di?n web.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "cli_text = 'C? s? gi?o d?c ??i h?c th?c hi?n ho?t ??ng ??o t?o, nghi?n c?u khoa h?c v? ph?c v? c?ng ??ng theo quy ??nh c?a ph?p lu?t.'\n",
+    "run_command([\n",
+    "    str(VENV_PYTHON),\n",
+    "    str(PROJECT_ROOT / 'generate_question.py'),\n",
+    "    '--text',\n",
+    "    cli_text,\n",
+    "    '--num_questions',\n",
+    "    '3',\n",
+    "    '--output_format',\n",
+    "    'text',\n",
+    "])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A9. Xem l?nh fine-tune m?u\n",
+    "\n",
+    "Fine-tune l? t?c v? n?ng, n?n notebook ch? in l?nh m?u ?? b?n copy khi c?n.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "print_title('Fine-tune tr?n CPU')\n",
+    "print(f'{VENV_PYTHON} fine_tune_qg.py --device cpu --output_dir t5-viet-qg-finetuned-cpu')\n",
+    "\n",
+    "print_title('Fine-tune tr?n GPU')\n",
+    "print(\n",
+    "    f'{VENV_PYTHON} fine_tune_qg.py --device cuda --fp16 --gradient_checkpointing '\n",
+    "    '--output_dir t5-viet-qg-finetuned'\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## A10. D?ng web app\n",
+    "\n",
+    "Khi kh?ng d?ng n?a, h?y ch?y cell n?y ?? d?ng server ?? b?t ? background.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "if 'web_process' in globals() and web_process and web_process.poll() is None:\n",
+    "    web_process.terminate()\n",
+    "    try:\n",
+    "        web_process.wait(timeout=5)\n",
+    "    except subprocess.TimeoutExpired:\n",
+    "        web_process.kill()\n",
+    "        web_process.wait(timeout=5)\n",
+    "    print('?? d?ng web app. PID =', web_process.pid)\n",
+    "else:\n",
+    "    print('Kh?ng c? web app n?o ?ang ch?y.')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Ph?n B - Ch?y nhanh b?ng tool\n",
+    "\n",
+    "Ph?n n?y m? ph?ng ??ng tr??ng h?p **ng??i d?ng ch? c? `HVU_QA_tool.py` ho?c `HVU_QA_tool.bat`** trong m?t th? m?c tr?ng.\n",
+    "\n",
+    "`HVU_QA_tool.py` m?i s?:\n",
+    "- t? nh?n bi?t kh?ng c? full project c?nh n?\n",
+    "- t? d?ng `HVU_QA_runtime/`\n",
+    "- t? t?o virtualenv ri?ng n?u c?n\n",
+    "- t? c?i dependencies runtime\n",
+    "- t? t?i model t? Hugging Face\n",
+    "- t? m? app\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## B1. T?o th? m?c demo ch? ch?a tool\n",
+    "\n",
+    "Cell n?y sao ch?p `HVU_QA_tool.py` v? `HVU_QA_tool.bat` sang m?t th? m?c demo ri?ng.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "if QUICK_TOOL_DIR.exists():\n",
+    "    shutil.rmtree(QUICK_TOOL_DIR)\n",
+    "QUICK_TOOL_DIR.mkdir(parents=True, exist_ok=True)\n",
+    "shutil.copy2(PROJECT_ROOT / 'HVU_QA_tool.py', QUICK_TOOL_DIR / 'HVU_QA_tool.py')\n",
+    "shutil.copy2(PROJECT_ROOT / 'HVU_QA_tool.bat', QUICK_TOOL_DIR / 'HVU_QA_tool.bat')\n",
+    "\n",
+    "print_title('Th? m?c quick tool')\n",
+    "for item in QUICK_TOOL_DIR.iterdir():\n",
+    "    print(item.name)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## B2. D?ng runtime standalone t? m?i file tool\n",
+    "\n",
+    "Cell n?y ch?y `HVU_QA_tool.py` trong th? m?c demo ? ch? ?? `--prepare-runtime-only` ?? ch?ng minh r?ng tool **kh?ng c?n ph? thu?c v?o full project local**.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "run_command([\n",
+    "    str(VENV_PYTHON),\n",
+    "    str(QUICK_TOOL_DIR / 'HVU_QA_tool.py'),\n",
+    "    '--prepare-runtime-only',\n",
+    "], cwd=QUICK_TOOL_DIR)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## B3. Ki?m tra runtime ???c t?o ra\n",
+    "\n",
+    "Cell n?y li?t k? c?c file runtime t?i thi?u m? launcher ?? t? d?ng.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "print_title('C?c file runtime standalone')\n",
+    "for path in sorted(QUICK_TOOL_RUNTIME.rglob('*')):\n",
+    "    if path.is_file():\n",
+    "        print(path.relative_to(QUICK_TOOL_DIR).as_posix())\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## B4. L?nh th?t m? ng??i d?ng cu?i s? ch?y\n",
+    "\n",
+    "Trong th?c t?, ng??i d?ng ch? c?n ??t `HVU_QA_tool.py` ho?c c? c?p `HVU_QA_tool.py` + `HVU_QA_tool.bat` v?o m?t th? m?c r?i ch?y m?t trong c?c l?nh sau.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "print_title('L?nh quick tool')\n",
+    "print('python HVU_QA_tool.py')\n",
+    "print('')\n",
+    "print('Ho?c tr?n Windows: double-click HVU_QA_tool.bat')\n",
+    "print('')\n",
+    "print('Launcher s? t? t?o:')\n",
+    "print('- .hvu_qa_tool_venv/ n?u m?y ch?a ? trong virtualenv')\n",
+    "print('- HVU_QA_runtime/ n?u th? m?c hi?n t?i ch?a c? full project')\n",
+    "print('- t5-viet-qg-finetuned/ trong runtime ?? ch?a model')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## B5. Ch?y th?t ch? ?? quick tool\n",
+    "\n",
+    "Cell d??i ??y ?? **t?y ch?n**. M?c ??nh notebook s? kh?ng ch?y th?t v? b??c n?y c? th? t?i dependencies v? model t? Hugging Face.\n",
+    "\n",
+    "L?u ?:\n",
+    "- `--best-model-only` ch? d?ng ???c khi repo tr?n Hugging Face th?t s? c? `best-model`.\n",
+    "- N?u repo hi?n t?i ch? c? model g?c, launcher s? b?o l?i r? r?ng khi b?n ?p `--best-model-only`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "metadata": {},
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "RUN_QUICK_TOOL_NOW = False\n",
+    "\n",
+    "quick_tool_command = [\n",
+    "    str(VENV_PYTHON),\n",
+    "    str(QUICK_TOOL_DIR / 'HVU_QA_tool.py'),\n",
+    "]\n",
+    "\n",
+    "if RUN_QUICK_TOOL_NOW:\n",
+    "    run_command(quick_tool_command, cwd=QUICK_TOOL_DIR)\n",
+    "else:\n",
+    "    print('B? qua ch?y th?t ?? tr?nh t?i dependency/model ngo?i ? mu?n.')\n",
+    "    print('Khi c?n, h?y ??t RUN_QUICK_TOOL_NOW = True r?i ch?y l?i cell n?y.')\n",
+    "    print('L?nh s? ch?y:')\n",
+    "    print(' '.join(quick_tool_command))\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

HVU_QA/HVU_QA_tool.bat

@@ -0,0 +1,43 @@
+@echo off
+setlocal
+cd /d "%~dp0"
+chcp 65001 >nul 2>&1
+
+echo [HVU_QA_tool] Dang khoi dong launcher...
+echo [HVU_QA_tool] Runtime va virtualenv se duoc tao tu dong neu can.
+echo.
+
+if exist ".\venv\Scripts\python.exe" (
+  call ".\venv\Scripts\python.exe" HVU_QA_tool.py %*
+  set "EXIT_CODE=%ERRORLEVEL%"
+  goto :done
+)
+
+where py >nul 2>&1
+if not errorlevel 1 (
+  call py -3 HVU_QA_tool.py %*
+  set "EXIT_CODE=%ERRORLEVEL%"
+  goto :done
+)
+
+where python >nul 2>&1
+if not errorlevel 1 (
+  call python HVU_QA_tool.py %*
+  set "EXIT_CODE=%ERRORLEVEL%"
+  goto :done
+)
+
+echo Khong tim thay Python tren may.
+echo Hay cai Python 3.11+ hoac tao san venv trong thu muc du an.
+set "EXIT_CODE=1"
+
+:done
+echo.
+if not "%EXIT_CODE%"=="0" (
+  echo [HVU_QA_tool] Co loi xay ra. Ma loi: %EXIT_CODE%
+) else (
+  echo [HVU_QA_tool] Da ket thuc.
+)
+echo.
+pause
+exit /b %EXIT_CODE%

HVU_QA/HVU_QA_tool.py

@@ -0,0 +1,2003 @@
+from __future__ import annotations
+
+import argparse
+import fnmatch
+import importlib.util
+import os
+import shutil
+import subprocess
+import sys
+import textwrap
+from dataclasses import dataclass
+from pathlib import Path
+
+SCRIPT_ROOT = Path(__file__).resolve().parent
+IS_WINDOWS = os.name == "nt"
+TOOL_VENV_DIR = SCRIPT_ROOT / ".hvu_qa_tool_venv"
+TOOL_VENV_PYTHON = TOOL_VENV_DIR / ("Scripts/python.exe" if IS_WINDOWS else "bin/python")
+
+HF_DATASET_REPO_ID = "DANGDOCAO/GeneratingQuestions"
+HF_DATASET_REVISION = "main"
+HF_PROJECT_SUBDIR = "HVU_QA"
+HF_MODEL_SUBDIR = f"{HF_PROJECT_SUBDIR}/t5-viet-qg-finetuned"
+HF_BEST_MODEL_SUBDIR = f"{HF_MODEL_SUBDIR}/best-model"
+
+HF_HUB_REQUIREMENT = "huggingface_hub>=0.23.0,<1.0.0"
+RUNTIME_REQUIREMENTS = [
+    "Flask>=3.0.0,<4.0.0",
+    HF_HUB_REQUIREMENT,
+    "numpy>=1.26.0,<3.0.0",
+    "safetensors>=0.4.3,<1.0.0",
+    "sentencepiece>=0.2.0,<1.0.0",
+    "torch>=2.2.0,<3.0.0",
+    "transformers>=4.41.0,<5.0.0",
+]
+LOCAL_PROJECT_MARKERS = [
+    "main.py",
+    "backend/app.py",
+    "frontend/index.html",
+    "generate_question.py",
+]
+DEPENDENCY_IMPORTS = {
+    "Flask": "flask",
+    "numpy": "numpy",
+    "torch": "torch",
+    "transformers": "transformers",
+    "sentencepiece": "sentencepiece",
+    "safetensors": "safetensors",
+    "huggingface_hub": "huggingface_hub",
+}
+MODEL_IGNORE_PATTERNS = [
+    f"{HF_MODEL_SUBDIR}/checkpoint-*/**",
+    f"{HF_MODEL_SUBDIR}/all_results.json",
+    f"{HF_MODEL_SUBDIR}/eval_results.json",
+    f"{HF_MODEL_SUBDIR}/train_results.json",
+    f"{HF_MODEL_SUBDIR}/trainer_state.json",
+    f"{HF_MODEL_SUBDIR}/training_summary.json",
+    f"{HF_MODEL_SUBDIR}/training_args.bin",
+    f"{HF_BEST_MODEL_SUBDIR}/training_args.bin",
+]
+
+
+@dataclass(frozen=True)
+class RuntimeContext:
+    root: Path
+    main_file: Path
+    requirements_file: Path
+    local_model_dir: Path
+    local_best_model_dir: Path
+    standalone_mode: bool
+
+
+def print_step(message: str) -> None:
+    print(f"[HVU_QA_tool] {message}")
+
+
+def module_exists(module_name: str) -> bool:
+    return importlib.util.find_spec(module_name) is not None
+
+
+def run_command(
+    command: list[str],
+    *,
+    cwd: Path | None = None,
+    env: dict[str, str] | None = None,
+) -> None:
+    subprocess.check_call(command, cwd=str(cwd) if cwd else None, env=env)
+
+
+def is_running_in_virtualenv() -> bool:
+    return sys.prefix != getattr(sys, "base_prefix", sys.prefix) or bool(os.getenv("VIRTUAL_ENV"))
+
+
+def format_bytes(size: int) -> str:
+    units = ["B", "KB", "MB", "GB", "TB"]
+    value = float(size)
+    for unit in units:
+        if value < 1024 or unit == units[-1]:
+            if unit == "B":
+                return f"{int(value)} {unit}"
+            return f"{value:.1f} {unit}"
+        value /= 1024
+    return f"{size} B"
+
+
+def render_progress_bar(current: int, total: int, width: int = 28) -> str:
+    if total <= 0:
+        return "[----------------------------] 0.0%"
+
+    ratio = max(0.0, min(1.0, current / total))
+    filled = int(ratio * width)
+    bar = "#" * filled + "-" * (width - filled)
+    percent = ratio * 100
+    return f"[{bar}] {percent:5.1f}%"
+
+
+def matches_any_pattern(path: str, patterns: list[str]) -> bool:
+    normalized = path.replace("\\", "/")
+    return any(fnmatch.fnmatch(normalized, pattern) for pattern in patterns)
+
+
+def build_allow_patterns(best_model_only: bool) -> list[str]:
+    if best_model_only:
+        return [f"{HF_BEST_MODEL_SUBDIR}/**"]
+    return [f"{HF_MODEL_SUBDIR}/**"]
+
+
+def has_local_project(root: Path) -> bool:
+    return all((root / marker).exists() for marker in LOCAL_PROJECT_MARKERS)
+
+
+def build_runtime_requirements_text() -> str:
+    lines = [
+        "# Runtime dependencies for standalone HVU_QA launcher.",
+        "# Nếu dùng GPU NVIDIA, hãy cài đúng bản torch theo CUDA của máy nếu cần.",
+        *RUNTIME_REQUIREMENTS,
+        "",
+    ]
+    return "\n".join(lines)
+
+
+def build_runtime_file_map() -> dict[str, str]:
+    requirements_text = build_runtime_requirements_text()
+    return {
+        "requirements.txt": requirements_text,
+        "main.py": textwrap.dedent(
+            """
+            from __future__ import annotations
+
+            import os
+            import threading
+            import webbrowser
+
+            from backend import create_app
+
+            app = create_app()
+
+
+            def _as_bool(value: str | None, default: bool) -> bool:
+                if value is None:
+                    return default
+                return value.strip().lower() not in {"0", "false", "no", "off"}
+
+
+            def _open_browser_later(host: str, port: int) -> None:
+                if not _as_bool(os.getenv("HVU_OPEN_BROWSER"), True):
+                    return
+                target_host = "127.0.0.1" if host in {"0.0.0.0", "::"} else host
+                url = f"http://{target_host}:{port}"
+                threading.Timer(1.2, lambda: webbrowser.open(url)).start()
+
+
+            if __name__ == "__main__":
+                host = os.getenv("HVU_HOST", "127.0.0.1")
+                port = int(os.getenv("HVU_PORT", "5000"))
+                debug = _as_bool(os.getenv("HVU_DEBUG"), False)
+                _open_browser_later(host, port)
+                app.run(host=host, port=port, debug=debug, use_reloader=False)
+            """
+        ).strip()
+        + "\n",
+        "backend/__init__.py": 'from .app import create_app\n\n__all__ = ["create_app"]\n',
+        "backend/app.py": textwrap.dedent(
+            """
+            from __future__ import annotations
+
+            import os
+            import time
+            from pathlib import Path
+
+            from flask import Flask, jsonify, request, send_from_directory
+
+            from generate_question import (
+                APP_TITLE,
+                QUESTION_LIMIT,
+                QuestionGenerator,
+                format_questions,
+                normalize_text,
+                parse_question_count,
+                resolve_model_dir,
+            )
+
+            IGNORED_MODEL_DIR_NAMES = {
+                ".git",
+                ".vscode",
+                "__pycache__",
+                "backend",
+                "frontend",
+                "venv",
+                ".hvu_qa_tool_venv",
+                "HVU_QA_runtime",
+            }
+
+
+            def project_root() -> Path:
+                return Path(__file__).resolve().parents[1]
+
+
+            def _read_optional_int(value: str | None) -> int | None:
+                if value in (None, ""):
+                    return None
+                return int(value)
+
+
+            def build_generator(
+                model_dir: str | Path | None = None,
+                prefer_nested_model: bool = True,
+            ) -> QuestionGenerator:
+                root = project_root()
+                selected_model_dir = (
+                    Path(model_dir).expanduser()
+                    if model_dir is not None
+                    else Path(os.getenv("HVU_MODEL_DIR", str(root / "t5-viet-qg-finetuned"))).expanduser()
+                )
+                if not selected_model_dir.is_absolute():
+                    selected_model_dir = root / selected_model_dir
+
+                return QuestionGenerator(
+                    model_dir=str(selected_model_dir),
+                    task_prefix=os.getenv("HVU_TASK_PREFIX", "sinh câu hỏi"),
+                    max_source_length=int(os.getenv("HVU_MAX_SOURCE_LENGTH", "512")),
+                    max_new_tokens=int(os.getenv("HVU_MAX_NEW_TOKENS", "64")),
+                    device=os.getenv("HVU_DEVICE", "auto"),
+                    cpu_threads=_read_optional_int(os.getenv("HVU_CPU_THREADS")),
+                    gpu_dtype=os.getenv("HVU_GPU_DTYPE", "auto"),
+                    prefer_nested_model=prefer_nested_model,
+                )
+
+
+            def _model_label(relative_path: str | Path) -> str:
+                path = Path(relative_path)
+                return path.name or "model"
+
+
+            def _iter_model_candidates(root: Path):
+                for child in sorted(root.iterdir(), key=lambda path: path.name.lower()):
+                    if not child.is_dir() or child.name.startswith(".") or child.name in IGNORED_MODEL_DIR_NAMES:
+                        continue
+
+                    if (child / "config.json").exists():
+                        yield {"path": child, "prefer_nested_model": False}
+
+                    for nested_name in ("best-model", "final-model"):
+                        nested = child / nested_name
+                        if nested.is_dir() and (nested / "config.json").exists():
+                            yield {"path": nested, "prefer_nested_model": False}
+
+
+            def _discover_available_models(
+                root: Path,
+                active_generator: QuestionGenerator | None = None,
+            ) -> list[dict[str, str]]:
+                models: list[dict[str, str]] = []
+                seen_roots: set[str] = set()
+                root = root.resolve()
+
+                for candidate_info in _iter_model_candidates(root):
+                    candidate = candidate_info["path"]
+                    model_key = str(candidate.resolve())
+                    if model_key in seen_roots:
+                        continue
+
+                    try:
+                        relative_candidate = candidate.resolve().relative_to(root)
+                    except ValueError:
+                        continue
+
+                    seen_roots.add(model_key)
+                    models.append(
+                        {
+                            "id": relative_candidate.as_posix(),
+                            "label": _model_label(relative_candidate),
+                            "model_root": str(candidate.resolve()),
+                            "model_dir": str(resolve_model_dir(candidate, prefer_nested_model=False).resolve()),
+                            "prefer_nested_model": bool(candidate_info["prefer_nested_model"]),
+                        }
+                    )
+
+                if active_generator is not None:
+                    current_root = active_generator.model_root.resolve()
+                    current_dir = active_generator.model_dir.resolve()
+                    exists = any(
+                        Path(item["model_root"]).resolve() == current_root
+                        or Path(item["model_dir"]).resolve() == current_dir
+                        for item in models
+                    )
+                    if not exists:
+                        models.append(
+                            {
+                                "id": current_root.as_posix(),
+                                "label": current_root.name,
+                                "model_root": str(current_root),
+                                "model_dir": str(current_dir),
+                                "prefer_nested_model": False,
+                            }
+                        )
+
+                return models
+
+
+            def _selected_model_id(
+                app: Flask,
+                models: list[dict[str, str]],
+                active_generator: QuestionGenerator | None = None,
+            ) -> str:
+                explicit_selection = str(app.config.get("SELECTED_MODEL_ID") or "").strip()
+                if explicit_selection and any(item["id"] == explicit_selection for item in models):
+                    return explicit_selection
+
+                active_generator = active_generator or _generator(app)
+                current_root = active_generator.model_root.resolve()
+                current_dir = active_generator.model_dir.resolve()
+
+                for item in models:
+                    if Path(item["model_dir"]).resolve() == current_dir:
+                        return item["id"]
+
+                for item in models:
+                    if Path(item["model_root"]).resolve() == current_root:
+                        return item["id"]
+
+                return models[0]["id"] if models else ""
+
+
+            def _switch_generator(app: Flask, model_id: str) -> QuestionGenerator:
+                available_models = _discover_available_models(app.config["PROJECT_ROOT"], _generator(app))
+                selected_model = next((item for item in available_models if item["id"] == model_id), None)
+                if selected_model is None:
+                    raise ValueError("Model được chọn không hợp lệ hoặc chưa tồn tại trong thư mục runtime.")
+
+                current_model_id = _selected_model_id(app, available_models)
+                if current_model_id != model_id:
+                    app.config["GENERATOR"] = build_generator(
+                        selected_model["model_root"],
+                        prefer_nested_model=bool(selected_model.get("prefer_nested_model")),
+                    )
+
+                app.config["SELECTED_MODEL_ID"] = model_id
+                return _generator(app)
+
+
+            def _info_payload(app: Flask, active_generator: QuestionGenerator | None = None) -> dict[str, object]:
+                active_generator = active_generator or _generator(app)
+                available_models = _discover_available_models(app.config["PROJECT_ROOT"], active_generator)
+                selected_model_id = _selected_model_id(app, available_models, active_generator)
+                model_name = next(
+                    (item["label"] for item in available_models if item["id"] == selected_model_id),
+                    Path(active_generator.model_dir).name,
+                )
+                return {
+                    "ok": True,
+                    "title": APP_TITLE,
+                    "model_name": model_name,
+                    "selected_model_id": selected_model_id,
+                    "available_models": [{"id": item["id"], "label": item["label"]} for item in available_models],
+                    "meta": active_generator.metadata(),
+                }
+
+
+            def create_app(generator: QuestionGenerator | None = None) -> Flask:
+                root = project_root()
+                frontend_root = root / "frontend"
+
+                app = Flask(__name__, static_folder=None)
+                app.json.ensure_ascii = False
+                app.config["GENERATOR"] = generator or build_generator()
+                app.config["PROJECT_ROOT"] = root
+                app.config["FRONTEND_ROOT"] = frontend_root
+                app.config["SELECTED_MODEL_ID"] = ""
+
+                @app.get("/")
+                def index():
+                    return send_from_directory(app.config["FRONTEND_ROOT"], "index.html")
+
+                @app.get("/frontend/<path:filename>")
+                def frontend_file(filename: str):
+                    return send_from_directory(app.config["FRONTEND_ROOT"], filename)
+
+                @app.get("/api/info")
+                def info():
+                    return jsonify(_info_payload(app))
+
+                @app.post("/api/model")
+                def set_model():
+                    payload = request.get_json(silent=True) or {}
+                    model_id = str(payload.get("model_id") or "").strip()
+                    if not model_id:
+                        return jsonify({"ok": False, "error": "Vui lòng chọn model trước khi chuyển."}), 400
+
+                    try:
+                        active_generator = _switch_generator(app, model_id)
+                    except ValueError as exc:
+                        return jsonify({"ok": False, "error": str(exc)}), 404
+
+                    return jsonify(_info_payload(app, active_generator))
+
+                @app.post("/api/generate")
+                def generate():
+                    payload = request.get_json(silent=True) or {}
+                    requested_model_id = str(payload.get("model_id") or "").strip()
+
+                    if requested_model_id:
+                        try:
+                            active_generator = _switch_generator(app, requested_model_id)
+                        except ValueError as exc:
+                            return jsonify({"ok": False, "error": str(exc)}), 400
+                    else:
+                        active_generator = _generator(app)
+
+                    text = normalize_text(payload.get("text"))
+                    if not text:
+                        return jsonify({"ok": False, "error": "Vui lòng nhập đoạn văn bản trước khi sinh câu hỏi."}), 400
+
+                    raw_count = payload.get("num_questions")
+                    if raw_count in (None, ""):
+                        count = 5
+                    else:
+                        try:
+                            count = int(raw_count)
+                        except (TypeError, ValueError):
+                            return jsonify({"ok": False, "error": "Số câu hỏi phải là số nguyên trong khoảng 1 đến 100."}), 400
+
+                        if count < 1 or count > QUESTION_LIMIT:
+                            return jsonify({"ok": False, "error": f"Số câu hỏi phải nằm trong khoảng 1 đến {QUESTION_LIMIT}."}), 400
+
+                    started = time.perf_counter()
+                    try:
+                        questions = active_generator.generate(text, parse_question_count(count))
+                    except Exception as exc:  # noqa: BLE001
+                        return jsonify({"ok": False, "error": str(exc)}), 500
+
+                    elapsed_ms = round((time.perf_counter() - started) * 1000, 2)
+                    info_payload = _info_payload(app, active_generator)
+                    return jsonify(
+                        {
+                            "ok": True,
+                            "text": text,
+                            "num_questions": count,
+                            "questions": questions,
+                            "formatted": format_questions(questions),
+                            "elapsed_ms": elapsed_ms,
+                            "model_name": info_payload["model_name"],
+                            "selected_model_id": info_payload["selected_model_id"],
+                            "meta": active_generator.metadata(),
+                        }
+                    )
+
+                return app
+
+
+            def _generator(app: Flask) -> QuestionGenerator:
+                generator: QuestionGenerator = app.config["GENERATOR"]
+                return generator
+            """
+        ).strip()
+        + "\n",
+        "generate_question.py": textwrap.dedent(
+            """
+            from __future__ import annotations
+
+            import argparse
+            import json
+            import os
+            import re
+            import sys
+            import threading
+            from pathlib import Path
+            from typing import Any
+
+            os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+            os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+
+
+            def raise_missing_dependency_error(exc: ModuleNotFoundError) -> None:
+                root = Path(__file__).resolve().parent
+                requirements = root / "requirements.txt"
+                message = [
+                    f"Thiếu thư viện Python: {exc.name}",
+                    f"Interpreter hiện tại: {sys.executable}",
+                ]
+                if requirements.exists():
+                    message.extend(
+                        [
+                            "Cài đặt dependencies bằng lệnh:",
+                            f"{sys.executable} -m pip install -r {requirements}",
+                        ]
+                    )
+                raise SystemExit("\\n".join(message)) from exc
+
+
+            try:
+                import torch
+                from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+            except ModuleNotFoundError as exc:
+                raise_missing_dependency_error(exc)
+
+
+            APP_TITLE = "HVU_QA Tool - Sinh câu hỏi"
+            TASK_PREFIX = "sinh câu hỏi"
+            QUESTION_LIMIT = 100
+            GENERATION_PASSES = (
+                (0.9, 0.95, 1, 4),
+                (1.0, 0.97, 1, 5),
+                (1.08, 0.99, 2, 6),
+            )
+
+
+            def normalize_text(text: Any) -> str:
+                return " ".join(str(text or "").split())
+
+
+            def unique_text(items: list[str]) -> list[str]:
+                seen: set[str] = set()
+                output: list[str] = []
+                for item in items:
+                    value = normalize_text(item)
+                    key = value.lower()
+                    if key and key not in seen:
+                        seen.add(key)
+                        output.append(value)
+                return output
+
+
+            def parse_question_count(value: Any, default: int = 5) -> int:
+                try:
+                    parsed = int(value)
+                except (TypeError, ValueError):
+                    parsed = default
+                return max(1, min(parsed, QUESTION_LIMIT))
+
+
+            def format_questions(items: list[str]) -> str:
+                if not items:
+                    return "Không sinh được câu hỏi phù hợp."
+                return "\\n".join(f"{index}. {item}" for index, item in enumerate(items, 1))
+
+
+            def resolve_model_dir(model_dir: str | Path, prefer_nested_model: bool = True) -> Path:
+                model_root = Path(model_dir).expanduser().resolve()
+                nested_candidates = [model_root / "best-model", model_root / "final-model"]
+                candidates = [*nested_candidates, model_root] if prefer_nested_model else [model_root, *nested_candidates]
+                for candidate in candidates:
+                    if candidate.is_dir() and (candidate / "config.json").exists():
+                        return candidate
+                raise FileNotFoundError(f"Không tìm thấy thư mục mô hình hợp lệ: {model_root}")
+
+
+            def parse_dtype(value: str) -> torch.dtype:
+                normalized = value.strip().lower()
+                mapping = {
+                    "float16": torch.float16,
+                    "fp16": torch.float16,
+                    "float32": torch.float32,
+                    "fp32": torch.float32,
+                    "bfloat16": torch.bfloat16,
+                    "bf16": torch.bfloat16,
+                }
+                if normalized not in mapping:
+                    raise ValueError(f"Không hỗ trợ gpu_dtype={value}")
+                return mapping[normalized]
+
+
+            class QuestionGenerator:
+                def __init__(
+                    self,
+                    model_dir: str | Path = "t5-viet-qg-finetuned",
+                    task_prefix: str = TASK_PREFIX,
+                    max_source_length: int = 512,
+                    max_new_tokens: int = 64,
+                    device: str = "auto",
+                    cpu_threads: int | None = None,
+                    gpu_dtype: str = "auto",
+                    prefer_nested_model: bool = True,
+                ) -> None:
+                    self.model_root = Path(model_dir).expanduser().resolve()
+                    self.model_dir = resolve_model_dir(model_dir, prefer_nested_model=prefer_nested_model)
+                    self.task_prefix = task_prefix
+                    self.max_source_length = max_source_length
+                    self.max_new_tokens = max_new_tokens
+                    self.requested_device = device
+                    self.cpu_threads = cpu_threads
+                    self.gpu_dtype = gpu_dtype
+                    self.device: torch.device | None = None
+                    self.dtype: torch.dtype | None = None
+                    self.tokenizer = None
+                    self.model = None
+                    self._load_lock = threading.Lock()
+
+                def _resolve_device(self) -> torch.device:
+                    requested = self.requested_device.lower()
+                    if requested == "cpu":
+                        return torch.device("cpu")
+                    if requested == "cuda":
+                        if not torch.cuda.is_available():
+                            raise RuntimeError("Bạn đã chọn device=cuda nhưng máy hiện tại không có CUDA.")
+                        return torch.device("cuda")
+                    return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+                def _resolve_dtype(self) -> torch.dtype:
+                    if self.device is None or self.device.type != "cuda":
+                        return torch.float32
+                    if self.gpu_dtype == "auto":
+                        if hasattr(torch.cuda, "is_bf16_supported") and torch.cuda.is_bf16_supported():
+                            return torch.bfloat16
+                        return torch.float16
+                    return parse_dtype(self.gpu_dtype)
+
+                def _configure_runtime(self) -> None:
+                    if self.device is None:
+                        return
+                    if self.device.type == "cpu":
+                        if self.cpu_threads:
+                            torch.set_num_threads(max(1, int(self.cpu_threads)))
+                            if hasattr(torch, "set_num_interop_threads"):
+                                torch.set_num_interop_threads(max(1, min(int(self.cpu_threads), 4)))
+                        return
+
+                    if hasattr(torch.backends, "cuda") and hasattr(torch.backends.cuda, "matmul"):
+                        torch.backends.cuda.matmul.allow_tf32 = True
+                    if hasattr(torch.backends, "cudnn"):
+                        torch.backends.cudnn.allow_tf32 = True
+                        torch.backends.cudnn.benchmark = True
+
+                def load(self) -> None:
+                    if self.model is not None and self.tokenizer is not None:
+                        return
+
+                    with self._load_lock:
+                        if self.model is not None and self.tokenizer is not None:
+                            return
+
+                        self.device = self._resolve_device()
+                        self.dtype = self._resolve_dtype()
+                        self._configure_runtime()
+
+                        model_kwargs: dict[str, Any] = {}
+                        if self.device.type == "cuda":
+                            model_kwargs["torch_dtype"] = self.dtype
+                            model_kwargs["low_cpu_mem_usage"] = True
+
+                        self.tokenizer = AutoTokenizer.from_pretrained(str(self.model_dir), use_fast=True)
+                        self.model = AutoModelForSeq2SeqLM.from_pretrained(str(self.model_dir), **model_kwargs)
+                        self.model.to(self.device)
+                        self.model.eval()
+
+                def metadata(self) -> dict[str, Any]:
+                    active_device = self.device.type if self.device is not None else None
+                    predicted_device = "cuda" if torch.cuda.is_available() and self.requested_device != "cpu" else "cpu"
+                    return {
+                        "title": APP_TITLE,
+                        "model_root": str(self.model_root),
+                        "model_dir": str(self.model_dir),
+                        "requested_device": self.requested_device,
+                        "active_device": active_device,
+                        "predicted_device": predicted_device,
+                        "loaded": self.model is not None,
+                        "gpu_available": torch.cuda.is_available(),
+                        "gpu_dtype": None if self.dtype is None else str(self.dtype).replace("torch.", ""),
+                        "cpu_threads": torch.get_num_threads(),
+                    }
+
+                def _candidate_answers(self, text: str, limit: int) -> list[str]:
+                    text = normalize_text(text)
+                    if not text:
+                        return []
+
+                    candidates: list[str] = []
+                    split_pattern = r"(?<=[.!?])\\s+|\\n+"
+                    for sentence in [normalize_text(part) for part in re.split(split_pattern, text) if normalize_text(part)]:
+                        if 3 <= len(sentence.split()) <= 30:
+                            candidates.append(sentence)
+                        for clause in (normalize_text(part) for part in re.split(r"\\s*[,;:]\\s*", sentence)):
+                            if 3 <= len(clause.split()) <= 20:
+                                candidates.append(clause)
+
+                    if not candidates:
+                        words = text.split()
+                        candidates = [" ".join(words[: min(12, len(words))])] if words else [text]
+
+                    ranked = sorted(unique_text(candidates), key=lambda item: (abs(len(item.split()) - 10), len(item)))
+                    return ranked[:limit]
+
+                def _build_prompt(self, context: str, answer: str) -> str:
+                    return f"{self.task_prefix}:\\nngữ cảnh: {context}\\nđáp án: {answer}"
+
+                @torch.inference_mode()
+                def _sample(self, context: str, answer: str, count: int, temperature: float, top_p: float) -> list[str]:
+                    if self.tokenizer is None or self.model is None or self.device is None:
+                        raise RuntimeError("Model chưa được load.")
+
+                    inputs = self.tokenizer(
+                        self._build_prompt(context, answer),
+                        return_tensors="pt",
+                        truncation=True,
+                        max_length=self.max_source_length,
+                    ).to(self.device)
+                    outputs = self.model.generate(
+                        **inputs,
+                        max_new_tokens=self.max_new_tokens,
+                        do_sample=True,
+                        temperature=temperature,
+                        top_p=top_p,
+                        num_return_sequences=max(1, min(count, 6)),
+                        no_repeat_ngram_size=3,
+                        repetition_penalty=1.1,
+                    )
+                    questions: list[str] = []
+                    for token_ids in outputs:
+                        question = normalize_text(self.tokenizer.decode(token_ids, skip_special_tokens=True))
+                        if question:
+                            questions.append(question if question.endswith("?") else f"{question}?")
+                    return [question for question in unique_text(questions) if len(question.split()) >= 3]
+
+                def generate(self, text: str, num_questions: int = 5) -> list[str]:
+                    clean_text = normalize_text(text)
+                    requested_count = parse_question_count(num_questions)
+                    if not clean_text:
+                        return []
+
+                    self.load()
+                    answers = self._candidate_answers(clean_text, limit=max(requested_count * 3, 8))
+                    questions: list[str] = []
+
+                    for temperature, top_p, candidate_step, sample_count in GENERATION_PASSES:
+                        for index, answer in enumerate(answers):
+                            generated = self._sample(
+                                clean_text,
+                                answer,
+                                count=min(sample_count + requested_count, requested_count + 2),
+                                temperature=temperature,
+                                top_p=top_p,
+                            )
+                            questions.extend(generated)
+                            questions = unique_text(questions)
+                            if len(questions) >= requested_count:
+                                return questions[:requested_count]
+                            if candidate_step and (index + 1) % candidate_step == 0 and len(questions) >= requested_count:
+                                return questions[:requested_count]
+
+                    return questions[:requested_count]
+
+
+            def _read_text_from_args(args: argparse.Namespace) -> str:
+                if args.text:
+                    return normalize_text(args.text)
+                if args.input_file:
+                    return normalize_text(Path(args.input_file).read_text(encoding="utf-8"))
+                raise SystemExit("Vui lòng truyền --text hoặc --input_file.")
+
+
+            def build_parser() -> argparse.ArgumentParser:
+                parser = argparse.ArgumentParser(description="Sinh câu hỏi từ một đoạn văn bản bằng model T5 tiếng Việt.")
+                parser.add_argument("--text", help="Đoạn văn bản đầu vào.")
+                parser.add_argument("--input_file", help="Đọc đoạn văn bản từ file UTF-8.")
+                parser.add_argument("--num_questions", type=int, default=5, help="Số câu hỏi cần sinh.")
+                parser.add_argument("--model_dir", default=os.getenv("HVU_MODEL_DIR", "t5-viet-qg-finetuned"))
+                parser.add_argument("--task_prefix", default=os.getenv("HVU_TASK_PREFIX", TASK_PREFIX))
+                parser.add_argument("--device", default=os.getenv("HVU_DEVICE", "auto"), choices=["auto", "cpu", "cuda"])
+                parser.add_argument("--cpu_threads", type=int, default=None)
+                parser.add_argument("--gpu_dtype", default=os.getenv("HVU_GPU_DTYPE", "auto"))
+                parser.add_argument("--max_source_length", type=int, default=int(os.getenv("HVU_MAX_SOURCE_LENGTH", "512")))
+                parser.add_argument("--max_new_tokens", type=int, default=int(os.getenv("HVU_MAX_NEW_TOKENS", "64")))
+                parser.add_argument("--output_format", choices=["text", "json"], default="text")
+                return parser
+
+
+            def main() -> int:
+                if hasattr(sys.stdout, "reconfigure"):
+                    sys.stdout.reconfigure(encoding="utf-8")
+                if hasattr(sys.stderr, "reconfigure"):
+                    sys.stderr.reconfigure(encoding="utf-8")
+
+                args = build_parser().parse_args()
+                text = _read_text_from_args(args)
+                generator = QuestionGenerator(
+                    model_dir=args.model_dir,
+                    task_prefix=args.task_prefix,
+                    max_source_length=args.max_source_length,
+                    max_new_tokens=args.max_new_tokens,
+                    device=args.device,
+                    cpu_threads=args.cpu_threads,
+                    gpu_dtype=args.gpu_dtype,
+                )
+                questions = generator.generate(text, args.num_questions)
+                payload = {
+                    "ok": True,
+                    "text": text,
+                    "num_questions": parse_question_count(args.num_questions),
+                    "questions": questions,
+                    "formatted": format_questions(questions),
+                    "meta": generator.metadata(),
+                }
+
+                if args.output_format == "json":
+                    print(json.dumps(payload, ensure_ascii=False, indent=2))
+                else:
+                    print(payload["formatted"])
+                return 0
+
+
+            if __name__ == "__main__":
+                raise SystemExit(main())
+            """
+        ).strip()
+        + "\n",
+        "frontend/index.html": textwrap.dedent(
+            """
+            <!doctype html>
+            <html lang="vi">
+            <head>
+              <meta charset="utf-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1">
+              <title>HVU_QA Tool</title>
+              <link rel="stylesheet" href="/frontend/style.css">
+            </head>
+            <body>
+              <div class="page-shell">
+                <header class="hero">
+                  <span class="hero-badge">HVU_QA Tool</span>
+                  <h1>Sinh câu hỏi từ văn bản</h1>
+                  <p>Launcher nhẹ dành cho người dùng cuối. Chỉ cần một file tool để dựng runtime, tải model và chạy ứng dụng.</p>
+                </header>
+
+                <div class="layout">
+                  <aside class="sidebar">
+                    <section class="panel">
+                      <div class="panel-heading">
+                        <h2>Trạng thái model</h2>
+                        <span id="readyBadge" class="badge badge-soft">Đang tải</span>
+                      </div>
+
+                      <label class="field-label" for="modelSelect">Model đang dùng</label>
+                      <select id="modelSelect" class="select-field"></select>
+
+                      <dl class="status-list">
+                        <div>
+                          <dt>Tên hiển thị</dt>
+                          <dd id="modelName">-</dd>
+                        </div>
+                        <div>
+                          <dt>Thiết bị</dt>
+                          <dd id="deviceStatus">-</dd>
+                        </div>
+                        <div>
+                          <dt>Trạng thái nạp</dt>
+                          <dd id="loadedStatus">-</dd>
+                        </div>
+                      </dl>
+                    </section>
+
+                    <section class="panel">
+                      <div class="panel-heading">
+                        <h2>Ví dụ mẫu</h2>
+                      </div>
+                      <p class="panel-hint">Bấm vào một văn bản luật mẫu để chèn nhanh nội dung thử nghiệm.</p>
+                      <div id="sampleList" class="sample-list"></div>
+                    </section>
+                  </aside>
+
+                  <main class="main-panel">
+                    <section class="composer panel">
+                      <label class="field-label" for="sourceText">Đoạn văn bản đầu vào</label>
+                      <textarea id="sourceText" class="text-input" placeholder="Nhập đoạn văn bản ..."></textarea>
+
+                      <div class="composer-footer">
+                        <div class="count-field">
+                          <span class="field-label">Số câu hỏi</span>
+                          <div class="count-controls">
+                            <button id="decreaseCount" type="button" class="count-button">-</button>
+                            <input id="questionCount" class="count-input" type="number" min="1" max="100" value="5">
+                            <button id="increaseCount" type="button" class="count-button">+</button>
+                          </div>
+                        </div>
+
+                        <button id="generateButton" type="button" class="primary-button">
+                          <span id="generateButtonText">Sinh câu hỏi</span>
+                        </button>
+                      </div>
+
+                      <p id="formMessage" class="form-message"></p>
+                    </section>
+
+                    <section id="resultPanel" class="result-panel panel">
+                      <div id="resultPlaceholder" class="result-placeholder">
+                        Nhập văn bản và nhấn <strong>Sinh câu hỏi</strong> để xem kết quả.
+                      </div>
+
+                      <div id="resultContent" class="result-content hidden">
+                        <div class="result-header">
+                          <div>
+                            <h2>Kết quả sinh câu hỏi</h2>
+                            <p id="resultStats" class="result-stats"></p>
+                          </div>
+                          <button id="copyButton" type="button" class="secondary-button">Sao chép</button>
+                        </div>
+
+                        <ol id="resultList" class="result-list"></ol>
+                        <pre id="formattedOutput" class="formatted-output"></pre>
+                      </div>
+                    </section>
+                  </main>
+                </div>
+              </div>
+
+              <script src="/frontend/app.js"></script>
+            </body>
+            </html>
+            """
+        ).strip()
+        + "\n",
+        "frontend/app.js": textwrap.dedent(
+            """
+            const sampleTexts = [
+              {
+                title: 'Luật Giáo dục đại học',
+                text: 'Cơ sở giáo dục đại học có nhiệm vụ tổ chức đào tạo, nghiên cứu khoa học, chuyển giao công nghệ và phục vụ cộng đồng theo quy định của pháp luật.'
+              },
+              {
+                title: 'Bộ luật Lao động',
+                text: 'Người lao động là người làm việc cho người sử dụng lao động theo thỏa thuận, được trả lương và chịu sự quản lý, điều hành, giám sát của người sử dụng lao động.'
+              },
+              {
+                title: 'Luật An toàn thông tin mạng',
+                text: 'An toàn thông tin mạng là sự bảo vệ thông tin, hệ thống thông tin trên mạng khỏi bị truy nhập, sử dụng, tiết lộ, gián đoạn, sửa đổi hoặc phá hoại trái phép.'
+              }
+            ];
+
+            const state = {
+              info: null,
+              loading: false,
+              count: 5,
+              lastFormatted: ''
+            };
+
+            const elements = {
+              modelSelect: document.getElementById('modelSelect'),
+              readyBadge: document.getElementById('readyBadge'),
+              modelName: document.getElementById('modelName'),
+              deviceStatus: document.getElementById('deviceStatus'),
+              loadedStatus: document.getElementById('loadedStatus'),
+              sampleList: document.getElementById('sampleList'),
+              sourceText: document.getElementById('sourceText'),
+              decreaseCount: document.getElementById('decreaseCount'),
+              increaseCount: document.getElementById('increaseCount'),
+              questionCount: document.getElementById('questionCount'),
+              generateButton: document.getElementById('generateButton'),
+              generateButtonText: document.getElementById('generateButtonText'),
+              formMessage: document.getElementById('formMessage'),
+              resultPanel: document.getElementById('resultPanel'),
+              resultPlaceholder: document.getElementById('resultPlaceholder'),
+              resultContent: document.getElementById('resultContent'),
+              resultStats: document.getElementById('resultStats'),
+              resultList: document.getElementById('resultList'),
+              formattedOutput: document.getElementById('formattedOutput'),
+              copyButton: document.getElementById('copyButton')
+            };
+
+            function normalizeCount(value) {
+              const parsed = Number.parseInt(value, 10);
+              if (Number.isNaN(parsed)) {
+                return 1;
+              }
+              return Math.max(1, Math.min(100, parsed));
+            }
+
+            function setCount(value) {
+              state.count = normalizeCount(value);
+              elements.questionCount.value = String(state.count);
+            }
+
+            function setMessage(text, tone = 'muted') {
+              elements.formMessage.textContent = text || '';
+              elements.formMessage.dataset.tone = tone;
+            }
+
+            function setLoading(loading) {
+              state.loading = loading;
+              elements.generateButton.disabled = loading;
+              elements.modelSelect.disabled = loading;
+              elements.generateButtonText.textContent = loading ? 'Đang xử lý...' : 'Sinh câu hỏi';
+              elements.readyBadge.textContent = loading ? 'Đang chạy' : 'Sẵn sàng';
+              elements.readyBadge.classList.toggle('badge-busy', loading);
+            }
+
+            async function fetchJson(url, options = {}) {
+              const response = await fetch(url, options);
+              const payload = await response.json().catch(() => ({}));
+              if (!response.ok || payload.ok === false) {
+                throw new Error(payload.error || `Yêu cầu thất bại (${response.status})`);
+              }
+              return payload;
+            }
+
+            function renderSamples() {
+              elements.sampleList.innerHTML = '';
+              sampleTexts.forEach((sample) => {
+                const button = document.createElement('button');
+                button.type = 'button';
+                button.className = 'sample-card';
+                button.innerHTML = `<strong>${sample.title}</strong><span>${sample.text}</span>`;
+                button.addEventListener('click', () => {
+                  elements.sourceText.value = sample.text;
+                  setMessage(`Đã chèn mẫu: ${sample.title}`, 'muted');
+                  elements.sourceText.focus();
+                });
+                elements.sampleList.appendChild(button);
+              });
+            }
+
+            function renderInfo(info) {
+              state.info = info;
+              const models = Array.isArray(info.available_models) ? info.available_models : [];
+              const selectedId = info.selected_model_id || models[0]?.id || '';
+
+              elements.modelSelect.innerHTML = '';
+              if (!models.length) {
+                const option = document.createElement('option');
+                option.value = '';
+                option.textContent = 'Không có model khả dụng';
+                elements.modelSelect.appendChild(option);
+              } else {
+                models.forEach((model) => {
+                  const option = document.createElement('option');
+                  option.value = model.id;
+                  option.textContent = model.label;
+                  elements.modelSelect.appendChild(option);
+                });
+                elements.modelSelect.value = selectedId;
+              }
+
+              const meta = info.meta || {};
+              elements.modelName.textContent = info.model_name || '-';
+              elements.deviceStatus.textContent = meta.active_device
+                ? meta.active_device.toUpperCase()
+                : (meta.predicted_device ? `Dự đoán: ${String(meta.predicted_device).toUpperCase()}` : '-');
+              elements.loadedStatus.textContent = meta.loaded ? 'Đã nạp' : 'Chưa nạp';
+              elements.readyBadge.textContent = 'Sẵn sàng';
+              elements.readyBadge.classList.remove('badge-busy');
+            }
+
+            function renderResult(result) {
+              const questions = Array.isArray(result.questions) ? result.questions : [];
+              elements.resultPlaceholder.classList.add('hidden');
+              elements.resultContent.classList.remove('hidden');
+              elements.resultList.innerHTML = '';
+
+              questions.forEach((question) => {
+                const item = document.createElement('li');
+                item.textContent = question;
+                elements.resultList.appendChild(item);
+              });
+
+              state.lastFormatted = result.formatted || '';
+              elements.formattedOutput.textContent = state.lastFormatted;
+              elements.resultStats.textContent = `${questions.length} câu hỏi • ${result.model_name || 'Không rõ model'} • ${result.elapsed_ms || 0} ms`;
+            }
+
+            async function loadInfo() {
+              const info = await fetchJson('/api/info');
+              renderInfo(info);
+              setMessage('Sẵn sàng để sinh câu hỏi.', 'muted');
+            }
+
+            async function changeModel() {
+              const modelId = elements.modelSelect.value;
+              if (!modelId) {
+                return;
+              }
+              setLoading(true);
+              setMessage('Đang chuyển model...', 'muted');
+              try {
+                const info = await fetchJson('/api/model', {
+                  method: 'POST',
+                  headers: { 'Content-Type': 'application/json' },
+                  body: JSON.stringify({ model_id: modelId })
+                });
+                renderInfo(info);
+                setMessage(`Đã chuyển sang model: ${info.model_name}`, 'muted');
+              } catch (error) {
+                setMessage(error.message, 'error');
+              } finally {
+                setLoading(false);
+              }
+            }
+
+            async function generateQuestions() {
+              const text = elements.sourceText.value.trim();
+              if (!text) {
+                setMessage('Vui lòng nhập đoạn văn bản trước khi sinh câu hỏi.', 'error');
+                elements.sourceText.focus();
+                return;
+              }
+
+              setLoading(true);
+              setMessage('Đang sinh câu hỏi từ nội dung đã nhập...', 'muted');
+
+              try {
+                const payload = await fetchJson('/api/generate', {
+                  method: 'POST',
+                  headers: { 'Content-Type': 'application/json' },
+                  body: JSON.stringify({
+                    text,
+                    num_questions: state.count,
+                    model_id: elements.modelSelect.value || undefined
+                  })
+                });
+                renderResult(payload);
+                setMessage(`Đã sinh xong ${payload.questions.length} câu hỏi.`, 'muted');
+              } catch (error) {
+                setMessage(error.message, 'error');
+              } finally {
+                setLoading(false);
+              }
+            }
+
+            async function copyOutput() {
+              if (!state.lastFormatted) {
+                setMessage('Chưa có nội dung để sao chép.', 'error');
+                return;
+              }
+
+              try {
+                await navigator.clipboard.writeText(state.lastFormatted);
+                setMessage('Đã sao chép kết quả vào clipboard.', 'muted');
+              } catch (error) {
+                setMessage('Không thể sao chép tự động. Hãy sao chép thủ công.', 'error');
+              }
+            }
+
+            function bindEvents() {
+              elements.decreaseCount.addEventListener('click', () => setCount(state.count - 1));
+              elements.increaseCount.addEventListener('click', () => setCount(state.count + 1));
+              elements.questionCount.addEventListener('change', (event) => setCount(event.target.value));
+              elements.modelSelect.addEventListener('change', changeModel);
+              elements.generateButton.addEventListener('click', generateQuestions);
+              elements.copyButton.addEventListener('click', copyOutput);
+            }
+
+            async function init() {
+              renderSamples();
+              setCount(5);
+              bindEvents();
+              try {
+                await loadInfo();
+              } catch (error) {
+                setMessage(error.message || 'Không thể kết nối backend.', 'error');
+                elements.readyBadge.textContent = 'Lỗi';
+              }
+            }
+
+            document.addEventListener('DOMContentLoaded', init);
+            """
+        ).strip()
+        + "\n",
+        "frontend/style.css": textwrap.dedent(
+            """
+            :root {
+              --bg-start: #f8f5ff;
+              --bg-end: #eef4ff;
+              --panel: rgba(255, 255, 255, 0.82);
+              --border: rgba(103, 102, 181, 0.18);
+              --text: #23244d;
+              --muted: #6c6d9a;
+              --primary-start: #6b73ff;
+              --primary-end: #d96ba2;
+              --shadow: 0 22px 60px rgba(52, 56, 121, 0.14);
+            }
+
+            * {
+              box-sizing: border-box;
+            }
+
+            body {
+              margin: 0;
+              min-height: 100vh;
+              font-family: "Be Vietnam Pro", "Segoe UI", sans-serif;
+              color: var(--text);
+              background:
+                radial-gradient(circle at top left, rgba(123, 135, 255, 0.14), transparent 28%),
+                radial-gradient(circle at bottom right, rgba(217, 107, 162, 0.18), transparent 25%),
+                linear-gradient(135deg, var(--bg-start), var(--bg-end));
+            }
+
+            button,
+            input,
+            textarea,
+            select {
+              font: inherit;
+            }
+
+            .page-shell {
+              width: min(1200px, calc(100% - 32px));
+              margin: 24px auto;
+            }
+
+            .hero {
+              padding: 32px;
+              border: 1px solid var(--border);
+              border-radius: 28px;
+              background: var(--panel);
+              box-shadow: var(--shadow);
+              backdrop-filter: blur(18px);
+            }
+
+            .hero-badge {
+              display: inline-flex;
+              padding: 8px 14px;
+              border-radius: 999px;
+              background: rgba(107, 115, 255, 0.12);
+              color: #5058d9;
+              font-size: 13px;
+              font-weight: 700;
+              letter-spacing: 0.04em;
+              text-transform: uppercase;
+            }
+
+            .hero h1 {
+              margin: 18px 0 10px;
+              font-size: clamp(34px, 5vw, 56px);
+              line-height: 1.04;
+            }
+
+            .hero p {
+              margin: 0;
+              max-width: 760px;
+              color: var(--muted);
+              font-size: 18px;
+              line-height: 1.65;
+            }
+
+            .layout {
+              display: grid;
+              grid-template-columns: 320px minmax(0, 1fr);
+              gap: 20px;
+              margin-top: 20px;
+            }
+
+            .panel {
+              border: 1px solid var(--border);
+              border-radius: 24px;
+              background: var(--panel);
+              box-shadow: var(--shadow);
+              backdrop-filter: blur(18px);
+            }
+
+            .sidebar,
+            .main-panel {
+              display: grid;
+              gap: 20px;
+              align-content: start;
+            }
+
+            .panel-heading {
+              display: flex;
+              align-items: center;
+              justify-content: space-between;
+              gap: 12px;
+              margin-bottom: 16px;
+            }
+
+            .panel h2 {
+              margin: 0;
+              font-size: 18px;
+            }
+
+            .sidebar .panel,
+            .composer,
+            .result-panel {
+              padding: 22px;
+            }
+
+            .badge {
+              display: inline-flex;
+              align-items: center;
+              justify-content: center;
+              min-width: 92px;
+              padding: 8px 12px;
+              border-radius: 999px;
+              font-size: 13px;
+              font-weight: 700;
+            }
+
+            .badge-soft {
+              background: rgba(39, 179, 112, 0.14);
+              color: #218b59;
+            }
+
+            .badge-busy {
+              background: rgba(238, 160, 59, 0.16);
+              color: #b86a00;
+            }
+
+            .field-label {
+              display: inline-block;
+              margin-bottom: 10px;
+              color: var(--muted);
+              font-size: 13px;
+              font-weight: 700;
+              letter-spacing: 0.02em;
+            }
+
+            .select-field,
+            .text-input,
+            .count-input {
+              width: 100%;
+              border: 1px solid rgba(103, 102, 181, 0.14);
+              border-radius: 18px;
+              background: rgba(255, 255, 255, 0.92);
+              color: var(--text);
+            }
+
+            .select-field {
+              min-height: 52px;
+              padding: 0 16px;
+            }
+
+            .status-list {
+              display: grid;
+              gap: 14px;
+              margin: 18px 0 0;
+            }
+
+            .status-list div {
+              padding: 14px 16px;
+              border-radius: 18px;
+              background: rgba(104, 109, 208, 0.07);
+            }
+
+            .status-list dt {
+              margin: 0 0 6px;
+              color: var(--muted);
+              font-size: 12px;
+              font-weight: 700;
+              text-transform: uppercase;
+              letter-spacing: 0.04em;
+            }
+
+            .status-list dd {
+              margin: 0;
+              font-size: 15px;
+              font-weight: 600;
+              word-break: break-word;
+            }
+
+            .panel-hint {
+              margin: 0 0 14px;
+              color: var(--muted);
+              line-height: 1.6;
+            }
+
+            .sample-list {
+              display: grid;
+              gap: 12px;
+            }
+
+            .sample-card {
+              display: grid;
+              gap: 8px;
+              width: 100%;
+              padding: 16px;
+              border: 1px solid rgba(103, 102, 181, 0.14);
+              border-radius: 18px;
+              background: rgba(255, 255, 255, 0.92);
+              text-align: left;
+              color: var(--text);
+              cursor: pointer;
+              transition: transform 0.18s ease, border-color 0.18s ease, box-shadow 0.18s ease;
+            }
+
+            .sample-card:hover {
+              transform: translateY(-2px);
+              border-color: rgba(86, 98, 218, 0.32);
+              box-shadow: 0 16px 30px rgba(61, 70, 154, 0.12);
+            }
+
+            .sample-card span {
+              color: var(--muted);
+              line-height: 1.55;
+            }
+
+            .text-input {
+              min-height: 250px;
+              padding: 18px 20px;
+              resize: vertical;
+              line-height: 1.7;
+            }
+
+            .composer-footer {
+              display: flex;
+              align-items: end;
+              justify-content: space-between;
+              gap: 18px;
+              margin-top: 18px;
+            }
+
+            .count-field {
+              min-width: 230px;
+            }
+
+            .count-controls {
+              display: grid;
+              grid-template-columns: 48px 92px 48px;
+              gap: 10px;
+              align-items: center;
+            }
+
+            .count-button,
+            .secondary-button {
+              min-height: 48px;
+              border: 1px solid rgba(103, 102, 181, 0.16);
+              border-radius: 16px;
+              background: rgba(255, 255, 255, 0.92);
+              color: var(--text);
+              cursor: pointer;
+            }
+
+            .count-button {
+              font-size: 22px;
+              font-weight: 700;
+            }
+
+            .count-input {
+              min-height: 48px;
+              padding: 0 12px;
+              text-align: center;
+              font-weight: 700;
+            }
+
+            .primary-button {
+              min-width: 220px;
+              min-height: 56px;
+              padding: 0 24px;
+              border: none;
+              border-radius: 18px;
+              background: linear-gradient(135deg, var(--primary-start), var(--primary-end));
+              color: white;
+              font-size: 16px;
+              font-weight: 800;
+              cursor: pointer;
+              box-shadow: 0 18px 34px rgba(95, 105, 220, 0.24);
+            }
+
+            .primary-button:disabled,
+            .secondary-button:disabled {
+              cursor: not-allowed;
+              opacity: 0.7;
+            }
+
+            .form-message {
+              min-height: 22px;
+              margin: 14px 0 0;
+              color: var(--muted);
+            }
+
+            .form-message[data-tone="error"] {
+              color: #c33b5f;
+            }
+
+            .result-panel {
+              min-height: 320px;
+            }
+
+            .result-placeholder {
+              display: grid;
+              place-items: center;
+              min-height: 260px;
+              padding: 24px;
+              border: 1px dashed rgba(103, 102, 181, 0.24);
+              border-radius: 20px;
+              color: var(--muted);
+              text-align: center;
+              line-height: 1.7;
+            }
+
+            .result-content.hidden,
+            .result-placeholder.hidden {
+              display: none;
+            }
+
+            .result-header {
+              display: flex;
+              align-items: start;
+              justify-content: space-between;
+              gap: 16px;
+              margin-bottom: 18px;
+            }
+
+            .result-header h2 {
+              margin: 0 0 8px;
+            }
+
+            .result-stats {
+              margin: 0;
+              color: var(--muted);
+            }
+
+            .result-list {
+              margin: 0;
+              padding-left: 20px;
+              display: grid;
+              gap: 12px;
+              line-height: 1.65;
+            }
+
+            .formatted-output {
+              margin: 20px 0 0;
+              padding: 18px;
+              border-radius: 18px;
+              background: rgba(104, 109, 208, 0.07);
+              white-space: pre-wrap;
+              word-break: break-word;
+              line-height: 1.65;
+            }
+
+            @media (max-width: 980px) {
+              .layout {
+                grid-template-columns: 1fr;
+              }
+            }
+
+            @media (max-width: 640px) {
+              .page-shell {
+                width: min(100% - 16px, 1000px);
+                margin: 16px auto;
+              }
+
+              .hero,
+              .sidebar .panel,
+              .composer,
+              .result-panel {
+                padding: 18px;
+              }
+
+              .composer-footer,
+              .result-header {
+                flex-direction: column;
+                align-items: stretch;
+              }
+
+              .count-field,
+              .primary-button,
+              .secondary-button {
+                width: 100%;
+              }
+            }
+            """
+        ).strip()
+        + "\n",
+    }
+
+
+def sync_text_file(destination_file: Path, content: str, force_write: bool) -> bool:
+    destination_file.parent.mkdir(parents=True, exist_ok=True)
+    if destination_file.exists() and not force_write:
+        current = destination_file.read_text(encoding="utf-8")
+        if current == content:
+            return False
+    destination_file.write_text(content, encoding="utf-8")
+    return True
+
+
+def materialize_standalone_runtime(runtime_root: Path, force_refresh: bool) -> None:
+    runtime_files = build_runtime_file_map()
+    created = 0
+    reused = 0
+
+    for relative_path, content in runtime_files.items():
+        destination = runtime_root / relative_path
+        if sync_text_file(destination, content, force_write=force_refresh):
+            created += 1
+        else:
+            reused += 1
+
+    print_step(
+        f"Đã chuẩn bị runtime standalone tại {runtime_root}. "
+        f"File mới/cập nhật: {created}, file giữ nguyên: {reused}."
+    )
+
+
+def resolve_runtime_context(args: argparse.Namespace) -> RuntimeContext:
+    use_local_project = has_local_project(SCRIPT_ROOT) and not args.force_standalone_runtime
+    if use_local_project:
+        runtime_root = SCRIPT_ROOT
+        standalone_mode = False
+    else:
+        requested_runtime_dir = Path(args.runtime_dir).expanduser()
+        if not requested_runtime_dir.is_absolute():
+            requested_runtime_dir = SCRIPT_ROOT / requested_runtime_dir
+        runtime_root = requested_runtime_dir.resolve()
+        standalone_mode = True
+        materialize_standalone_runtime(runtime_root, force_refresh=args.force_runtime_refresh)
+
+    context = RuntimeContext(
+        root=runtime_root,
+        main_file=runtime_root / "main.py",
+        requirements_file=runtime_root / "requirements.txt",
+        local_model_dir=runtime_root / "t5-viet-qg-finetuned",
+        local_best_model_dir=runtime_root / "t5-viet-qg-finetuned" / "best-model",
+        standalone_mode=standalone_mode,
+    )
+    mode_label = "standalone" if standalone_mode else "full project"
+    print_step(f"Runtime mode: {mode_label}")
+    print_step(f"Runtime root: {context.root}")
+    return context
+
+
+def maybe_bootstrap_tool_venv(args: argparse.Namespace) -> int | None:
+    if args.no_venv or is_running_in_virtualenv():
+        return None
+
+    if not TOOL_VENV_PYTHON.exists():
+        print_step("Không phát hiện virtualenv hiện tại. Đang tạo môi trường riêng cho launcher...")
+        run_command([sys.executable, "-m", "venv", str(TOOL_VENV_DIR)], cwd=SCRIPT_ROOT)
+        run_command([str(TOOL_VENV_PYTHON), "-m", "pip", "install", "--upgrade", "pip"], cwd=SCRIPT_ROOT)
+
+    relaunch_env = os.environ.copy()
+    relaunch_env["HVU_QA_TOOL_BOOTSTRAPPED"] = "1"
+    relaunch_command = [str(TOOL_VENV_PYTHON), str(Path(__file__).resolve()), *sys.argv[1:]]
+
+    print_step("Đang chuyển sang môi trường Python riêng của launcher...")
+    return subprocess.call(relaunch_command, cwd=str(SCRIPT_ROOT), env=relaunch_env)
+
+
+def ensure_huggingface_hub(skip_install: bool, context: RuntimeContext) -> None:
+    if module_exists("huggingface_hub"):
+        return
+
+    if skip_install:
+        install_hint = (
+            f"{sys.executable} -m pip install {HF_HUB_REQUIREMENT}"
+            if not context.requirements_file.exists()
+            else f"{sys.executable} -m pip install -r {context.requirements_file}"
+        )
+        raise RuntimeError(
+            "Thiếu huggingface_hub. Hãy chạy "
+            f"`{install_hint}` hoặc bỏ `--skip-install`."
+        )
+
+    print_step("Thiếu huggingface_hub. Đang cài tự động...")
+    if context.requirements_file.exists():
+        run_command([sys.executable, "-m", "pip", "install", "-r", str(context.requirements_file)], cwd=context.root)
+    else:
+        run_command([sys.executable, "-m", "pip", "install", HF_HUB_REQUIREMENT], cwd=context.root)
+
+
+def find_missing_dependencies() -> list[str]:
+    missing: list[str] = []
+    for package_name, module_name in DEPENDENCY_IMPORTS.items():
+        if not module_exists(module_name):
+            missing.append(package_name)
+    return missing
+
+
+def ensure_runtime_dependencies(skip_install: bool, context: RuntimeContext) -> None:
+    missing = find_missing_dependencies()
+    if not missing:
+        print_step("Môi trường Python đã có đủ dependency cần thiết.")
+        return
+
+    if skip_install:
+        missing_text = ", ".join(missing)
+        install_hint = (
+            f"{sys.executable} -m pip install -r {context.requirements_file}"
+            if context.requirements_file.exists()
+            else f"{sys.executable} -m pip install {' '.join(RUNTIME_REQUIREMENTS)}"
+        )
+        raise RuntimeError(
+            f"Thiếu dependency: {missing_text}. "
+            f"Hãy chạy `{install_hint}` hoặc bỏ `--skip-install`."
+        )
+
+    if context.requirements_file.exists():
+        print_step(f"Đang cài dependency còn thiếu: {', '.join(missing)}")
+        run_command([sys.executable, "-m", "pip", "install", "-r", str(context.requirements_file)], cwd=context.root)
+        return
+
+    print_step(f"Đang cài dependency runtime còn thiếu: {', '.join(missing)}")
+    run_command([sys.executable, "-m", "pip", "install", *RUNTIME_REQUIREMENTS], cwd=context.root)
+
+
+def select_repo_files(repo_files: list[str], best_model_only: bool) -> list[str]:
+    allow_patterns = build_allow_patterns(best_model_only)
+    selected: list[str] = []
+
+    for repo_file in repo_files:
+        normalized = repo_file.replace("\\", "/")
+        if not matches_any_pattern(normalized, allow_patterns):
+            continue
+        if matches_any_pattern(normalized, MODEL_IGNORE_PATTERNS):
+            continue
+        selected.append(normalized)
+
+    return sorted(selected)
+
+
+def get_target_destination(context: RuntimeContext, repo_file: str) -> Path:
+    relative_path = Path(repo_file).relative_to(HF_MODEL_SUBDIR)
+    return context.local_model_dir / relative_path
+
+
+def resolve_repo_files(repo_id: str, revision: str, best_model_only: bool) -> list[dict[str, int | str | None]]:
+    from huggingface_hub import HfApi
+
+    api = HfApi()
+    repo_files = api.list_repo_tree(repo_id=repo_id, repo_type="dataset", revision=revision, recursive=True)
+
+    file_entries: list[str] = []
+    size_map: dict[str, int | None] = {}
+    for entry in repo_files:
+        entry_path = str(getattr(entry, "path", "")).replace("\\", "/")
+        if not entry_path or entry_path.endswith("/"):
+            continue
+        file_entries.append(entry_path)
+        size_map[entry_path] = getattr(entry, "size", None)
+
+    selected_paths = select_repo_files(file_entries, best_model_only=best_model_only)
+    if not selected_paths:
+        scope = "best-model" if best_model_only else "model"
+        raise FileNotFoundError(
+            f"Không tìm thấy file {scope} hợp lệ trong repo {repo_id}@{revision}. "
+            "Hãy kiểm tra lại cấu trúc repo trên Hugging Face."
+        )
+
+    return [{"path": path, "size": size_map.get(path)} for path in selected_paths]
+
+
+def sync_single_file(source_file: Path, destination_file: Path, force_copy: bool) -> tuple[bool, int]:
+    destination_file.parent.mkdir(parents=True, exist_ok=True)
+    size = source_file.stat().st_size
+
+    if (
+        destination_file.exists()
+        and not force_copy
+        and destination_file.stat().st_size == size
+    ):
+        return False, size
+
+    shutil.copy2(source_file, destination_file)
+    return True, size
+
+
+def download_and_sync_model(
+    context: RuntimeContext,
+    repo_id: str,
+    revision: str,
+    force_download: bool,
+    best_model_only: bool,
+) -> tuple[int, int, int, int]:
+    from huggingface_hub import hf_hub_download
+
+    repo_files = resolve_repo_files(repo_id=repo_id, revision=revision, best_model_only=best_model_only)
+    total_files = len(repo_files)
+    total_bytes = sum(int(item["size"] or 0) for item in repo_files)
+
+    copied_files = 0
+    skipped_files = 0
+    copied_bytes = 0
+    skipped_bytes = 0
+    processed_bytes = 0
+    download_scope = "best-model" if best_model_only else "toàn bộ model"
+
+    print_step(f"Tìm thấy {total_files} file cần đồng bộ cho {download_scope}.")
+
+    for index, repo_item in enumerate(repo_files, start=1):
+        repo_file = str(repo_item["path"])
+        destination_path = get_target_destination(context, repo_file)
+        relative_label = destination_path.relative_to(context.root).as_posix()
+        print_step(f"[{index}/{total_files}] Đang tải {relative_label}")
+
+        cached_file = hf_hub_download(
+            repo_id=repo_id,
+            repo_type="dataset",
+            revision=revision,
+            filename=repo_file,
+            force_download=force_download,
+            local_files_only=False,
+        )
+
+        copied, size = sync_single_file(Path(cached_file), destination_path, force_copy=force_download)
+        if copied:
+            copied_files += 1
+            copied_bytes += size
+            print_step(f"    Đã đồng bộ {relative_label} ({format_bytes(size)})")
+        else:
+            skipped_files += 1
+            skipped_bytes += size
+            print_step(f"    Giữ nguyên {relative_label} ({format_bytes(size)})")
+
+        processed_bytes += size
+        if processed_bytes > total_bytes:
+            total_bytes = processed_bytes
+
+        print_step(
+            "    Tổng tiến độ "
+            f"{render_progress_bar(processed_bytes, total_bytes)} "
+            f"({format_bytes(processed_bytes)}/{format_bytes(total_bytes)})"
+        )
+
+    return copied_files, skipped_files, copied_bytes, skipped_bytes
+
+
+def required_model_files(context: RuntimeContext, best_model_only: bool) -> list[Path]:
+    if best_model_only:
+        model_dir = context.local_best_model_dir
+    else:
+        model_dir = context.local_model_dir
+
+    return [
+        model_dir / "config.json",
+        model_dir / "generation_config.json",
+        model_dir / "model.safetensors",
+        model_dir / "tokenizer_config.json",
+        model_dir / "special_tokens_map.json",
+        model_dir / "spiece.model",
+    ]
+
+
+def validate_local_model_dir(context: RuntimeContext, best_model_only: bool) -> None:
+    missing_files = [
+        str(path.relative_to(context.root))
+        for path in required_model_files(context, best_model_only)
+        if not path.exists()
+    ]
+    if missing_files:
+        raise FileNotFoundError(
+            "Model chưa đầy đủ sau khi tải về. Thiếu các file: " + ", ".join(missing_files)
+        )
+
+
+def prepare_model(
+    context: RuntimeContext,
+    repo_id: str,
+    revision: str,
+    force_download: bool,
+    skip_download: bool,
+    best_model_only: bool,
+) -> None:
+    if skip_download:
+        print_step("Bỏ qua bước tải model theo yêu cầu `--skip-download`.")
+        validate_local_model_dir(context, best_model_only=best_model_only)
+        return
+
+    copied_files, skipped_files, copied_bytes, skipped_bytes = download_and_sync_model(
+        context=context,
+        repo_id=repo_id,
+        revision=revision,
+        force_download=force_download,
+        best_model_only=best_model_only,
+    )
+    validate_local_model_dir(context, best_model_only=best_model_only)
+
+    scope = "best-model" if best_model_only else "toàn bộ model"
+    print_step(
+        f"Đồng bộ {scope} xong. "
+        f"File mới/cập nhật: {copied_files} ({format_bytes(copied_bytes)}), "
+        f"file giữ nguyên: {skipped_files} ({format_bytes(skipped_bytes)})."
+    )
+
+
+def build_runtime_env(context: RuntimeContext, args: argparse.Namespace) -> dict[str, str]:
+    env = os.environ.copy()
+
+    if args.host:
+        env["HVU_HOST"] = args.host
+    if args.port is not None:
+        env["HVU_PORT"] = str(args.port)
+    if args.device:
+        env["HVU_DEVICE"] = args.device
+    if args.debug:
+        env["HVU_DEBUG"] = "1"
+    if args.no_browser:
+        env["HVU_OPEN_BROWSER"] = "0"
+
+    env["HVU_MODEL_DIR"] = str(context.local_model_dir)
+    return env
+
+
+def launch_app(context: RuntimeContext, args: argparse.Namespace) -> int:
+    if not context.main_file.exists():
+        raise FileNotFoundError(f"Không tìm thấy file chạy ứng dụng: {context.main_file}")
+
+    env = build_runtime_env(context, args)
+    command = [sys.executable, str(context.main_file)]
+
+    print_step("Đang chạy ứng dụng web...")
+    print_step(
+        "Mở trình duyệt tại "
+        f"http://{env.get('HVU_HOST', '127.0.0.1')}:{env.get('HVU_PORT', '5000')}"
+    )
+    return subprocess.call(command, cwd=str(context.root), env=env)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Launcher cho HVU_QA: có thể chạy full project nếu đang đứng trong repo, "
+            "hoặc tự dựng runtime standalone khi chỉ có file HVU_QA_tool.py."
+        ),
+    )
+    parser.add_argument("--repo-id", default=HF_DATASET_REPO_ID, help="Repo dataset trên Hugging Face.")
+    parser.add_argument("--revision", default=HF_DATASET_REVISION, help="Revision trên Hugging Face.")
+    parser.add_argument("--host", default=None, help="Host chạy Flask. Mặc định dùng HVU_HOST hoặc 127.0.0.1.")
+    parser.add_argument("--port", type=int, default=None, help="Port chạy Flask. Mặc định dùng HVU_PORT hoặc 5000.")
+    parser.add_argument(
+        "--device",
+        choices=["auto", "cpu", "cuda"],
+        default=None,
+        help="Thiết bị chạy model. Mặc định dùng HVU_DEVICE hoặc auto.",
+    )
+    parser.add_argument("--debug", action="store_true", help="Bật Flask debug.")
+    parser.add_argument("--no-browser", action="store_true", help="Không tự mở trình duyệt.")
+    parser.add_argument("--no-venv", action="store_true", help="Không tự tạo virtualenv riêng cho launcher.")
+    parser.add_argument("--force-download", action="store_true", help="Tải lại model và ghi đè file local.")
+    parser.add_argument(
+        "--best-model-only",
+        action="store_true",
+        help="Chỉ tải thư mục best-model. Lệnh này chỉ dùng được khi repo thật sự có best-model.",
+    )
+    parser.add_argument("--skip-download", action="store_true", help="Bỏ qua bước tải model từ Hugging Face.")
+    parser.add_argument("--skip-install", action="store_true", help="Không tự cài dependency còn thiếu.")
+    parser.add_argument("--skip-run", action="store_true", help="Chỉ chuẩn bị môi trường và model, không chạy app.")
+    parser.add_argument(
+        "--runtime-dir",
+        default="HVU_QA_runtime",
+        help="Thư mục runtime standalone sẽ được tạo nếu không có full project hoặc khi ép standalone.",
+    )
+    parser.add_argument(
+        "--force-standalone-runtime",
+        action="store_true",
+        help="Luôn dựng runtime standalone, kể cả khi đang đứng trong full project.",
+    )
+    parser.add_argument(
+        "--force-runtime-refresh",
+        action="store_true",
+        help="Ghi đè lại các file runtime standalone được nhúng sẵn trong launcher.",
+    )
+    parser.add_argument(
+        "--prepare-runtime-only",
+        action="store_true",
+        help="Chỉ dựng runtime standalone hoặc kiểm tra full project hiện tại, không cài dependency, không tải model.",
+    )
+    return parser
+
+
+def main() -> int:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    if hasattr(sys.stderr, "reconfigure"):
+        sys.stderr.reconfigure(encoding="utf-8")
+
+    parser = build_parser()
+    args = parser.parse_args()
+
+    bootstrap_exit_code = maybe_bootstrap_tool_venv(args)
+    if bootstrap_exit_code is not None:
+        return bootstrap_exit_code
+
+    print_step("Bắt đầu chuẩn bị dự án HVU_QA...")
+    context = resolve_runtime_context(args)
+
+    if args.prepare_runtime_only:
+        print_step("Đã chuẩn bị xong runtime. Bỏ qua các bước tiếp theo theo `--prepare-runtime-only`.")
+        return 0
+
+    ensure_huggingface_hub(skip_install=args.skip_install, context=context)
+    prepare_model(
+        context=context,
+        repo_id=args.repo_id,
+        revision=args.revision,
+        force_download=args.force_download,
+        skip_download=args.skip_download,
+        best_model_only=args.best_model_only,
+    )
+    ensure_runtime_dependencies(skip_install=args.skip_install, context=context)
+
+    if args.skip_run:
+        print_step("Đã chuẩn bị xong model và dependency. Bỏ qua chạy app theo `--skip-run`.")
+        return 0
+
+    return launch_app(context, args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

HVU_QA/backend/__init__.py

@@ -0,0 +1,3 @@
+from .app import create_app
+
+__all__ = ["create_app"]

HVU_QA/backend/app.py

@@ -0,0 +1,319 @@
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from flask import Flask, jsonify, request, send_from_directory
+
+from generate_question import (
+    APP_TITLE,
+    QUESTION_LIMIT,
+    QuestionGenerator,
+    format_questions,
+    normalize_text,
+    parse_question_count,
+    resolve_model_dir,
+)
+
+IGNORED_MODEL_DIR_NAMES = {
+    ".git",
+    ".vscode",
+    "__pycache__",
+    "backend",
+    "frontend",
+    "venv",
+}
+
+
+def project_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def build_generator(
+    model_dir: str | Path | None = None,
+    prefer_nested_model: bool = True,
+) -> QuestionGenerator:
+    root = project_root()
+    selected_model_dir = (
+        Path(model_dir).expanduser()
+        if model_dir is not None
+        else Path(os.getenv("HVU_MODEL_DIR", str(root / "t5-viet-qg-finetuned"))).expanduser()
+    )
+    if not selected_model_dir.is_absolute():
+        selected_model_dir = root / selected_model_dir
+
+    return QuestionGenerator(
+        model_dir=str(selected_model_dir),
+        task_prefix=os.getenv("HVU_TASK_PREFIX", "sinh câu hỏi"),
+        max_source_length=int(os.getenv("HVU_MAX_SOURCE_LENGTH", "512")),
+        max_new_tokens=int(os.getenv("HVU_MAX_NEW_TOKENS", "64")),
+        device=os.getenv("HVU_DEVICE", "auto"),
+        cpu_threads=_read_optional_int(os.getenv("HVU_CPU_THREADS")),
+        gpu_dtype=os.getenv("HVU_GPU_DTYPE", "auto"),
+        prefer_nested_model=prefer_nested_model,
+    )
+
+
+def _read_optional_int(value: str | None) -> int | None:
+    if value in (None, ""):
+        return None
+    return int(value)
+
+
+def _humanize_model_segment(value: str) -> str:
+    normalized = value.replace("_", "-")
+    parts: list[str] = []
+    for part in normalized.split("-"):
+        lowered = part.lower()
+        if not lowered:
+            continue
+        if lowered in {"t5", "qg", "qa", "hvu"}:
+            parts.append(lowered.upper())
+        elif lowered == "seq2seq":
+            parts.append("Seq2Seq")
+        elif lowered == "checkpoint":
+            parts.append("Checkpoint")
+        elif part.isdigit():
+            parts.append(part)
+        else:
+            parts.append(part.capitalize())
+    return "-".join(parts) or "Model"
+
+
+def _display_model_name(meta: dict[str, object]) -> str:
+    raw_name = Path(str(meta.get("model_root") or meta.get("model_dir") or "model")).name
+    return _humanize_model_segment(raw_name)
+
+
+def _model_label(relative_path: str | Path) -> str:
+    path = Path(relative_path)
+    return path.name or "model"
+
+
+def _iter_model_candidates(root: Path):
+    for child in sorted(root.iterdir(), key=lambda path: path.name.lower()):
+        if not child.is_dir() or child.name.startswith(".") or child.name in IGNORED_MODEL_DIR_NAMES:
+            continue
+
+        if (child / "config.json").exists():
+            yield {"path": child, "prefer_nested_model": False}
+
+        for nested_name in ("best-model", "final-model"):
+            nested = child / nested_name
+            if nested.is_dir() and (nested / "config.json").exists():
+                yield {"path": nested, "prefer_nested_model": False}
+
+
+def _discover_available_models(
+    root: Path,
+    active_generator: QuestionGenerator | None = None,
+) -> list[dict[str, str]]:
+    models: list[dict[str, str]] = []
+    seen_model_roots: set[str] = set()
+    root = root.resolve()
+
+    for candidate_info in _iter_model_candidates(root):
+        candidate = candidate_info["path"]
+        prefer_nested_model = bool(candidate_info["prefer_nested_model"])
+        model_key = str(candidate.resolve())
+        if model_key in seen_model_roots:
+            continue
+
+        try:
+            relative_candidate = candidate.resolve().relative_to(root)
+        except ValueError:
+            continue
+
+        seen_model_roots.add(model_key)
+        models.append(
+            {
+                "id": relative_candidate.as_posix(),
+                "label": _model_label(relative_candidate),
+                "model_root": str(candidate.resolve()),
+                "model_dir": str(resolve_model_dir(candidate, prefer_nested_model=False).resolve()),
+                "prefer_nested_model": prefer_nested_model,
+            }
+        )
+
+    if active_generator is not None:
+        current_root = active_generator.model_root.resolve()
+        current_dir = active_generator.model_dir.resolve()
+        exists = any(
+            Path(item["model_root"]).resolve() == current_root
+            or Path(item["model_dir"]).resolve() == current_dir
+            for item in models
+        )
+        if not exists:
+            models.append(
+                {
+                    "id": current_root.as_posix(),
+                    "label": _display_model_name(active_generator.metadata()),
+                    "model_root": str(current_root),
+                    "model_dir": str(current_dir),
+                    "prefer_nested_model": False,
+                }
+            )
+
+    return models
+
+
+def _selected_model_id(
+    app: Flask,
+    models: list[dict[str, str]],
+    active_generator: QuestionGenerator | None = None,
+) -> str:
+    explicit_selection = str(app.config.get("SELECTED_MODEL_ID") or "").strip()
+    if explicit_selection and any(item["id"] == explicit_selection for item in models):
+        return explicit_selection
+
+    active_generator = active_generator or _generator(app)
+    current_root = active_generator.model_root.resolve()
+    current_dir = active_generator.model_dir.resolve()
+
+    for item in models:
+        if Path(item["model_dir"]).resolve() == current_dir:
+            return item["id"]
+
+    for item in models:
+        if Path(item["model_root"]).resolve() == current_root:
+            return item["id"]
+
+    return models[0]["id"] if models else ""
+
+
+def _switch_generator(app: Flask, model_id: str) -> QuestionGenerator:
+    available_models = _discover_available_models(app.config["PROJECT_ROOT"], _generator(app))
+    selected_model = next((item for item in available_models if item["id"] == model_id), None)
+    if selected_model is None:
+        raise ValueError("Model được chọn không hợp lệ hoặc chưa tồn tại trong thư mục dự án.")
+
+    current_model_id = _selected_model_id(app, available_models)
+    if current_model_id != model_id:
+        app.config["GENERATOR"] = build_generator(
+            selected_model["model_root"],
+            prefer_nested_model=bool(selected_model.get("prefer_nested_model")),
+        )
+
+    app.config["SELECTED_MODEL_ID"] = model_id
+    return _generator(app)
+
+
+def _info_payload(app: Flask, active_generator: QuestionGenerator | None = None) -> dict[str, object]:
+    active_generator = active_generator or _generator(app)
+    meta = active_generator.metadata()
+    available_models = _discover_available_models(app.config["PROJECT_ROOT"], active_generator)
+    selected_model_id = _selected_model_id(app, available_models, active_generator)
+    model_name = next(
+        (item["label"] for item in available_models if item["id"] == selected_model_id),
+        _display_model_name(meta),
+    )
+
+    return {
+        "ok": True,
+        "title": APP_TITLE,
+        "model_name": model_name,
+        "selected_model_id": selected_model_id,
+        "available_models": [{"id": item["id"], "label": item["label"]} for item in available_models],
+        "meta": meta,
+    }
+
+
+def create_app(generator: QuestionGenerator | None = None) -> Flask:
+    root = project_root()
+    frontend_root = root / "frontend"
+
+    app = Flask(__name__, static_folder=None)
+    app.json.ensure_ascii = False
+    app.config["GENERATOR"] = generator or build_generator()
+    app.config["PROJECT_ROOT"] = root
+    app.config["FRONTEND_ROOT"] = frontend_root
+    app.config["SELECTED_MODEL_ID"] = ""
+
+    @app.get("/")
+    def index():
+        return send_from_directory(app.config["FRONTEND_ROOT"], "index.html")
+
+    @app.get("/frontend/<path:filename>")
+    def frontend_file(filename: str):
+        return send_from_directory(app.config["FRONTEND_ROOT"], filename)
+
+    @app.get("/assets/<path:filename>")
+    def asset_file(filename: str):
+        return send_from_directory(app.config["PROJECT_ROOT"], filename)
+
+    @app.get("/api/info")
+    def info():
+        return jsonify(_info_payload(app))
+
+    @app.post("/api/model")
+    def set_model():
+        payload = request.get_json(silent=True) or {}
+        model_id = str(payload.get("model_id") or "").strip()
+        if not model_id:
+            return jsonify({"ok": False, "error": "Vui lòng chọn model trước khi chuyển."}), 400
+
+        try:
+            active_generator = _switch_generator(app, model_id)
+        except ValueError as exc:
+            return jsonify({"ok": False, "error": str(exc)}), 404
+
+        return jsonify(_info_payload(app, active_generator))
+
+    @app.post("/api/generate")
+    def generate():
+        payload = request.get_json(silent=True) or {}
+        requested_model_id = str(payload.get("model_id") or "").strip()
+
+        if requested_model_id:
+            try:
+                active_generator = _switch_generator(app, requested_model_id)
+            except ValueError as exc:
+                return jsonify({"ok": False, "error": str(exc)}), 400
+        else:
+            active_generator = _generator(app)
+
+        text = normalize_text(payload.get("text"))
+        if not text:
+            return jsonify({"ok": False, "error": "Vui lòng nhập đoạn văn bản trước khi sinh câu hỏi."}), 400
+
+        raw_count = payload.get("num_questions")
+        if raw_count in (None, ""):
+            count = 100
+        else:
+            try:
+                count = int(raw_count)
+            except (TypeError, ValueError):
+                return jsonify({"ok": False, "error": "Số câu hỏi phải là số nguyên trong khoảng 1 đến 100."}), 400
+
+            if count < 1 or count > QUESTION_LIMIT:
+                return jsonify({"ok": False, "error": f"Số câu hỏi phải nằm trong khoảng 1 đến {QUESTION_LIMIT}."}), 400
+
+        started = time.perf_counter()
+        try:
+            questions = active_generator.generate(text, parse_question_count(count))
+        except Exception as exc:  # noqa: BLE001
+            return jsonify({"ok": False, "error": str(exc)}), 500
+
+        elapsed_ms = round((time.perf_counter() - started) * 1000, 2)
+        info_payload = _info_payload(app, active_generator)
+        return jsonify(
+            {
+                "ok": True,
+                "text": text,
+                "num_questions": count,
+                "questions": questions,
+                "formatted": format_questions(questions),
+                "elapsed_ms": elapsed_ms,
+                "model_name": info_payload["model_name"],
+                "selected_model_id": info_payload["selected_model_id"],
+                "meta": active_generator.metadata(),
+            }
+        )
+
+    return app
+
+
+def _generator(app: Flask) -> QuestionGenerator:
+    generator: QuestionGenerator = app.config["GENERATOR"]
+    return generator

HVU_QA/fine_tune_qg.py

@@ -0,0 +1,556 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from importlib import metadata
+from inspect import signature
+from pathlib import Path
+from typing import Any
+
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+
+
+def raise_missing_dependency_error(exc: ModuleNotFoundError) -> None:
+    root = Path(__file__).resolve().parent
+    script = Path(__file__).resolve()
+    requirements = root / "requirements.txt"
+    venv_python = root / "venv" / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
+    lines = [f"Thiếu thư viện Python: {exc.name}", f"Interpreter hiện tại: {sys.executable}"]
+    if venv_python.exists():
+        lines.extend([f"Venv của project: {venv_python}", f"Chạy lại bằng: {venv_python} {script}"])
+    if requirements.exists():
+        lines.extend(
+            [
+                "Hoặc cài dependencies cho interpreter hiện tại bằng:",
+                f"{sys.executable} -m pip install -r {requirements}",
+            ]
+        )
+    raise SystemExit("\n".join(lines)) from exc
+
+
+try:
+    import torch
+    from datasets import Dataset
+    from transformers import (
+        AutoModelForSeq2SeqLM,
+        AutoTokenizer,
+        DataCollatorForSeq2Seq,
+        EarlyStoppingCallback,
+        Seq2SeqTrainer,
+        Seq2SeqTrainingArguments,
+        set_seed,
+    )
+    from transformers.trainer_utils import get_last_checkpoint
+except ModuleNotFoundError as exc:
+    raise_missing_dependency_error(exc)
+
+
+def normalize_text(text: Any) -> str:
+    return " ".join(str(text or "").split())
+
+
+def dedupe(items) -> list[str]:
+    seen, output = set(), []
+    for item in items:
+        if item and item not in seen:
+            seen.add(item)
+            output.append(item)
+    return output
+
+
+def save_json(data: dict[str, Any], path: Path) -> None:
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def get_installed_version(package_name: str) -> tuple[int, ...]:
+    try:
+        version = metadata.version(package_name)
+    except metadata.PackageNotFoundError:
+        return ()
+
+    parts = []
+    for chunk in version.replace("-", ".").split("."):
+        digits = "".join(ch for ch in chunk if ch.isdigit())
+        if not digits:
+            break
+        parts.append(int(digits))
+    return tuple(parts)
+
+
+def supports_data_seed() -> bool:
+    return get_installed_version("accelerate") >= (1, 1, 0)
+
+
+def run_nvidia_smi(query: str) -> list[list[str]]:
+    try:
+        result = subprocess.run(
+            ["nvidia-smi", f"--query-{query}", "--format=csv,noheader,nounits"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        return []
+
+    return [
+        [part.strip() for part in line.split(",")]
+        for line in result.stdout.strip().splitlines()
+        if line.strip()
+    ]
+
+
+def query_gpu_memory():
+    rows = run_nvidia_smi("gpu=memory.total,memory.used,memory.free")
+    if not rows or len(rows[0]) < 3:
+        return None
+    try:
+        total_mb, used_mb, free_mb = (int(value) for value in rows[0][:3])
+    except ValueError:
+        return None
+    return {"total_mb": total_mb, "used_mb": used_mb, "free_mb": free_mb}
+
+
+def query_gpu_processes() -> list[dict[str, Any]]:
+    processes = []
+    for row in run_nvidia_smi("compute-apps=pid,process_name,used_memory"):
+        if len(row) != 3:
+            continue
+        try:
+            pid = int(row[0])
+            used_memory_mb = int(row[2])
+        except ValueError:
+            continue
+        processes.append({"pid": pid, "process_name": row[1], "used_memory_mb": used_memory_mb})
+    return processes
+
+
+def format_memory_mb(memory_mb: int) -> str:
+    return f"{memory_mb} MiB ({memory_mb / 1024:.2f} GiB)"
+
+
+def active_gpu_processes() -> list[dict[str, Any]]:
+    current_pid = os.getpid()
+    return sorted(
+        [proc for proc in query_gpu_processes() if proc["pid"] != current_pid and proc["used_memory_mb"] > 0],
+        key=lambda item: item["used_memory_mb"],
+        reverse=True,
+    )
+
+
+def append_process_lines(lines: list[str], header: str, processes: list[dict[str, Any]]) -> None:
+    if not processes:
+        return
+    lines.append(header)
+    lines.extend(
+        f"- PID {proc['pid']} | {proc['process_name']} | {format_memory_mb(proc['used_memory_mb'])}"
+        for proc in processes
+    )
+
+
+def ensure_device_ready(args) -> None:
+    if args.device == "cpu":
+        return
+    if not torch.cuda.is_available():
+        if args.device == "cuda":
+            raise SystemExit("Bạn đã chọn --device cuda nhưng môi trường hiện tại không có CUDA.")
+        return
+    if args.skip_gpu_preflight:
+        return
+
+    gpu_memory = query_gpu_memory()
+    if gpu_memory is None or gpu_memory["free_mb"] >= args.min_free_gpu_mb:
+        return
+
+    lines = [
+        "GPU không đủ bộ nhớ để bắt đầu train ổn định.",
+        f"GPU free: {format_memory_mb(gpu_memory['free_mb'])} / total: {format_memory_mb(gpu_memory['total_mb'])}.",
+        f"Ngưỡng tối thiểu hiện tại: {format_memory_mb(args.min_free_gpu_mb)}.",
+    ]
+    append_process_lines(lines, "Các tiến trình CUDA đang chiếm GPU:", active_gpu_processes())
+    lines.extend(
+        [
+            "Cách xử lý:",
+            "- Giải phóng tiến trình đang chiếm GPU rồi chạy lại.",
+            "- Hoặc train trên CPU bằng `python fine_tune_qg.py --device cpu`.",
+            "- Nếu GPU đã rảnh mà vẫn thiếu VRAM, thử `--per_device_train_batch_size 1 --per_device_eval_batch_size 1 --gradient_accumulation_steps 16 --gradient_checkpointing`.",
+            "- Nếu bạn vẫn muốn thử trên GPU hiện tại, thêm `--skip_gpu_preflight` để bỏ qua kiểm tra này.",
+        ]
+    )
+    raise SystemExit("\n".join(lines))
+
+
+def raise_cuda_oom(args) -> None:
+    gpu_memory = query_gpu_memory()
+    lines = ["Train thất bại do CUDA out of memory."]
+    if gpu_memory is not None:
+        lines.append(
+            f"VRAM hiện tại: free {format_memory_mb(gpu_memory['free_mb'])}, used {format_memory_mb(gpu_memory['used_mb'])}, total {format_memory_mb(gpu_memory['total_mb'])}."
+        )
+    append_process_lines(lines, "Các tiến trình khác đang dùng GPU:", active_gpu_processes())
+    lines.extend(
+        [
+            "Gợi ý:",
+            "- Dừng tiến trình CUDA khác rồi chạy lại.",
+            f"- Hoặc chạy trên CPU: python fine_tune_qg.py --device cpu --output_dir {args.output_dir}-cpu",
+            "- Khi GPU rảnh, nếu vẫn thiếu VRAM, giảm batch: `--per_device_train_batch_size 1 --per_device_eval_batch_size 1 --gradient_accumulation_steps 16 --gradient_checkpointing`.",
+        ]
+    )
+    raise SystemExit("\n".join(lines))
+
+
+def build_source(title: str, context: str, answer: str, task_prefix: str) -> str:
+    parts = [f"{task_prefix}:"]
+    if title:
+        parts.append(f"tiêu đề: {title}")
+    parts.extend((f"ngữ cảnh: {context}", f"đáp án: {answer}"))
+    return "\n".join(parts)
+
+
+def load_squad_qg_examples(
+    file_path: str,
+    use_all_answers: bool = True,
+    task_prefix: str = "sinh câu hỏi",
+    require_answer_in_context: bool = False,
+) -> tuple[list[dict[str, str]], dict[str, int]]:
+    data = json.loads(Path(file_path).read_text(encoding="utf-8"))
+    examples = []
+    stats = {
+        "articles": 0,
+        "paragraphs": 0,
+        "qas": 0,
+        "examples": 0,
+        "skipped_impossible": 0,
+        "skipped_no_context": 0,
+        "skipped_no_question": 0,
+        "skipped_no_answers": 0,
+        "skipped_answer_not_in_context": 0,
+        "answers_not_in_context_but_kept": 0,
+    }
+
+    for article in data.get("data", []):
+        stats["articles"] += 1
+        title = normalize_text(article.get("title"))
+        for paragraph in article.get("paragraphs", []):
+            stats["paragraphs"] += 1
+            context = normalize_text(paragraph.get("context"))
+            if not context:
+                stats["skipped_no_context"] += 1
+                continue
+
+            for qa in paragraph.get("qas", []):
+                stats["qas"] += 1
+                question = normalize_text(qa.get("question"))
+                if qa.get("is_impossible", False):
+                    stats["skipped_impossible"] += 1
+                    continue
+                if not question:
+                    stats["skipped_no_question"] += 1
+                    continue
+
+                answers = dedupe(normalize_text(answer.get("text")) for answer in qa.get("answers", []))
+                if not answers:
+                    stats["skipped_no_answers"] += 1
+                    continue
+                if not use_all_answers:
+                    answers = answers[:1]
+
+                for answer in answers:
+                    in_context = answer in context
+                    if require_answer_in_context and not in_context:
+                        stats["skipped_answer_not_in_context"] += 1
+                        continue
+                    if not in_context:
+                        stats["answers_not_in_context_but_kept"] += 1
+
+                    examples.append(
+                        {
+                            "source": build_source(title, context, answer, task_prefix),
+                            "target": question,
+                        }
+                    )
+                    stats["examples"] += 1
+
+    return examples, stats
+
+
+def preprocess_function(batch, tokenizer, max_source_length: int, max_target_length: int) -> dict[str, Any]:
+    model_inputs = tokenizer(batch["source"], max_length=max_source_length, truncation=True)
+    model_inputs["labels"] = tokenizer(
+        text_target=batch["target"],
+        max_length=max_target_length,
+        truncation=True,
+    )["input_ids"]
+    return model_inputs
+
+
+def build_supported_kwargs(cls, kwargs: dict[str, Any], aliases=None) -> dict[str, Any]:
+    params = set(signature(cls.__init__).parameters)
+    aliases = aliases or {}
+    resolved = {}
+    for key, value in kwargs.items():
+        if value is None:
+            continue
+        target = key if key in params else aliases.get(key)
+        if target in params:
+            resolved[target] = value
+    return resolved
+
+
+def build_training_args(args, has_eval: bool):
+    kwargs = {
+        "output_dir": args.output_dir,
+        "overwrite_output_dir": False,
+        "learning_rate": args.learning_rate,
+        "per_device_train_batch_size": args.per_device_train_batch_size,
+        "per_device_eval_batch_size": args.per_device_eval_batch_size,
+        "gradient_accumulation_steps": args.gradient_accumulation_steps,
+        "weight_decay": args.weight_decay,
+        "num_train_epochs": args.num_train_epochs,
+        "warmup_ratio": args.warmup_ratio,
+        "logging_strategy": "steps",
+        "logging_steps": args.logging_steps,
+        "save_strategy": args.save_strategy_type,
+        "save_steps": args.save_steps if args.save_strategy_type == "steps" else None,
+        "save_total_limit": args.save_total_limit,
+        "report_to": "none",
+        "fp16": args.fp16,
+        "bf16": args.bf16,
+        "predict_with_generate": False,
+        "generation_max_length": args.max_target_length,
+        "dataloader_num_workers": args.dataloader_num_workers,
+        "dataloader_pin_memory": not args.no_pin_memory,
+        "save_only_model": args.save_only_model,
+        "restore_callback_states_from_checkpoint": args.restore_callback_states_from_checkpoint,
+        "torch_empty_cache_steps": args.torch_empty_cache_steps or None,
+        "seed": args.seed,
+        "data_seed": args.seed if supports_data_seed() else None,
+        "use_cpu": True if args.device == "cpu" else None,
+        "gradient_checkpointing": True if args.gradient_checkpointing else None,
+        "load_best_model_at_end": has_eval,
+        "metric_for_best_model": "eval_loss" if has_eval else None,
+        "greater_is_better": False if has_eval else None,
+        "eval_strategy": args.save_strategy_type if has_eval else None,
+        "eval_steps": args.eval_steps if has_eval and args.save_strategy_type == "steps" else None,
+    }
+    return Seq2SeqTrainingArguments(
+        **build_supported_kwargs(
+            Seq2SeqTrainingArguments,
+            kwargs,
+            aliases={"eval_strategy": "evaluation_strategy", "use_cpu": "no_cuda"},
+        )
+    )
+
+
+def resolve_resume_checkpoint(args):
+    if args.resume_checkpoint:
+        if not Path(args.resume_checkpoint).is_dir():
+            raise FileNotFoundError(f"Không tìm thấy resume_checkpoint: {args.resume_checkpoint}")
+        return args.resume_checkpoint
+    if args.resume_from_latest and Path(args.output_dir).is_dir():
+        return get_last_checkpoint(args.output_dir)
+    return None
+
+
+def validate_args(args, has_eval: bool) -> None:
+    if has_eval and args.save_strategy_type == "steps":
+        if args.eval_steps <= 0 or args.save_steps <= 0:
+            raise ValueError("save_steps và eval_steps phải > 0")
+        if args.save_steps % args.eval_steps != 0:
+            raise ValueError("save_steps phải là bội số của eval_steps")
+    if args.save_only_model and (args.resume_from_latest or args.resume_checkpoint):
+        print("Cảnh báo: save_only_model sẽ không resume train đầy đủ được.")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser()
+    add = parser.add_argument
+
+    add("--train_file", default="40k_train.json")
+    add("--validation_file", default=None)
+    add("--output_dir", default="t5-viet-qg-finetuned")
+    add("--model_name", default="VietAI/vit5-base")
+    add("--task_prefix", default="sinh câu hỏi")
+
+    add("--max_source_length", type=int, default=512)
+    add("--max_target_length", type=int, default=64)
+    add("--val_ratio", type=float, default=0.1)
+
+    add("--per_device_train_batch_size", type=int, default=4)
+    add("--per_device_eval_batch_size", type=int, default=4)
+    add("--gradient_accumulation_steps", type=int, default=4)
+    add("--learning_rate", type=float, default=1e-4)
+    add("--weight_decay", type=float, default=0.01)
+    add("--warmup_ratio", type=float, default=0.05)
+    add("--num_train_epochs", type=int, default=3)
+    add("--logging_steps", type=int, default=50)
+    add("--seed", type=int, default=42)
+    add("--early_stopping_patience", type=int, default=2)
+
+    add("--save_strategy_type", default="steps", choices=["steps", "epoch"])
+    add("--save_steps", type=int, default=500)
+    add("--eval_steps", type=int, default=500)
+    add("--save_total_limit", type=int, default=1)
+
+    parser.set_defaults(resume_from_latest=True)
+    add("--resume_from_latest", dest="resume_from_latest", action="store_true")
+    add("--no_resume_from_latest", dest="resume_from_latest", action="store_false")
+    add("--resume_checkpoint", default=None)
+    add("--save_only_model", action="store_true")
+    add("--restore_callback_states_from_checkpoint", action="store_true")
+
+    add("--fp16", action="store_true")
+    add("--bf16", action="store_true")
+    add("--gradient_checkpointing", action="store_true")
+    add("--dataloader_num_workers", type=int, default=0)
+    add("--no_pin_memory", action="store_true")
+    add("--torch_empty_cache_steps", type=int, default=0)
+    add("--device", default="auto", choices=["auto", "cuda", "cpu"])
+    add("--min_free_gpu_mb", type=int, default=4096)
+    add("--skip_gpu_preflight", action="store_true")
+
+    add("--use_first_answer_only", action="store_true")
+    add("--require_answer_in_context", action="store_true")
+    return parser
+
+
+def load_datasets(args):
+    load_kwargs = {
+        "use_all_answers": not args.use_first_answer_only,
+        "task_prefix": args.task_prefix,
+        "require_answer_in_context": args.require_answer_in_context,
+    }
+    train_examples, train_stats = load_squad_qg_examples(args.train_file, **load_kwargs)
+    if not train_examples:
+        raise ValueError("Không có dữ liệu train hợp lệ sau khi tiền xử lý.")
+
+    train_dataset = Dataset.from_list(train_examples)
+    val_dataset = None
+    val_stats = None
+
+    if args.validation_file:
+        val_examples, val_stats = load_squad_qg_examples(args.validation_file, **load_kwargs)
+        if not val_examples:
+            raise ValueError("Không có dữ liệu validation hợp lệ sau khi tiền xử lý.")
+        val_dataset = Dataset.from_list(val_examples)
+    elif args.val_ratio > 0 and len(train_dataset) > 10:
+        split = train_dataset.train_test_split(test_size=args.val_ratio, seed=args.seed)
+        train_dataset, val_dataset = split["train"], split["test"]
+
+    return train_dataset, val_dataset, train_stats, val_stats
+
+
+def tokenize_dataset(dataset, tokenizer, args):
+    return dataset.map(
+        lambda batch: preprocess_function(batch, tokenizer, args.max_source_length, args.max_target_length),
+        batched=True,
+        remove_columns=dataset.column_names,
+    )
+
+
+def build_trainer(model, tokenizer, training_args, train_dataset, eval_dataset, args):
+    kwargs = {
+        "model": model,
+        "args": training_args,
+        "data_collator": DataCollatorForSeq2Seq(tokenizer=tokenizer, model=model),
+        "train_dataset": train_dataset,
+        "eval_dataset": eval_dataset,
+        "callbacks": [EarlyStoppingCallback(early_stopping_patience=args.early_stopping_patience)]
+        if eval_dataset is not None
+        else None,
+        "processing_class": tokenizer,
+    }
+    return Seq2SeqTrainer(
+        **build_supported_kwargs(Seq2SeqTrainer, kwargs, aliases={"processing_class": "tokenizer"})
+    )
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    set_seed(args.seed)
+    ensure_device_ready(args)
+
+    raw_train_dataset, raw_val_dataset, train_stats, val_stats = load_datasets(args)
+    has_eval = raw_val_dataset is not None
+    validate_args(args, has_eval)
+
+    tokenizer = AutoTokenizer.from_pretrained(args.model_name)
+    model = AutoModelForSeq2SeqLM.from_pretrained(args.model_name)
+
+    if args.gradient_checkpointing:
+        model.gradient_checkpointing_enable()
+        if hasattr(model.config, "use_cache"):
+            model.config.use_cache = False
+
+    tokenized_train = tokenize_dataset(raw_train_dataset, tokenizer, args)
+    tokenized_val = tokenize_dataset(raw_val_dataset, tokenizer, args) if has_eval else None
+    trainer = build_trainer(
+        model,
+        tokenizer,
+        build_training_args(args, has_eval),
+        tokenized_train,
+        tokenized_val,
+        args,
+    )
+
+    resume_checkpoint = resolve_resume_checkpoint(args)
+    try:
+        train_result = trainer.train(resume_from_checkpoint=resume_checkpoint)
+    except torch.OutOfMemoryError:
+        raise_cuda_oom(args)
+    except RuntimeError as exc:
+        if "CUDA out of memory" in str(exc):
+            raise_cuda_oom(args)
+        raise
+
+    trainer.save_state()
+
+    export_dir = output_dir / ("best-model" if has_eval else "final-model")
+    export_dir.mkdir(parents=True, exist_ok=True)
+    for path in (export_dir, output_dir):
+        trainer.save_model(str(path))
+        tokenizer.save_pretrained(str(path))
+
+    train_metrics = train_result.metrics
+    trainer.log_metrics("train", train_metrics)
+    trainer.save_metrics("train", train_metrics)
+
+    eval_metrics = None
+    if has_eval:
+        eval_metrics = trainer.evaluate(
+            max_length=args.max_target_length,
+            num_beams=4,
+            metric_key_prefix="eval",
+        )
+        trainer.log_metrics("eval", eval_metrics)
+        trainer.save_metrics("eval", eval_metrics)
+
+    save_json(
+        {
+            "base_model": args.model_name,
+            "task_prefix": args.task_prefix,
+            "output_dir": str(output_dir),
+            "export_dir": str(export_dir),
+            "train_size": len(raw_train_dataset),
+            "val_size": len(raw_val_dataset) if raw_val_dataset is not None else 0,
+            "train_stats": train_stats,
+            "val_stats": val_stats,
+            "best_model_checkpoint": trainer.state.best_model_checkpoint,
+            "best_metric": trainer.state.best_metric,
+            "resumed_from_checkpoint": resume_checkpoint,
+            "args": vars(args),
+            "train_metrics": train_metrics,
+            "eval_metrics": eval_metrics,
+        },
+        output_dir / "training_summary.json",
+    )
+
+
+if __name__ == "__main__":
+    main()

HVU_QA/frontend/app.js

@@ -0,0 +1,1233 @@
+const STORAGE_KEY = "hvu_qa_history_v1";
+const QUESTION_COUNT_LIMITS = { min: 0, max: 100, default: 0 };
+const SAMPLE_SNIPPETS = [
+  {
+    id: "luat-giao-duc-dai-hoc",
+    title: "Luật Giáo dục đại học",
+    preview: "Quy định về cơ sở giáo dục đại học, chương trình đào tạo và quyền tự chủ.",
+    text: "Cơ sở giáo dục đại học có nhiệm vụ tổ chức hoạt động đào tạo, nghiên cứu khoa học, hợp tác quốc tế và phục vụ cộng đồng theo quy định của pháp luật. Cơ sở giáo dục đại học được thực hiện quyền tự chủ gắn với trách nhiệm giải trình, bảo đảm chất lượng đào tạo, công khai điều kiện bảo đảm chất lượng và kết quả hoạt động với cơ quan quản lý nhà nước, người học và xã hội.",
+    suggestedCount: 5,
+  },
+  {
+    id: "bo-luat-lao-dong",
+    title: "Bộ luật Lao động",
+    preview: "Nội dung về hợp đồng lao động, quyền và nghĩa vụ của người lao động.",
+    text: "Hợp đồng lao động là sự thỏa thuận giữa người lao động và người sử dụng lao động về việc làm có trả công, tiền lương, điều kiện lao động, quyền và nghĩa vụ của mỗi bên. Khi giao kết hợp đồng lao động, các bên phải tuân thủ nguyên tắc tự nguyện, bình đẳng, thiện chí, hợp tác và trung thực; không được thỏa thuận nội dung làm giảm quyền lợi của người lao động so với quy định của pháp luật.",
+    suggestedCount: 4,
+  },
+  {
+    id: "luat-an-toan-thong-tin-mang",
+    title: "Luật An toàn thông tin mạng",
+    preview: "Yêu cầu bảo vệ thông tin, phòng ngừa rủi ro và trách nhiệm của tổ chức, cá nhân.",
+    text: "Cơ quan, tổ chức, cá nhân tham gia hoạt động trên môi trường mạng có trách nhiệm bảo đảm an toàn thông tin mạng; áp dụng biện pháp quản lý, kỹ thuật phù hợp để phòng ngừa, phát hiện, ngăn chặn và xử lý nguy cơ mất an toàn thông tin. Việc thu thập, xử lý và sử dụng thông tin trên môi trường mạng phải đúng mục đích, đúng thẩm quyền và bảo đảm quyền, lợi ích hợp pháp của cơ quan, tổ chức, cá nhân có liên quan.",
+    suggestedCount: 5,
+  },
+];
+const AUTHOR_PROFILES = [
+  {
+    id: "do-cao-dang",
+    name: "Đỗ Cao Đăng",
+    role: "Sinh viên thực hiện",
+    summary: "Thành viên nhóm thực hiện đề tài.",
+    description: "Sinh viên tham gia triển khai và hoàn thiện hệ thống.",
+    unit: "Khoa Kỹ thuật - Công nghệ",
+    email: "docaodang532001@gmail.com",
+  },
+  {
+    id: "hoang-tuan-ngoc",
+    name: "Hoàng Tuấn Ngọc",
+    role: "Sinh viên thực hiện",
+    summary: "Thành viên nhóm thực hiện đề tài.",
+    description: "Sinh viên đồng thực hiện và phối hợp phát triển nội dung cho hệ thống.",
+    unit: "Khoa Kỹ thuật - Công nghệ",
+    email: "hoangtuanngoc2005@gmail.com",
+  },
+  {
+    id: "nguyen-tien-ha",
+    name: "TS. Nguyễn Tiến Hà",
+    role: "Giảng viên hướng dẫn",
+    summary: "Giảng viên hướng dẫn chuyên môn cho đề tài.",
+    description: "Giảng viên hướng dẫn học thuật và định hướng chuyên môn cho đề tài.",
+    unit: "Khoa Kỹ thuật - Công nghệ",
+    email: "nguyentienha@hvu.edu.vn",
+  },
+];
+
+const state = {
+  history: loadHistory(),
+  selectedId: null,
+  thread: [],
+  availableModels: [],
+  activeModelId: "",
+  isSwitchingModel: false,
+  selectedAuthorId: null,
+  isAuthorPanelOpen: false,
+};
+
+const voiceState = {
+  isSupported: false,
+  isListening: false,
+  recognition: null,
+  discardOnStop: false,
+  stopRequested: false,
+  baseText: "",
+  finalTranscript: "",
+  interimTranscript: "",
+  lastErrorMessage: "",
+};
+
+const elements = {
+  menuToggle: document.getElementById("menuToggle"),
+  sidebarContent: document.getElementById("sidebarContent"),
+  modelSelect: document.getElementById("modelSelect"),
+  deviceStatus: document.getElementById("deviceStatus"),
+  modelStatus: document.getElementById("modelStatus"),
+  historyList: document.getElementById("historyList"),
+  clearHistory: document.getElementById("clearHistory"),
+  resultCard: document.getElementById("resultCard"),
+  form: document.getElementById("generatorForm"),
+  sourceShell: document.getElementById("sourceShell"),
+  sourceText: document.getElementById("sourceText"),
+  voiceInputButton: document.getElementById("voiceInputButton"),
+  voiceStatus: document.getElementById("voiceStatus"),
+  questionCount: document.getElementById("questionCount"),
+  questionCountValue: document.getElementById("questionCountValue"),
+  decreaseCount: document.getElementById("decreaseCount"),
+  increaseCount: document.getElementById("increaseCount"),
+  generateButton: document.getElementById("generateButton"),
+  authorToggle: document.getElementById("authorToggle"),
+  authorContent: document.getElementById("authorContent"),
+  authorList: document.getElementById("authorList"),
+  copyrightLine: document.getElementById("copyrightLine"),
+  heroTitle: document.getElementById("heroTitle"),
+  landingPanel: document.getElementById("landingPanel"),
+  sampleList: document.getElementById("sampleList"),
+  landingRuntimeBadge: document.getElementById("landingRuntimeBadge"),
+  landingStatusText: document.getElementById("landingStatusText"),
+  landingModelName: document.getElementById("landingModelName"),
+  landingDeviceName: document.getElementById("landingDeviceName"),
+  landingModelCount: document.getElementById("landingModelCount"),
+};
+
+bootstrap();
+
+function bootstrap() {
+  hydrateQuestionCount();
+  syncSidebar(false);
+  renderHistory();
+  renderAuthors();
+  renderLandingSamples();
+  attachEvents();
+  hideResultCard();
+  activateHeroTitle();
+  syncCopyright();
+  autoResizeTextarea();
+  initVoiceInput();
+  syncLandingPanel();
+  fetchInfo();
+}
+
+function hydrateQuestionCount() {
+  syncQuestionCount(elements.questionCount.value);
+}
+
+function attachEvents() {
+  elements.menuToggle.addEventListener("click", () => {
+    syncSidebar(!document.body.classList.contains("sidebar-open"));
+  });
+
+  document.addEventListener("keydown", (event) => {
+    if (event.key === "Escape" && document.body.classList.contains("sidebar-open")) {
+      syncSidebar(false);
+    }
+  });
+
+  elements.clearHistory.addEventListener("click", () => {
+    stopVoiceInput(true);
+    state.history = [];
+    state.selectedId = null;
+    state.thread = [];
+    persistHistory();
+    renderHistory();
+    hideResultCard();
+  });
+
+  elements.historyList.addEventListener("click", (event) => {
+    const button = event.target.closest("[data-history-id]");
+    if (!button) return;
+
+    stopVoiceInput(true);
+
+    const entry = state.history.find((item) => item.id === button.dataset.historyId);
+    if (!entry) return;
+
+    state.selectedId = entry.id;
+    state.thread = [entry];
+    elements.sourceText.value = entry.text || entry.title || "";
+    autoResizeTextarea();
+    renderHistory();
+    renderThread();
+  });
+
+  elements.resultCard.addEventListener("click", async (event) => {
+    const button = event.target.closest("[data-copy-entry-id][data-copy-target]");
+    if (!button) return;
+
+    const entryId = button.dataset.copyEntryId;
+    const target = button.dataset.copyTarget;
+    const textToCopy = buildCopyText(entryId, target);
+    if (!textToCopy) return;
+
+    const copied = await copyToClipboard(textToCopy);
+    if (!copied) return;
+
+    button.classList.add("is-copied");
+    button.setAttribute("aria-label", "Đã sao chép");
+    window.setTimeout(() => {
+      button.classList.remove("is-copied");
+      button.setAttribute("aria-label", "Sao chép");
+    }, 1400);
+  });
+
+  elements.sourceText.addEventListener("input", () => {
+    autoResizeTextarea();
+  });
+
+  elements.sampleList?.addEventListener("click", (event) => {
+    const button = event.target.closest("[data-sample-id]");
+    if (!button) return;
+
+    const sample = SAMPLE_SNIPPETS.find((item) => item.id === button.dataset.sampleId);
+    if (!sample) return;
+
+    stopVoiceInput(true);
+    elements.sourceText.value = sample.text;
+    if (Number(elements.questionCount.value || QUESTION_COUNT_LIMITS.default) <= 0) {
+      syncQuestionCount(sample.suggestedCount || 5);
+    }
+    autoResizeTextarea();
+    elements.sourceText.focus();
+  });
+
+  elements.voiceInputButton.addEventListener("click", () => {
+    toggleVoiceInput();
+  });
+
+  elements.modelSelect.addEventListener("change", () => {
+    const nextModelId = String(elements.modelSelect.value || "").trim();
+    if (!nextModelId || nextModelId === state.activeModelId || state.isSwitchingModel) {
+      return;
+    }
+    switchModel(nextModelId);
+  });
+
+  elements.authorToggle?.addEventListener("click", () => {
+    state.isAuthorPanelOpen = !state.isAuthorPanelOpen;
+    renderAuthors();
+  });
+
+  elements.authorList?.addEventListener("click", (event) => {
+    const button = event.target.closest("[data-author-id]");
+    if (!button) return;
+    selectAuthor(button.dataset.authorId);
+  });
+
+  elements.decreaseCount.addEventListener("click", () => {
+    syncQuestionCount(Number(elements.questionCount.value || QUESTION_COUNT_LIMITS.default) - 1);
+  });
+
+  elements.increaseCount.addEventListener("click", () => {
+    syncQuestionCount(Number(elements.questionCount.value || QUESTION_COUNT_LIMITS.default) + 1);
+  });
+
+  elements.form.addEventListener("submit", async (event) => {
+    event.preventDefault();
+
+    if (state.isSwitchingModel) {
+      renderMessage("Vui lòng chờ chuyển model xong rồi thử lại.");
+      return;
+    }
+
+    if (voiceState.isListening) {
+      renderMessage("Vui lòng dừng micro trước khi sinh câu hỏi.");
+      return;
+    }
+
+    const text = elements.sourceText.value.trim();
+    const numQuestions = Number(elements.questionCount.value || String(QUESTION_COUNT_LIMITS.default));
+
+    if (!text) {
+      renderMessage("Vui lòng nhập đoạn văn bản trước khi sinh câu hỏi.");
+      elements.sourceText.focus();
+      return;
+    }
+
+    if (numQuestions <= 0) {
+      renderMessage("Vui lòng tăng số câu hỏi lên ít nhất 1.");
+      elements.increaseCount.focus();
+      return;
+    }
+
+    const pendingEntry = {
+      id: makeId(),
+      title: shrink(text, 52),
+      text,
+      questions: [],
+      elapsedMs: null,
+      device: null,
+      count: numQuestions,
+      createdAt: new Date().toISOString(),
+      status: "pending",
+      errorMessage: "",
+    };
+
+    state.thread = [...state.thread, pendingEntry];
+    renderThread();
+    elements.sourceText.value = "";
+    autoResizeTextarea();
+
+    setLoading(true);
+
+    try {
+      const response = await fetch("/api/generate", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model_id: state.activeModelId || undefined,
+          text,
+          num_questions: numQuestions,
+        }),
+      });
+      const payload = await response.json();
+
+      if (!response.ok || !payload.ok) {
+        throw new Error(payload.error || "Không thể sinh câu hỏi lúc này.");
+      }
+
+      const entry = {
+        id: pendingEntry.id,
+        title: shrink(text, 52),
+        text: payload.text,
+        questions: payload.questions,
+        elapsedMs: payload.elapsed_ms,
+        device: payload.meta.active_device || payload.meta.predicted_device,
+        count: payload.questions?.length || numQuestions,
+        createdAt: pendingEntry.createdAt,
+        status: "done",
+        errorMessage: "",
+      };
+
+      state.selectedId = entry.id;
+      state.history = [entry, ...state.history.filter((item) => item.questions?.length)].slice(0, 10);
+      state.thread = state.thread.map((item) => (item.id === pendingEntry.id ? entry : item));
+      persistHistory();
+      renderHistory();
+      renderThread();
+    } catch (error) {
+      state.thread = state.thread.map((item) =>
+        item.id === pendingEntry.id
+          ? {
+              ...item,
+              status: "error",
+              errorMessage: error.message || "Có lỗi xảy ra khi sinh câu hỏi.",
+            }
+          : item,
+      );
+      renderThread();
+    } finally {
+      setLoading(false);
+    }
+  });
+}
+
+function syncQuestionCount(value) {
+  const parsedValue = Number(value);
+  const normalizedValue = Number.isFinite(parsedValue) ? Math.trunc(parsedValue) : QUESTION_COUNT_LIMITS.default;
+  const safeValue = Math.min(
+    QUESTION_COUNT_LIMITS.max,
+    Math.max(QUESTION_COUNT_LIMITS.min, normalizedValue),
+  );
+  const isLoading = isInterfaceBusy();
+
+  elements.questionCount.value = String(safeValue);
+  elements.questionCountValue.textContent = String(safeValue);
+  elements.decreaseCount.disabled = isLoading || safeValue <= QUESTION_COUNT_LIMITS.min;
+  elements.increaseCount.disabled = isLoading || safeValue >= QUESTION_COUNT_LIMITS.max;
+}
+
+function syncSidebar(isOpen) {
+  document.body.classList.toggle("sidebar-open", isOpen);
+  elements.menuToggle.setAttribute("aria-expanded", String(isOpen));
+  elements.sidebarContent.setAttribute("aria-hidden", String(!isOpen));
+}
+
+function initVoiceInput() {
+  const SpeechRecognitionApi = window.SpeechRecognition || window.webkitSpeechRecognition;
+
+  if (!SpeechRecognitionApi) {
+    voiceState.isSupported = false;
+    syncVoiceUi(buildVoiceUnsupportedMessage(), "error");
+    return;
+  }
+
+  if (!canUseBrowserVoiceInput()) {
+    voiceState.isSupported = false;
+    syncVoiceUi(buildVoiceOriginMessage(), "error");
+    return;
+  }
+
+  voiceState.recognition = createSpeechRecognition(SpeechRecognitionApi);
+  voiceState.isSupported = true;
+  syncVoiceUi("");
+}
+
+function toggleVoiceInput() {
+  if (!voiceState.isSupported) {
+    syncVoiceUi(
+      canUseBrowserVoiceInput() ? buildVoiceUnsupportedMessage() : buildVoiceOriginMessage(),
+      "error",
+    );
+    return;
+  }
+
+  if (voiceState.isListening) {
+    stopVoiceInput(false);
+    return;
+  }
+
+  startVoiceInput();
+}
+
+function startVoiceInput() {
+  if (!voiceState.recognition) {
+    syncVoiceUi(buildVoiceUnsupportedMessage(), "error");
+    return;
+  }
+
+  try {
+    voiceState.baseText = elements.sourceText.value.trimEnd();
+    voiceState.finalTranscript = "";
+    voiceState.interimTranscript = "";
+    voiceState.discardOnStop = false;
+    voiceState.stopRequested = false;
+    voiceState.lastErrorMessage = "";
+    syncVoiceUi("Đang bật nhận giọng nói...");
+    voiceState.recognition.start();
+  } catch (error) {
+    voiceState.discardOnStop = false;
+    syncVoiceUi(humanizeVoiceStartError(error), "error");
+  }
+}
+
+function stopVoiceInput(discardRecording = false) {
+  if (!voiceState.isListening || !voiceState.recognition) {
+    return;
+  }
+
+  voiceState.discardOnStop = Boolean(discardRecording);
+  voiceState.stopRequested = true;
+
+  if (discardRecording) {
+    voiceState.finalTranscript = "";
+    voiceState.interimTranscript = "";
+    elements.sourceText.value = voiceState.baseText;
+    autoResizeTextarea();
+  }
+
+  syncVoiceUi(discardRecording ? "Đang hủy nhận giọng nói..." : "Đang dừng micro...");
+  voiceState.recognition.stop();
+}
+
+function createSpeechRecognition(SpeechRecognitionApi) {
+  const recognition = new SpeechRecognitionApi();
+  recognition.lang = "vi-VN";
+  recognition.continuous = true;
+  recognition.interimResults = true;
+  recognition.maxAlternatives = 1;
+
+  recognition.onstart = () => {
+    voiceState.isListening = true;
+    voiceState.stopRequested = false;
+    voiceState.lastErrorMessage = "";
+    syncVoiceUi("Đang nghe... hãy nói vào micro.");
+  };
+
+  recognition.onresult = (event) => {
+    if (voiceState.discardOnStop) {
+      return;
+    }
+
+    let nextFinalTranscript = "";
+    let nextInterimTranscript = "";
+
+    for (let index = event.resultIndex; index < event.results.length; index += 1) {
+      const transcript = String(event.results[index][0]?.transcript || "").trim();
+      if (!transcript) continue;
+
+      if (event.results[index].isFinal) {
+        nextFinalTranscript = appendSpeechChunk(nextFinalTranscript, transcript);
+      } else {
+        nextInterimTranscript = appendSpeechChunk(nextInterimTranscript, transcript);
+      }
+    }
+
+    if (nextFinalTranscript) {
+      voiceState.finalTranscript = appendSpeechChunk(voiceState.finalTranscript, nextFinalTranscript);
+    }
+
+    voiceState.interimTranscript = nextInterimTranscript;
+    syncSpeechDraft();
+    syncVoiceUi("Đang nghe... bấm lại nếu muốn dừng.");
+  };
+
+  recognition.onerror = (event) => {
+    console.warn("SpeechRecognition error:", event.error);
+
+    if (event.error === "aborted" && (voiceState.discardOnStop || voiceState.stopRequested)) {
+      voiceState.lastErrorMessage = "";
+      return;
+    }
+
+    voiceState.lastErrorMessage = humanizeVoiceRecognitionError(event.error);
+  };
+
+  recognition.onend = () => {
+    const shouldDiscard = voiceState.discardOnStop;
+    const recognizedText = appendSpeechChunk(voiceState.finalTranscript, voiceState.interimTranscript);
+    const hasRecognizedText = Boolean(recognizedText.trim());
+
+    voiceState.isListening = false;
+
+    if (!shouldDiscard && hasRecognizedText) {
+      elements.sourceText.value = appendSpeechChunk(voiceState.baseText, recognizedText);
+      autoResizeTextarea();
+    }
+
+    let finalMessage = "";
+    let finalTone = "default";
+
+    if (voiceState.lastErrorMessage) {
+      finalMessage = voiceState.lastErrorMessage;
+      finalTone = "error";
+    } else if (!shouldDiscard && hasRecognizedText) {
+      finalMessage = "Đã chèn nội dung giọng nói vào ô nhập.";
+    } else if (!shouldDiscard && !voiceState.stopRequested) {
+      finalMessage = "Không nhận diện được nội dung giọng nói. Hãy thử lại.";
+      finalTone = "error";
+    }
+
+    voiceState.discardOnStop = false;
+    voiceState.stopRequested = false;
+    voiceState.finalTranscript = "";
+    voiceState.interimTranscript = "";
+    voiceState.lastErrorMessage = "";
+    voiceState.baseText = elements.sourceText.value.trimEnd();
+
+    syncVoiceUi(finalMessage, finalTone);
+  };
+
+  return recognition;
+}
+
+function appendSpeechChunk(base, chunk) {
+  const normalizedBase = String(base || "");
+  const normalizedChunk = String(chunk || "").trim();
+
+  if (!normalizedChunk) return normalizedBase;
+  if (!normalizedBase.trim()) return normalizedChunk;
+
+  return /[\s(]$/.test(normalizedBase) ? `${normalizedBase}${normalizedChunk}` : `${normalizedBase} ${normalizedChunk}`;
+}
+
+function humanizeVoiceStartError(error) {
+  const errorName = error?.name || "";
+
+  if (errorName === "InvalidStateError") {
+    return "Micro đang hoạt động. Hãy dừng phiên hiện tại trước khi bật lại.";
+  }
+
+  if (errorName === "NotAllowedError" || errorName === "SecurityError") {
+    if (!canUseBrowserVoiceInput()) {
+      return buildVoiceOriginMessage();
+    }
+    return "Bạn chưa cấp quyền micro cho trình duyệt.";
+  }
+
+  if (errorName === "NotFoundError" || errorName === "DevicesNotFoundError") {
+    return "Không tìm thấy thiết bị micro.";
+  }
+
+  return "Không thể bật nhận giọng nói lúc này. Hãy thử lại.";
+}
+
+function humanizeVoiceRecognitionError(errorCode) {
+  if (errorCode === "not-allowed" || errorCode === "service-not-allowed") {
+    if (!canUseBrowserVoiceInput()) {
+      return buildVoiceOriginMessage();
+    }
+    return "Bạn chưa cấp quyền micro hoặc nhận giọng nói cho trình duyệt.";
+  }
+
+  if (errorCode === "audio-capture") {
+    return "Không tìm thấy micro hoặc micro đang bị chiếm dụng.";
+  }
+
+  if (errorCode === "network") {
+    if (!navigator.onLine) {
+      return "Thiết bị đang offline. Hãy kết nối Internet rồi thử lại.";
+    }
+
+    if (!canUseBrowserVoiceInput()) {
+      return buildVoiceOriginMessage();
+    }
+
+    return "Trình duyệt không kết nối được dịch vụ nhận giọng nói. Hãy dùng Chrome hoặc Edge, kiểm tra mạng, VPN hay firewall rồi thử lại.";
+  }
+
+  if (errorCode === "language-not-supported") {
+    return "Trình duyệt không hỗ trợ nhận giọng nói tiếng Việt.";
+  }
+
+  if (errorCode === "no-speech") {
+    return "Không nghe thấy giọng nói. Hãy thử nói gần micro hơn.";
+  }
+
+  return "Không thể nhận giọng nói lúc này. Hãy thử lại.";
+}
+
+function canUseBrowserVoiceInput() {
+  return window.isSecureContext || isLocalhost(window.location.hostname);
+}
+
+function isLocalhost(hostname) {
+  return (
+    hostname === "localhost" ||
+    hostname.endsWith(".localhost") ||
+    hostname === "127.0.0.1" ||
+    hostname === "::1" ||
+    hostname === "[::1]"
+  );
+}
+
+function buildVoiceUnsupportedMessage() {
+  return "Trình duyệt này chưa hỗ trợ nhập giọng nói trực tiếp. Hãy dùng Chrome hoặc Edge bản mới.";
+}
+
+function buildVoiceOriginMessage() {
+  return "Nhập bằng giọng nói qua trình duyệt chỉ hoạt động trên HTTPS hoặc localhost. Hãy mở ứng dụng bằng https:// hoặc http://localhost.";
+}
+
+function syncSpeechDraft() {
+  const stableText = appendSpeechChunk(voiceState.baseText, voiceState.finalTranscript);
+  elements.sourceText.value = appendSpeechChunk(stableText, voiceState.interimTranscript);
+  autoResizeTextarea();
+}
+
+function syncVoiceUi(message, tone = "default") {
+  const resolvedMessage = String(message || "").trim();
+
+  elements.voiceStatus.textContent = resolvedMessage;
+  elements.voiceStatus.classList.toggle("is-empty", !resolvedMessage);
+  elements.voiceStatus.classList.toggle("is-error", tone === "error");
+  elements.voiceStatus.classList.toggle("is-active", voiceState.isListening);
+  elements.voiceInputButton.disabled = !voiceState.isSupported;
+  elements.voiceInputButton.classList.toggle("is-listening", voiceState.isListening);
+  elements.voiceInputButton.classList.toggle("is-unsupported", !voiceState.isSupported);
+  elements.voiceInputButton.setAttribute(
+    "aria-label",
+    voiceState.isListening ? "Dừng nhận giọng nói" : "Nhập bằng giọng nói qua trình duyệt",
+  );
+}
+
+function autoResizeTextarea() {
+  const collapsedHeight = 30;
+  const expandedMinHeight = 86;
+  const hasContent = elements.sourceText.value.trim().length > 0;
+
+  elements.sourceText.style.height = `${collapsedHeight}px`;
+  const nextHeight = Math.min(elements.sourceText.scrollHeight, 240);
+  elements.sourceText.style.height = `${Math.max(nextHeight, hasContent ? expandedMinHeight : collapsedHeight)}px`;
+  elements.sourceShell.classList.toggle("is-expanded", hasContent || nextHeight > collapsedHeight + 4);
+}
+
+function loadHistory() {
+  try {
+    const saved = window.localStorage.getItem(STORAGE_KEY);
+    if (!saved) {
+      return [];
+    }
+
+    const parsed = JSON.parse(saved);
+    if (!Array.isArray(parsed)) return [];
+
+    return parsed
+      .map((item) => ({
+        ...item,
+        id: item.id || makeId(),
+        createdAt: item.createdAt || new Date().toISOString(),
+      }))
+      .filter((item) => Array.isArray(item.questions) && item.questions.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+function persistHistory() {
+  window.localStorage.setItem(STORAGE_KEY, JSON.stringify(state.history));
+}
+
+async function fetchInfo() {
+  try {
+    const response = await fetch("/api/info");
+    const payload = await response.json();
+
+    if (!response.ok || !payload.ok) {
+      throw new Error(payload.error || "Không đọc được thông tin hệ thống.");
+    }
+
+    applySystemInfo(payload);
+  } catch (error) {
+    state.availableModels = [];
+    state.activeModelId = "";
+    renderModelOptions("Không tải được danh sách model.");
+    elements.deviceStatus.textContent = "Không kết nối được backend.";
+    elements.modelStatus.textContent = error.message || "Vui lòng kiểm tra lại backend hoặc server Flask.";
+    syncLandingStatus({
+      modelName: "Không tải được danh sách model",
+      deviceName: "Chưa kết nối backend",
+      modelCount: 0,
+      badgeText: "Lỗi kết nối",
+      badgeTone: "error",
+      statusText: error.message || "Không thể đọc thông tin hệ thống từ backend.",
+    });
+  }
+}
+
+async function switchModel(modelId) {
+  const previousModelId = state.activeModelId;
+
+  state.isSwitchingModel = true;
+  syncInteractiveControls();
+  elements.modelStatus.textContent = "Đang chuyển model...";
+  syncLandingStatus({
+    modelName: state.availableModels.find((item) => item.id === modelId)?.label || "Đang chuyển model...",
+    deviceName: elements.deviceStatus.textContent || "Đang kiểm tra...",
+    modelCount: state.availableModels.length,
+    badgeText: "Đang chuyển",
+    badgeTone: "pending",
+    statusText: "Hệ thống đang chuyển model theo lựa chọn của bạn.",
+  });
+
+  try {
+    const response = await fetch("/api/model", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model_id: modelId }),
+    });
+    const payload = await response.json();
+
+    if (!response.ok || !payload.ok) {
+      throw new Error(payload.error || "Không thể chuyển model lúc này.");
+    }
+
+    applySystemInfo(payload);
+  } catch (error) {
+    state.activeModelId = previousModelId;
+    renderModelOptions();
+    elements.modelStatus.textContent = error.message || "Không thể chuyển model lúc này.";
+    syncLandingStatus({
+      modelName:
+        state.availableModels.find((item) => item.id === previousModelId)?.label
+        || state.availableModels[0]?.label
+        || "Không xác định",
+      deviceName: elements.deviceStatus.textContent || "Đang kiểm tra...",
+      modelCount: state.availableModels.length,
+      badgeText: "Lỗi chuyển model",
+      badgeTone: "error",
+      statusText: error.message || "Không thể chuyển model lúc này.",
+    });
+  } finally {
+    state.isSwitchingModel = false;
+    syncInteractiveControls();
+  }
+}
+
+function applySystemInfo(payload) {
+  const availableModels = Array.isArray(payload.available_models) ? payload.available_models : [];
+  const fallbackModelId = String(payload.selected_model_id || payload.model_name || "default-model");
+  const fallbackModelLabel = String(payload.model_name || "Model hiện tại");
+
+  state.availableModels = availableModels.length
+    ? availableModels
+    : [{ id: fallbackModelId, label: fallbackModelLabel }];
+  state.activeModelId = String(payload.selected_model_id || state.availableModels[0]?.id || "");
+  renderModelOptions();
+
+  const activeModel =
+    state.availableModels.find((item) => item.id === state.activeModelId)?.label || payload.model_name || "Model";
+
+  elements.deviceStatus.textContent = humanizeDevice(payload.meta.active_device || payload.meta.predicted_device);
+  elements.modelStatus.textContent = payload.meta.loaded
+    ? `${activeModel} đã sẵn sàng cho tác vụ sinh câu hỏi.`
+    : `Đã chọn ${activeModel}. Model sẽ được nạp tự động ở lần sinh câu hỏi đầu tiên.`;
+
+  syncLandingStatus({
+    modelName: activeModel,
+    deviceName: humanizeDeviceCompact(payload.meta.active_device || payload.meta.predicted_device),
+    modelCount: state.availableModels.length,
+    badgeText: payload.meta.loaded ? "Sẵn sàng" : "Chờ nạp model",
+    badgeTone: payload.meta.loaded ? "ready" : "pending",
+    statusText: payload.meta.loaded
+      ? `${activeModel} đã nạp xong và có thể sử dụng ngay.`
+      : `${activeModel} sẽ được nạp tự động ở lần sinh câu hỏi đầu tiên.`,
+  });
+}
+
+function renderModelOptions(emptyLabel = "Chưa có model khả dụng.") {
+  elements.modelSelect.innerHTML = "";
+
+  if (!state.availableModels.length) {
+    const fallbackOption = document.createElement("option");
+    fallbackOption.value = "";
+    fallbackOption.textContent = emptyLabel;
+    elements.modelSelect.appendChild(fallbackOption);
+    elements.modelSelect.disabled = true;
+    return;
+  }
+
+  for (const model of state.availableModels) {
+    const option = document.createElement("option");
+    option.value = model.id;
+    option.textContent = model.label;
+    elements.modelSelect.appendChild(option);
+  }
+
+  if (!state.availableModels.some((item) => item.id === state.activeModelId)) {
+    state.activeModelId = state.availableModels[0].id;
+  }
+
+  elements.modelSelect.value = state.activeModelId;
+  syncInteractiveControls();
+}
+
+function renderAuthors() {
+  if (!elements.authorToggle || !elements.authorContent || !elements.authorList) return;
+
+  elements.authorToggle.setAttribute("aria-expanded", String(state.isAuthorPanelOpen));
+  elements.authorToggle.classList.toggle("is-open", state.isAuthorPanelOpen);
+  elements.authorContent.hidden = !state.isAuthorPanelOpen;
+
+  if (!state.isAuthorPanelOpen) {
+    elements.authorList.innerHTML = "";
+    return;
+  }
+
+  elements.authorList.innerHTML = AUTHOR_PROFILES.map((author) => {
+    const isActive = author.id === state.selectedAuthorId;
+    const detailMarkup = isActive ? buildAuthorDetailMarkup(author) : "";
+    return `
+      <article
+        class="author-person ${isActive ? "is-active" : ""}"
+        data-author-shell="${escapeHtml(author.id)}"
+      >
+        <button
+          class="author-person-trigger"
+          type="button"
+          data-author-id="${escapeHtml(author.id)}"
+          aria-expanded="${String(isActive)}"
+        >
+          <div class="author-person-top">
+            <span class="author-person-role">${escapeHtml(author.role)}</span>
+            <span class="author-person-chevron" aria-hidden="true">
+              <svg viewBox="0 0 24 24" fill="none">
+                <path
+                  d="m8 10 4 4 4-4"
+                  stroke="currentColor"
+                  stroke-linecap="round"
+                  stroke-linejoin="round"
+                  stroke-width="1.8"
+                />
+              </svg>
+            </span>
+          </div>
+          <strong>${escapeHtml(author.name)}</strong>
+          <span class="author-person-summary">${escapeHtml(author.summary)}</span>
+        </button>
+        ${detailMarkup}
+      </article>
+    `;
+  }).join("");
+}
+
+function renderLandingSamples() {
+  if (!elements.sampleList) return;
+
+  elements.sampleList.innerHTML = SAMPLE_SNIPPETS.map((sample) => `
+    <button class="sample-card" type="button" data-sample-id="${escapeHtml(sample.id)}">
+      <strong>${escapeHtml(sample.title)}</strong>
+      <span>${escapeHtml(sample.preview)}</span>
+    </button>
+  `).join("");
+}
+
+function syncLandingPanel() {
+  if (!elements.landingPanel) return;
+  elements.landingPanel.hidden = !elements.resultCard.hidden;
+}
+
+function syncLandingStatus({
+  modelName = "Đang tải...",
+  deviceName = "Đang kiểm tra...",
+  modelCount = 0,
+  badgeText = "Đang kiểm tra",
+  badgeTone = "pending",
+  statusText = "Đang đồng bộ trạng thái hệ thống.",
+} = {}) {
+  if (
+    !elements.landingRuntimeBadge
+    || !elements.landingStatusText
+    || !elements.landingModelName
+    || !elements.landingDeviceName
+    || !elements.landingModelCount
+  ) {
+    return;
+  }
+
+  elements.landingRuntimeBadge.textContent = badgeText;
+  elements.landingRuntimeBadge.classList.remove("is-ready", "is-pending", "is-error");
+  elements.landingRuntimeBadge.classList.add(
+    badgeTone === "ready" ? "is-ready" : badgeTone === "error" ? "is-error" : "is-pending",
+  );
+  elements.landingStatusText.textContent = statusText;
+  elements.landingModelName.textContent = modelName;
+  elements.landingDeviceName.textContent = deviceName;
+  elements.landingModelCount.textContent = String(modelCount);
+}
+
+function selectAuthor(authorId) {
+  if (!AUTHOR_PROFILES.some((author) => author.id === authorId)) {
+    return;
+  }
+
+  state.selectedAuthorId = state.selectedAuthorId === authorId ? null : authorId;
+  renderAuthors();
+}
+
+function buildAuthorDetailMarkup(author) {
+  const metaItems = [
+    { label: "Vai trò", value: author.description },
+    { label: "Đơn vị", value: author.unit },
+    ...(author.email ? [{ label: "Email", value: author.email }] : []),
+  ];
+
+  return `
+    <div class="author-person-body">
+      <div class="author-person-meta">
+        ${metaItems
+          .map(
+            (item) => `
+              <div class="author-person-meta-row" title="${escapeHtml(item.value)}">
+                <span class="author-person-meta-label">${escapeHtml(item.label)}</span>
+                <span class="author-person-meta-value">${escapeHtml(item.value)}</span>
+              </div>
+            `,
+          )
+          .join("")}
+      </div>
+    </div>
+  `;
+}
+
+function humanizeDevice(device) {
+  if (device === "cuda") return "Đang sử dụng GPU CUDA.";
+  return "Đang sử dụng CPU.";
+}
+
+function humanizeDeviceCompact(device) {
+  if (device === "cuda") return "GPU CUDA";
+  return "CPU";
+}
+
+function renderHistory() {
+  if (!state.history.length) {
+    elements.historyList.innerHTML = '<div class="history-empty">Chưa có lịch sử. Hãy tạo bộ câu hỏi đầu tiên của bạn.</div>';
+    return;
+  }
+
+  elements.historyList.innerHTML = state.history
+    .map((item) => {
+      const activeClass = item.id === state.selectedId ? "is-active" : "";
+      return `
+        <button class="history-item ${activeClass}" type="button" data-history-id="${item.id}">
+          <span class="history-icon" aria-hidden="true">
+            <svg viewBox="0 0 24 24" width="18" height="18" fill="none">
+              <path d="M12 20c4.4 0 8-2.9 8-6.5S16.4 7 12 7 4 9.9 4 13.5c0 1.6.7 3 1.9 4.1L5 21l3.2-1.6c1.1.4 2.4.6 3.8.6Z" stroke="currentColor" stroke-width="1.6" stroke-linejoin="round"/>
+            </svg>
+          </span>
+          <span class="history-main">
+            <strong>${escapeHtml(item.title || "Đoạn văn mới")}</strong>
+            <span>${escapeHtml(formatTimestamp(item.createdAt))}</span>
+          </span>
+        </button>
+      `;
+    })
+    .join("");
+}
+
+function showResultCard() {
+  elements.resultCard.hidden = false;
+  elements.resultCard.classList.add("is-visible");
+  syncLandingPanel();
+}
+
+function hideResultCard() {
+  elements.resultCard.hidden = true;
+  elements.resultCard.classList.remove("is-visible");
+  elements.resultCard.classList.remove("has-entry");
+  elements.resultCard.classList.remove("is-updating");
+  elements.resultCard.innerHTML = "";
+  syncLandingPanel();
+}
+
+function renderMessage(message) {
+  showResultCard();
+  elements.resultCard.classList.remove("is-updating");
+
+  if (state.thread.length) {
+    elements.resultCard.classList.add("has-entry");
+    elements.resultCard.innerHTML = `
+      <p class="result-message result-message-inline">${escapeHtml(message)}</p>
+      ${renderThreadMarkup(state.thread)}
+    `;
+    return;
+  }
+
+  elements.resultCard.classList.remove("has-entry");
+  elements.resultCard.innerHTML = `
+    <p class="result-message">${escapeHtml(message)}</p>
+  `;
+}
+
+function renderThread() {
+  if (!state.thread.length) {
+    hideResultCard();
+    return;
+  }
+
+  showResultCard();
+  elements.resultCard.classList.add("has-entry");
+  elements.resultCard.classList.remove("is-updating");
+  elements.resultCard.innerHTML = renderThreadMarkup(state.thread);
+}
+
+function renderThreadMarkup(entries) {
+  return `
+    <div class="result-feed">
+      ${entries.map((entry) => renderThreadItem(entry)).join("")}
+    </div>
+  `;
+}
+
+function renderThreadItem(entry) {
+  const questions = Array.isArray(entry.questions) ? entry.questions : [];
+  const questionItems = questions.map((item) => `<li>${escapeHtml(item)}</li>`).join("");
+  const statusLabel =
+    entry.status === "pending" ? "ĐANG XỬ LÝ" : entry.status === "error" ? "LỖI" : entry.device ? entry.device.toUpperCase() : "AUTO";
+  const questionBlock =
+    entry.status === "pending"
+      ? `
+        <div class="result-pending">
+          <div class="atom-loader atom-loader-inline" aria-hidden="true">
+            <span class="atom-core"></span>
+            <span class="atom-orbit atom-orbit-a"><span class="atom-electron"></span></span>
+            <span class="atom-orbit atom-orbit-b"><span class="atom-electron"></span></span>
+            <span class="atom-orbit atom-orbit-c"><span class="atom-electron"></span></span>
+          </div>
+          <p class="result-note">Đang sinh câu hỏi từ đoạn văn bản này...</p>
+        </div>
+      `
+      : entry.status === "error"
+        ? `<p class="result-message">${escapeHtml(entry.errorMessage || "Có lỗi xảy ra khi sinh câu hỏi.")}</p>`
+        : questions.length
+          ? `<ol class="result-questions">${questionItems}</ol>`
+          : '<p class="result-note">Mục lịch sử này chưa lưu danh sách câu hỏi. Hãy bấm “Sinh câu hỏi” để tạo lại.</p>';
+
+  return `
+    <article class="result-thread-item" data-entry-id="${escapeHtml(entry.id)}">
+      <div class="result-meta">
+        <span>${escapeHtml(formatTimestamp(entry.createdAt))}</span>
+        <span>${escapeHtml(statusLabel)}</span>
+        <span>${escapeHtml(String(entry.count || questions.length || 0))} câu hỏi</span>
+        ${entry.elapsedMs ? `<span>${escapeHtml(String(entry.elapsedMs))} ms</span>` : ""}
+      </div>
+
+      <section class="result-section">
+        <div class="result-section-head">
+          <h3 class="result-source-title">Văn bản đầu vào</h3>
+          <button class="copy-button" type="button" data-copy-entry-id="${escapeHtml(entry.id)}" data-copy-target="source" aria-label="Sao chép">
+            ${copyIconMarkup()}
+          </button>
+        </div>
+        <p class="result-source">${escapeHtml(entry.text || entry.title || "")}</p>
+      </section>
+
+      <section class="result-section">
+        <div class="result-section-head">
+          <h3 class="result-questions-title">Câu hỏi sinh ra</h3>
+          <button class="copy-button" type="button" data-copy-entry-id="${escapeHtml(entry.id)}" data-copy-target="response" aria-label="Sao chép">
+            ${copyIconMarkup()}
+          </button>
+        </div>
+        ${questionBlock}
+      </section>
+    </article>
+  `;
+}
+
+function copyIconMarkup() {
+  return `
+    <svg viewBox="0 0 24 24" fill="none" aria-hidden="true">
+      <path
+        d="M9 9.75A2.25 2.25 0 0 1 11.25 7.5h6A2.25 2.25 0 0 1 19.5 9.75v6A2.25 2.25 0 0 1 17.25 18h-6A2.25 2.25 0 0 1 9 15.75v-6Z"
+        stroke="currentColor"
+        stroke-linecap="round"
+        stroke-linejoin="round"
+        stroke-width="1.7"
+      />
+      <path
+        d="M15 7.5v-.75A2.25 2.25 0 0 0 12.75 4.5h-6A2.25 2.25 0 0 0 4.5 6.75v6A2.25 2.25 0 0 0 6.75 15H9"
+        stroke="currentColor"
+        stroke-linecap="round"
+        stroke-linejoin="round"
+        stroke-width="1.7"
+      />
+    </svg>
+  `;
+}
+
+function buildCopyText(entryId, target) {
+  const entry = state.thread.find((item) => item.id === entryId) || state.history.find((item) => item.id === entryId);
+  if (!entry) return "";
+
+  if (target === "source") {
+    return String(entry.text || entry.title || "").trim();
+  }
+
+  if (entry.status === "pending") {
+    return "Đang sinh câu hỏi từ đoạn văn bản này...";
+  }
+
+  if (entry.status === "error") {
+    return String(entry.errorMessage || "Có lỗi xảy ra khi sinh câu hỏi.").trim();
+  }
+
+  const questions = Array.isArray(entry.questions) ? entry.questions : [];
+  if (questions.length) {
+    return questions.map((item, index) => `${index + 1}. ${item}`).join("\n");
+  }
+
+  return "Mục lịch sử này chưa lưu danh sách câu hỏi. Hãy bấm “Sinh câu hỏi” để tạo lại.";
+}
+
+async function copyToClipboard(text) {
+  try {
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch {
+    try {
+      const area = document.createElement("textarea");
+      area.value = text;
+      area.setAttribute("readonly", "");
+      area.style.position = "fixed";
+      area.style.opacity = "0";
+      document.body.appendChild(area);
+      area.select();
+      const success = document.execCommand("copy");
+      area.remove();
+      return success;
+    } catch {
+      return false;
+    }
+  }
+}
+
+function setLoading(isLoading) {
+  elements.generateButton.classList.toggle("is-loading", isLoading);
+  document.body.classList.toggle("is-generating", isLoading);
+  elements.resultCard.classList.toggle("is-updating", isLoading && elements.resultCard.classList.contains("has-entry"));
+  syncQuestionCount(elements.questionCount.value);
+  syncInteractiveControls();
+}
+
+function isInterfaceBusy() {
+  return document.body.classList.contains("is-generating") || state.isSwitchingModel;
+}
+
+function syncInteractiveControls() {
+  const isBusy = isInterfaceBusy();
+  elements.generateButton.disabled = isBusy;
+  elements.modelSelect.disabled = isBusy || state.availableModels.length <= 1;
+}
+
+function activateHeroTitle() {
+  const node = elements.heroTitle;
+  if (!node) return;
+
+  const fullText = String(node.dataset.text || "").trim();
+  if (!fullText) return;
+
+  node.textContent = fullText;
+  node.classList.remove("is-ready");
+
+  if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) {
+    node.classList.add("is-ready");
+    return;
+  }
+
+  window.requestAnimationFrame(() => {
+    node.classList.add("is-ready");
+  });
+}
+
+function shrink(text, maxLength) {
+  const normalized = String(text || "").trim();
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, maxLength - 3).trim()}...`;
+}
+
+function formatTimestamp(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "Vừa xong";
+
+  const now = new Date();
+  const sameDay = date.toDateString() === now.toDateString();
+  const yesterday = new Date(now);
+  yesterday.setDate(now.getDate() - 1);
+
+  const timeLabel = date.toLocaleTimeString("vi-VN", { hour: "2-digit", minute: "2-digit" });
+  if (sameDay) return `Hôm nay ${timeLabel}`;
+  if (date.toDateString() === yesterday.toDateString()) return `Hôm qua ${timeLabel}`;
+
+  return date.toLocaleDateString("vi-VN", { day: "2-digit", month: "2-digit", year: "numeric" });
+}
+
+function syncCopyright() {
+  const year = new Date().getFullYear();
+  elements.copyrightLine.textContent = `© ${year} HVU - KTCN`;
+}
+
+function escapeHtml(value) {
+  return String(value || "")
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+function makeId() {
+  if (window.crypto && typeof window.crypto.randomUUID === "function") {
+    return window.crypto.randomUUID();
+  }
+  return `item-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}

HVU_QA/frontend/index.html

@@ -0,0 +1,265 @@
+<!DOCTYPE html>
+<html lang="vi">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>HVU QA - Mô hình sinh câu hỏi thường gặp</title>
+    <meta
+      name="description"
+      content="Hệ thống sinh câu hỏi thường gặp của Trường Đại học Hùng Vương."
+    />
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Be+Vietnam+Pro:wght@400;500;600;700;800&display=swap"
+      rel="stylesheet"
+    />
+    <link rel="stylesheet" href="/frontend/style.css" />
+    <script src="/frontend/app.js" defer></script>
+  </head>
+  <body>
+    <div class="page-shell">
+      <aside class="sidebar" id="sidebar">
+        <div class="sidebar-top">
+          <button
+            class="menu-toggle"
+            id="menuToggle"
+            type="button"
+            aria-label="Mở hoặc đóng thanh bên"
+            aria-expanded="false"
+            aria-controls="sidebarContent"
+          >
+            <span></span>
+            <span></span>
+            <span></span>
+          </button>
+        </div>
+
+        <div class="sidebar-content" id="sidebarContent" aria-hidden="true">
+          <section class="side-card">
+            <p class="side-label">Chọn model</p>
+            <label class="select-shell">
+              <span class="select-icon" aria-hidden="true">
+                <svg viewBox="0 0 24 24" fill="none">
+                  <path
+                    d="M12 3 4.5 7.2v9.6L12 21l7.5-4.2V7.2L12 3Zm0 0v8.4m0 0 7.5-4.2M12 11.4 4.5 7.2"
+                    stroke="currentColor"
+                    stroke-linecap="round"
+                    stroke-linejoin="round"
+                    stroke-width="1.6"
+                  />
+                </svg>
+              </span>
+              <select id="modelSelect" disabled>
+                <option>Đang tải danh sách model...</option>
+              </select>
+            </label>
+          </section>
+
+          <section class="side-card status-card">
+            <div class="status-chip">
+              <span class="status-dot" aria-hidden="true"></span>
+              <p id="deviceStatus">Đang kiểm tra thiết bị...</p>
+            </div>
+            <p class="status-note" id="modelStatus">Model sẽ được nạp ở lần sinh câu hỏi đầu tiên.</p>
+          </section>
+
+          <section class="side-card history-card">
+            <div class="history-header">
+              <p class="side-label">Lịch sử</p>
+              <button id="clearHistory" type="button">Xóa</button>
+            </div>
+            <div class="history-list" id="historyList"></div>
+          </section>
+
+          <section class="author-card">
+            <button
+              class="author-toggle"
+              id="authorToggle"
+              type="button"
+              aria-expanded="false"
+              aria-controls="authorContent"
+            >
+              <div class="author-header">
+                <div class="author-header-icon" aria-hidden="true">
+                  <svg viewBox="0 0 24 24" fill="none">
+                    <path
+                      d="M12 12a4 4 0 1 0 0-8 4 4 0 0 0 0 8Zm-7 8c0-3.314 3.134-6 7-6s7 2.686 7 6"
+                      stroke="currentColor"
+                      stroke-linecap="round"
+                      stroke-linejoin="round"
+                      stroke-width="1.8"
+                    />
+                  </svg>
+                </div>
+                <div>
+                  <p class="author-title">Tác giả</p>
+                </div>
+              </div>
+              <span class="author-toggle-icon" aria-hidden="true">
+                <svg viewBox="0 0 24 24" fill="none">
+                  <path
+                    d="m8 10 4 4 4-4"
+                    stroke="currentColor"
+                    stroke-linecap="round"
+                    stroke-linejoin="round"
+                    stroke-width="1.8"
+                  />
+                </svg>
+              </span>
+            </button>
+
+            <div class="author-content" id="authorContent" hidden>
+              <div class="author-grid" id="authorList"></div>
+            </div>
+
+            <div class="author-footer">
+              <p id="copyrightLine">© 2026 HVU - KTCN</p>
+            </div>
+          </section>
+        </div>
+      </aside>
+
+      <main class="workspace">
+        <header class="topbar">
+          <div class="identity">
+            <img class="logo" src="/assets/HVU.png" alt="Logo Trường Đại học Hùng Vương" />
+            <div class="identity-copy">
+              <h1>Trường Đại học Hùng Vương</h1>
+              <p>Khoa Kỹ thuật - công nghệ</p>
+            </div>
+          </div>
+        </header>
+
+        <section class="hero-panel">
+          <div class="hero-copy">
+            <h2>
+              <span
+                class="typewriter-text"
+                id="heroTitle"
+                data-text="Mô hình sinh câu hỏi thường gặp"
+                aria-label="Mô hình sinh câu hỏi thường gặp"
+              ></span>
+            </h2>
+          </div>
+        </section>
+
+        <section class="result-card" id="resultCard" aria-live="polite" hidden></section>
+
+        <form class="composer" id="generatorForm">
+          <div class="input-shell" id="sourceShell">
+            <label class="visually-hidden" for="sourceText">Nhập đoạn văn bản</label>
+            <textarea
+              id="sourceText"
+              name="sourceText"
+              rows="1"
+              placeholder="Nhập đoạn văn bản ..."
+              required
+            ></textarea>
+
+            <div class="composer-actions">
+              <div class="count-shell" aria-label="Số câu hỏi">
+                <span class="count-label">Số câu hỏi</span>
+                <div class="count-stepper" role="group" aria-label="Điều chỉnh số câu hỏi">
+                  <button class="count-button" id="decreaseCount" type="button" aria-label="Giảm số câu hỏi">
+                    <span aria-hidden="true">-</span>
+                  </button>
+                  <output class="count-value" id="questionCountValue" for="questionCount">0</output>
+                  <button class="count-button" id="increaseCount" type="button" aria-label="Tăng số câu hỏi">
+                    <span aria-hidden="true">+</span>
+                  </button>
+                </div>
+                <input id="questionCount" name="questionCount" type="hidden" value="0" />
+              </div>
+
+              <div class="action-cluster">
+                <span class="voice-status is-empty" id="voiceStatus" aria-live="polite"></span>
+                <div class="action-buttons">
+                  <button
+                    class="voice-button"
+                    id="voiceInputButton"
+                    type="button"
+                    aria-label="Nhập bằng giọng nói qua trình duyệt"
+                  >
+                    <span class="voice-button-icon" aria-hidden="true">
+                      <svg viewBox="0 0 24 24" fill="none">
+                        <path
+                          d="M12 15a3.5 3.5 0 0 0 3.5-3.5v-4a3.5 3.5 0 1 0-7 0v4A3.5 3.5 0 0 0 12 15Z"
+                          stroke="currentColor"
+                          stroke-linecap="round"
+                          stroke-linejoin="round"
+                          stroke-width="1.8"
+                        />
+                        <path
+                          d="M6.5 11.5a5.5 5.5 0 1 0 11 0M12 17v3m-3 0h6"
+                          stroke="currentColor"
+                          stroke-linecap="round"
+                          stroke-linejoin="round"
+                          stroke-width="1.8"
+                        />
+                      </svg>
+                    </span>
+                  </button>
+
+                  <button class="generate-button" id="generateButton" type="submit">
+                    <span class="atom-loader atom-loader-sm" aria-hidden="true">
+                      <span class="atom-core"></span>
+                      <span class="atom-orbit atom-orbit-a"><span class="atom-electron"></span></span>
+                      <span class="atom-orbit atom-orbit-b"><span class="atom-electron"></span></span>
+                      <span class="atom-orbit atom-orbit-c"><span class="atom-electron"></span></span>
+                    </span>
+                    <span class="button-label">Sinh câu hỏi</span>
+                  </button>
+                </div>
+              </div>
+            </div>
+          </div>
+        </form>
+
+        <section class="landing-panel" id="landingPanel">
+          <article class="landing-card landing-guide">
+            <div class="landing-card-head">
+              <p class="landing-kicker">Hướng dẫn nhanh</p>
+              <p class="landing-card-note">Tạo bộ câu hỏi từ đoạn văn bản đầu vào.</p>
+            </div>
+            <ol class="landing-guide-list">
+              <li>Nhập hoặc dán đoạn văn bản vào ô nhập.</li>
+              <li>Chọn số lượng câu hỏi cần sinh.</li>
+              <li>Nhấn <strong>Sinh câu hỏi</strong> để hệ thống xử lý.</li>
+            </ol>
+          </article>
+
+          <article class="landing-card landing-samples">
+            <div class="landing-card-head">
+              <p class="landing-kicker">Ví dụ mẫu</p>
+              <p class="landing-card-note">Chọn văn bản luật mẫu để chèn nhanh nội dung thử nghiệm.</p>
+            </div>
+            <div class="landing-sample-grid" id="sampleList"></div>
+          </article>
+
+          <article class="landing-card landing-system">
+            <div class="landing-card-head">
+              <p class="landing-kicker">Trạng thái model</p>
+              <span class="landing-runtime-badge is-pending" id="landingRuntimeBadge">Đang kiểm tra</span>
+            </div>
+            <p class="landing-card-note" id="landingStatusText">Đang kết nối backend và đọc cấu hình hệ thống.</p>
+            <div class="landing-system-list">
+              <div class="landing-system-row">
+                <span>Model đang dùng</span>
+                <strong id="landingModelName">Đang tải...</strong>
+              </div>
+              <div class="landing-system-row">
+                <span>Thiết bị xử lý</span>
+                <strong id="landingDeviceName">Đang kiểm tra...</strong>
+              </div>
+              <div class="landing-system-row">
+                <span>Số model khả dụng</span>
+                <strong id="landingModelCount">0</strong>
+              </div>
+            </div>
+          </article>
+        </section>
+      </main>
+    </div>
+  </body>
+</html>

HVU_QA/frontend/style.css

@@ -0,0 +1,1792 @@
+:root {
+  --bg: #f6f4fb;
+  --panel: rgba(255, 255, 255, 0.88);
+  --panel-soft: rgba(250, 248, 255, 0.92);
+  --line: rgba(92, 85, 168, 0.12);
+  --line-strong: rgba(92, 85, 168, 0.22);
+  --text: #232343;
+  --text-soft: #66648a;
+  --text-muted: #9793b5;
+  --accent: #5c63e7;
+  --accent-strong: #434dc7;
+  --accent-soft: rgba(92, 99, 231, 0.09);
+  --warm: #e0607c;
+  --gold: #f0b558;
+  --shadow-main: 0 28px 64px rgba(70, 62, 132, 0.12);
+  --shadow-soft: 0 12px 28px rgba(97, 88, 171, 0.08);
+  --radius-xl: 30px;
+  --radius-lg: 24px;
+  --radius-md: 18px;
+  --radius-sm: 14px;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  min-height: 100%;
+}
+
+body {
+  margin: 0;
+  font-family: "Be Vietnam Pro", "Segoe UI", sans-serif;
+  color: var(--text);
+  background:
+    radial-gradient(circle at 15% 15%, rgba(92, 99, 231, 0.08), transparent 22%),
+    radial-gradient(circle at 85% 85%, rgba(224, 96, 124, 0.1), transparent 18%),
+    linear-gradient(180deg, #f8f6fc 0%, #f2eef9 100%);
+}
+
+button,
+input,
+select,
+textarea {
+  font: inherit;
+}
+
+.page-shell {
+  --sidebar-width: 96px;
+  width: min(1420px, calc(100vw - 32px));
+  min-height: calc(100vh - 32px);
+  margin: 16px auto;
+  display: grid;
+  grid-template-columns: var(--sidebar-width) minmax(0, 1fr);
+  background: linear-gradient(180deg, rgba(255, 255, 255, 0.74), rgba(246, 241, 255, 0.82));
+  border: 1px solid rgba(255, 255, 255, 0.88);
+  border-radius: 28px;
+  box-shadow: var(--shadow-main);
+  overflow: hidden;
+  backdrop-filter: blur(18px);
+  transition: grid-template-columns 0.28s ease;
+}
+
+body.sidebar-open .page-shell {
+  --sidebar-width: 360px;
+}
+
+.sidebar {
+  padding: 18px;
+  background: linear-gradient(180deg, rgba(247, 244, 255, 0.98), rgba(239, 244, 255, 0.96));
+  border-right: 1px solid var(--line);
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+
+.sidebar-top {
+  min-height: 64px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.menu-toggle {
+  width: 56px;
+  height: 56px;
+  border: 0;
+  border-radius: 18px;
+  background: #fff;
+  box-shadow: var(--shadow-soft);
+  display: inline-grid;
+  place-content: center;
+  gap: 5px;
+  cursor: pointer;
+  transition: transform 0.2s ease, box-shadow 0.2s ease;
+}
+
+.menu-toggle:hover {
+  transform: translateY(-1px);
+  box-shadow: 0 16px 30px rgba(97, 88, 171, 0.12);
+}
+
+.menu-toggle span {
+  width: 24px;
+  height: 3px;
+  border-radius: 999px;
+  background: #5d5a8c;
+  transition: transform 0.24s ease, opacity 0.24s ease;
+}
+
+body.sidebar-open .menu-toggle span:nth-child(1) {
+  transform: translateY(8px) rotate(45deg);
+}
+
+body.sidebar-open .menu-toggle span:nth-child(2) {
+  opacity: 0;
+}
+
+body.sidebar-open .menu-toggle span:nth-child(3) {
+  transform: translateY(-8px) rotate(-45deg);
+}
+
+.sidebar-content {
+  display: grid;
+  gap: 14px;
+  opacity: 0;
+  max-height: 0;
+  overflow: hidden;
+  pointer-events: none;
+  transform: translateY(-8px);
+  transition: opacity 0.22s ease, transform 0.22s ease, max-height 0.28s ease;
+}
+
+body.sidebar-open .sidebar-content {
+  opacity: 1;
+  max-height: 2000px;
+  pointer-events: auto;
+  transform: translateY(0);
+}
+
+.side-card,
+.author-card,
+.result-card,
+.composer {
+  border: 1px solid rgba(255, 255, 255, 0.92);
+  box-shadow: var(--shadow-soft);
+}
+
+.side-card {
+  padding: 14px;
+  border-radius: 20px;
+  background: linear-gradient(180deg, rgba(242, 245, 255, 0.98), rgba(252, 252, 255, 0.94));
+  border-color: rgba(151, 161, 240, 0.16);
+}
+
+.side-label {
+  margin: 0 0 12px;
+  font-size: 0.8rem;
+  font-weight: 700;
+  letter-spacing: 0.03em;
+  color: var(--text-muted);
+}
+
+.select-shell {
+  min-height: 54px;
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 0 14px;
+  border-radius: 16px;
+  border: 1px solid var(--line);
+  background: #fff;
+}
+
+.select-icon {
+  width: 20px;
+  height: 20px;
+  color: var(--accent);
+  display: inline-flex;
+}
+
+.select-shell select {
+  width: 100%;
+  border: 0;
+  outline: none;
+  background: transparent;
+  color: #585480;
+  font-weight: 500;
+}
+
+.status-card {
+  display: grid;
+  gap: 8px;
+}
+
+.status-chip {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.status-chip p,
+.status-note {
+  margin: 0;
+}
+
+.status-chip p {
+  font-size: 0.92rem;
+  font-weight: 600;
+  color: #57527d;
+}
+
+.status-note {
+  font-size: 0.84rem;
+  line-height: 1.6;
+  color: var(--text-muted);
+}
+
+.status-dot {
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  background: linear-gradient(135deg, var(--warm), var(--accent));
+  box-shadow: 0 0 0 5px rgba(92, 99, 231, 0.1);
+}
+
+.history-card {
+  min-height: 240px;
+  display: flex;
+  flex-direction: column;
+}
+
+.history-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-bottom: 8px;
+}
+
+.history-header .side-label {
+  margin: 0;
+}
+
+.history-header button {
+  border: 0;
+  background: transparent;
+  color: var(--accent);
+  font-weight: 600;
+  cursor: pointer;
+}
+
+.history-list {
+  display: grid;
+  gap: 10px;
+  max-height: 100%;
+  overflow: auto;
+  padding-right: 4px;
+}
+
+.history-list::-webkit-scrollbar {
+  width: 8px;
+}
+
+.history-list::-webkit-scrollbar-thumb {
+  border-radius: 999px;
+  background: rgba(92, 99, 231, 0.2);
+}
+
+.history-item {
+  width: 100%;
+  border: 1px solid transparent;
+  border-radius: 16px;
+  background: rgba(255, 255, 255, 0.82);
+  padding: 12px 14px;
+  display: grid;
+  grid-template-columns: auto 1fr;
+  gap: 12px;
+  align-items: start;
+  text-align: left;
+  color: inherit;
+  cursor: pointer;
+  transition: transform 0.18s ease, box-shadow 0.18s ease, border-color 0.18s ease;
+}
+
+.history-item:hover,
+.history-item.is-active {
+  transform: translateY(-1px);
+  border-color: rgba(92, 99, 231, 0.18);
+  box-shadow: 0 12px 24px rgba(92, 99, 231, 0.1);
+}
+
+.history-icon {
+  width: 24px;
+  height: 24px;
+  color: var(--accent);
+  display: inline-grid;
+  place-items: center;
+  margin-top: 3px;
+}
+
+.history-main strong,
+.history-main span {
+  display: block;
+}
+
+.history-main strong {
+  font-size: 0.95rem;
+  line-height: 1.45;
+  font-weight: 600;
+  color: #4a466e;
+}
+
+.history-main span {
+  margin-top: 4px;
+  font-size: 0.8rem;
+  color: var(--text-muted);
+}
+
+.history-empty {
+  padding: 14px;
+  border-radius: 16px;
+  background: rgba(255, 255, 255, 0.7);
+  color: var(--text-muted);
+  line-height: 1.6;
+}
+
+.author-card {
+  border-radius: 22px;
+  padding: 16px;
+  display: grid;
+  gap: 12px;
+  background: linear-gradient(180deg, rgba(255, 243, 247, 0.98), rgba(247, 242, 255, 0.96));
+  border-color: rgba(236, 158, 182, 0.18);
+}
+
+.author-toggle {
+  min-width: 0;
+  width: 100%;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: inherit;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  text-align: left;
+  cursor: pointer;
+}
+
+.author-toggle:focus-visible {
+  outline: 2px solid rgba(92, 99, 231, 0.24);
+  outline-offset: 4px;
+  border-radius: 18px;
+}
+
+.author-header {
+  min-width: 0;
+  display: grid;
+  grid-template-columns: auto 1fr;
+  gap: 12px;
+  align-items: center;
+}
+
+.author-header > :last-child {
+  min-width: 0;
+}
+
+.author-toggle-icon {
+  width: 34px;
+  height: 34px;
+  border-radius: 12px;
+  background: rgba(255, 255, 255, 0.8);
+  color: #7b75a6;
+  display: inline-grid;
+  place-items: center;
+  flex: none;
+  transition: transform 0.18s ease, background 0.18s ease, color 0.18s ease;
+}
+
+.author-toggle-icon svg {
+  width: 18px;
+  height: 18px;
+}
+
+.author-toggle.is-open .author-toggle-icon {
+  transform: rotate(180deg);
+  background: rgba(240, 234, 255, 0.98);
+  color: var(--accent-strong);
+}
+
+.author-header-icon {
+  width: 44px;
+  height: 44px;
+  border-radius: 16px;
+  background: linear-gradient(180deg, rgba(240, 228, 255, 0.98), rgba(255, 240, 246, 0.98));
+  color: var(--accent);
+  display: inline-grid;
+  place-items: center;
+  box-shadow: 0 10px 20px rgba(123, 117, 166, 0.08);
+}
+
+.author-header-icon svg {
+  width: 20px;
+  height: 20px;
+}
+
+.author-title,
+.author-footer p,
+.author-person-summary,
+.author-person-meta-label,
+.author-person-meta-value {
+  margin: 0;
+}
+
+.author-title {
+  font-size: 0.82rem;
+  font-weight: 800;
+  letter-spacing: 0.04em;
+  color: #7b75a6;
+  overflow-wrap: anywhere;
+  word-break: break-word;
+  white-space: normal;
+}
+
+.author-grid {
+  min-width: 0;
+  display: grid;
+  gap: 10px;
+}
+
+.author-content {
+  min-width: 0;
+  display: grid;
+  gap: 12px;
+}
+
+.author-content[hidden] {
+  display: none;
+}
+
+.author-person {
+  min-width: 0;
+  width: 100%;
+  border: 1px solid rgba(184, 167, 224, 0.24);
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.74);
+  display: grid;
+  overflow: hidden;
+  transition:
+    transform 0.18s ease,
+    box-shadow 0.18s ease,
+    border-color 0.18s ease,
+    background 0.18s ease;
+}
+
+.author-person:hover,
+.author-person.is-active {
+  transform: translateY(-1px);
+  border-color: rgba(92, 99, 231, 0.22);
+  background: rgba(255, 255, 255, 0.94);
+  box-shadow: 0 12px 24px rgba(92, 99, 231, 0.1);
+}
+
+.author-person-trigger {
+  min-width: 0;
+  width: 100%;
+  padding: 14px;
+  border: 0;
+  background: transparent;
+  text-align: left;
+  color: inherit;
+  display: grid;
+  gap: 8px;
+  cursor: pointer;
+}
+
+.author-person-trigger > * {
+  min-width: 0;
+}
+
+.author-person-trigger:focus-visible {
+  outline: 2px solid rgba(92, 99, 231, 0.28);
+  outline-offset: 2px;
+}
+
+.author-person-top {
+  min-width: 0;
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.author-person-role {
+  min-width: 0;
+  flex: 1 1 auto;
+  padding: 0;
+  color: var(--accent-strong);
+  display: block;
+  font-size: 0.74rem;
+  font-weight: 700;
+  line-height: 1.35;
+  overflow-wrap: anywhere;
+  word-break: break-word;
+  white-space: normal;
+}
+
+.author-person-chevron {
+  width: 18px;
+  height: 18px;
+  color: #7b75a6;
+  display: inline-grid;
+  place-items: center;
+  flex: none;
+  transition: transform 0.18s ease, color 0.18s ease;
+}
+
+.author-person-chevron svg {
+  width: 16px;
+  height: 16px;
+}
+
+.author-person.is-active .author-person-chevron {
+  transform: rotate(180deg);
+  color: var(--accent-strong);
+}
+
+.author-person strong {
+  display: block;
+  font-size: 1rem;
+  line-height: 1.35;
+  color: #403a67;
+  overflow-wrap: anywhere;
+  word-break: break-word;
+  white-space: normal;
+}
+
+.author-person-summary {
+  font-size: 0.84rem;
+  line-height: 1.55;
+  color: #6f6996;
+  overflow-wrap: anywhere;
+  word-break: break-word;
+  white-space: normal;
+}
+
+.author-person-body {
+  min-width: 0;
+  margin: 0 14px 14px;
+  padding-top: 12px;
+  border-top: 1px solid rgba(187, 171, 227, 0.2);
+  display: grid;
+  gap: 8px;
+}
+
+.author-person-body > * {
+  min-width: 0;
+}
+
+.author-person-meta {
+  min-width: 0;
+  display: grid;
+  gap: 8px;
+}
+
+.author-person-meta-row {
+  min-width: 0;
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 2px;
+  align-items: start;
+}
+
+.author-person-meta-label {
+  font-size: 0.75rem;
+  font-weight: 700;
+  letter-spacing: 0.03em;
+  color: #8a84b2;
+  white-space: normal;
+}
+
+.author-person-meta-value {
+  min-width: 0;
+  font-size: 0.88rem;
+  line-height: 1.4;
+  font-weight: 700;
+  color: #4e4878;
+  overflow-wrap: anywhere;
+  word-break: break-word;
+  white-space: normal;
+}
+
+.author-footer {
+  padding-top: 2px;
+}
+
+.author-footer p {
+  font-size: 0.9rem;
+  color: #6b648d;
+  overflow-wrap: anywhere;
+  word-break: break-word;
+  white-space: normal;
+}
+
+.workspace {
+  display: flex;
+  flex-direction: column;
+  min-width: 0;
+  background:
+    radial-gradient(circle at 50% 24%, rgba(92, 99, 231, 0.12), transparent 22%),
+    linear-gradient(180deg, rgba(255, 255, 255, 0.9), rgba(248, 244, 255, 0.9));
+}
+
+.topbar {
+  min-height: auto;
+  padding: 42px 34px 10px;
+  display: flex;
+  justify-content: center;
+  text-align: center;
+  background: transparent;
+}
+
+.identity {
+  display: grid;
+  justify-items: center;
+  gap: 16px;
+}
+
+.logo {
+  width: clamp(88px, 10vw, 110px);
+  height: clamp(88px, 10vw, 110px);
+  object-fit: contain;
+  flex: none;
+  filter: drop-shadow(0 12px 24px rgba(92, 99, 231, 0.12));
+}
+
+.identity-copy {
+  display: grid;
+  justify-items: center;
+  gap: 8px;
+}
+
+.identity-copy h1,
+.identity-copy p,
+.hero-copy h2,
+.button-label {
+  margin: 0;
+}
+
+.identity-copy h1 {
+  max-width: none;
+  font-size: clamp(1.55rem, 2.45vw, 2.55rem);
+  line-height: 1.1;
+  font-weight: 800;
+  letter-spacing: -0.04em;
+  color: #22203d;
+  white-space: nowrap;
+}
+
+.identity-copy p {
+  font-size: clamp(1.08rem, 1.38vw, 1.42rem);
+  line-height: 1.2;
+  font-weight: 700;
+  color: #4d466f;
+  text-wrap: balance;
+}
+
+.hero-panel {
+  padding: 0 34px 18px;
+  display: grid;
+  justify-items: center;
+  gap: 10px;
+  text-align: center;
+}
+
+.hero-copy {
+  width: min(100%, 1180px);
+  display: grid;
+  justify-items: center;
+}
+
+.hero-copy h2 {
+  max-width: none;
+  min-height: auto;
+  font-size: clamp(1.65rem, 3vw, 2.9rem);
+  line-height: 1.12;
+  font-weight: 800;
+  letter-spacing: -0.04em;
+  color: var(--accent-strong);
+  white-space: nowrap;
+}
+
+.typewriter-text {
+  position: relative;
+  display: inline-block;
+  padding: 0.04em 0.08em 0.08em;
+  opacity: 0;
+  transform: translateY(18px) scale(0.985);
+  filter: blur(10px);
+  transition:
+    opacity 0.75s ease,
+    transform 0.75s cubic-bezier(0.2, 0.8, 0.2, 1),
+    filter 0.75s ease;
+  overflow: hidden;
+}
+
+.typewriter-text::before {
+  content: "";
+  position: absolute;
+  inset: -8% -5%;
+  background: linear-gradient(
+    112deg,
+    transparent 0%,
+    rgba(255, 255, 255, 0) 38%,
+    rgba(255, 255, 255, 0.78) 49%,
+    rgba(255, 255, 255, 0.18) 56%,
+    transparent 66%
+  );
+  transform: translateX(-135%) skewX(-18deg);
+  opacity: 0;
+  pointer-events: none;
+}
+
+.typewriter-text.is-ready {
+  opacity: 1;
+  transform: translateY(0) scale(1);
+  filter: blur(0);
+  text-shadow: 0 16px 28px rgba(92, 99, 231, 0.12);
+}
+
+.typewriter-text.is-ready::before {
+  opacity: 1;
+  animation: title-sheen 1.45s cubic-bezier(0.22, 1, 0.36, 1) 0.12s both;
+}
+
+.result-card {
+  margin: 6px 34px 18px;
+  padding: 0;
+  min-height: 0;
+  position: relative;
+  background: transparent;
+  border: 0;
+  box-shadow: none;
+  overflow: visible;
+}
+
+.result-card.is-visible {
+  animation: result-card-in 0.3s ease;
+}
+
+.result-card.is-updating {
+  box-shadow: none;
+}
+
+.result-feed {
+  display: grid;
+  gap: 16px;
+}
+
+.result-thread-item {
+  padding: 22px 24px;
+  border-radius: 24px;
+  background: rgba(255, 255, 255, 0.96);
+  border: 1px solid rgba(132, 141, 231, 0.14);
+  box-shadow: 0 14px 28px rgba(92, 99, 231, 0.06);
+}
+
+.result-thread-item:nth-child(even) {
+  background: rgba(255, 253, 249, 0.96);
+  border-color: rgba(240, 191, 143, 0.18);
+}
+
+.atom-loader {
+  --atom-size: 58px;
+  --atom-border: rgba(92, 99, 231, 0.26);
+  --atom-glow: rgba(92, 99, 231, 0.2);
+  position: relative;
+  width: var(--atom-size);
+  height: var(--atom-size);
+  display: inline-grid;
+  place-items: center;
+  border-radius: 50%;
+  filter: drop-shadow(0 10px 22px var(--atom-glow));
+}
+
+.atom-loader-sm {
+  --atom-size: 30px;
+  position: absolute;
+  left: 18px;
+  top: 50%;
+  transform: translateY(-50%);
+  z-index: 1;
+}
+
+.atom-loader-inline {
+  --atom-size: 42px;
+}
+
+.atom-core {
+  width: calc(var(--atom-size) * 0.28);
+  height: calc(var(--atom-size) * 0.28);
+  border-radius: 50%;
+  background: radial-gradient(circle at 35% 35%, #ffffff 0%, #ffe4eb 28%, #9ba9ff 68%, #5c63e7 100%);
+  box-shadow:
+    0 0 0 calc(var(--atom-size) * 0.085) rgba(255, 255, 255, 0.28),
+    0 0 calc(var(--atom-size) * 0.34) rgba(92, 99, 231, 0.24);
+  position: relative;
+  z-index: 2;
+}
+
+.atom-orbit {
+  position: absolute;
+  inset: 6%;
+  border: 1.5px solid var(--atom-border);
+  border-radius: 50%;
+  will-change: transform;
+}
+
+.atom-orbit-a {
+  transform: rotate(10deg);
+}
+
+.atom-orbit-b {
+  inset: 14%;
+  transform: rotate(72deg);
+}
+
+.atom-orbit-c {
+  inset: 14%;
+  transform: rotate(-58deg);
+}
+
+.atom-electron {
+  position: absolute;
+  width: calc(var(--atom-size) * 0.12);
+  height: calc(var(--atom-size) * 0.12);
+  border-radius: 50%;
+  box-shadow: 0 0 calc(var(--atom-size) * 0.18) rgba(255, 255, 255, 0.34);
+}
+
+.atom-orbit-a .atom-electron {
+  top: calc(var(--atom-size) * -0.045);
+  left: 50%;
+  transform: translateX(-50%);
+  background: radial-gradient(circle at 35% 35%, #ffffff 0%, #ffd7df 38%, #ff8ba7 100%);
+}
+
+.atom-orbit-b .atom-electron {
+  bottom: calc(var(--atom-size) * -0.05);
+  left: 50%;
+  transform: translateX(-50%);
+  background: radial-gradient(circle at 35% 35%, #ffffff 0%, #dbe2ff 42%, #7e90ff 100%);
+}
+
+.atom-orbit-c .atom-electron {
+  top: 50%;
+  right: calc(var(--atom-size) * -0.05);
+  transform: translateY(-50%);
+  background: radial-gradient(circle at 35% 35%, #ffffff 0%, #ffe6b9 40%, #f0b558 100%);
+}
+
+body.is-generating .result-card:not(.has-entry) .atom-orbit-a,
+.generate-button.is-loading .atom-orbit-a {
+  animation: atom-orbit-a-spin 1.75s linear infinite;
+}
+
+body.is-generating .result-card:not(.has-entry) .atom-orbit-b,
+.generate-button.is-loading .atom-orbit-b {
+  animation: atom-orbit-b-spin 1.2s linear infinite;
+}
+
+body.is-generating .result-card:not(.has-entry) .atom-orbit-c,
+.generate-button.is-loading .atom-orbit-c {
+  animation: atom-orbit-c-spin 2.25s linear infinite;
+}
+
+body.is-generating .result-card:not(.has-entry) .atom-core,
+.generate-button.is-loading .atom-core {
+  animation: atom-core-pulse 1s ease-in-out infinite alternate;
+}
+
+.result-meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-bottom: 16px;
+}
+
+.result-meta span {
+  min-height: 32px;
+  padding: 0 12px;
+  border-radius: 999px;
+  background: rgba(235, 238, 255, 0.9);
+  color: var(--accent-strong);
+  display: inline-flex;
+  align-items: center;
+  font-size: 0.82rem;
+  font-weight: 700;
+  line-height: 1;
+}
+
+.result-meta span:nth-child(4n + 2) {
+  background: rgba(255, 235, 240, 0.9);
+  color: #b44c70;
+}
+
+.result-meta span:nth-child(4n + 3) {
+  background: rgba(255, 243, 223, 0.95);
+  color: #9f6e19;
+}
+
+.result-meta span:nth-child(4n + 4) {
+  background: rgba(234, 246, 255, 0.95);
+  color: #356c97;
+}
+
+.result-meta span + span::before {
+  content: none;
+}
+
+.result-section {
+  padding: 0;
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+}
+
+.result-section + .result-section {
+  margin-top: 18px;
+  padding-top: 18px;
+  border-top: 1px solid rgba(132, 141, 231, 0.14);
+}
+
+.result-source-title,
+.result-questions-title {
+  margin: 0;
+  min-height: 32px;
+  padding: 0 14px;
+  border-radius: 999px;
+  display: inline-flex;
+  align-items: center;
+  font-size: 0.78rem;
+  font-weight: 800;
+  letter-spacing: 0.04em;
+}
+
+.result-source-title {
+  background: rgba(236, 238, 255, 0.92);
+  color: var(--accent-strong);
+}
+
+.result-questions-title {
+  background: rgba(255, 244, 225, 0.96);
+  color: #9f6e19;
+}
+
+.result-section-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-bottom: 10px;
+}
+
+.copy-button {
+  width: auto;
+  height: auto;
+  padding: 4px;
+  border: 0;
+  border-radius: 10px;
+  background: transparent;
+  color: #68639a;
+  display: inline-grid;
+  place-items: center;
+  cursor: pointer;
+  transition: background 0.18s ease, color 0.18s ease;
+}
+
+.copy-button:hover {
+  background: rgba(235, 238, 255, 0.78);
+  color: var(--accent-strong);
+}
+
+.copy-button.is-copied {
+  background: rgba(226, 244, 233, 0.92);
+  color: #2f8a54;
+}
+
+.copy-button svg {
+  width: 17px;
+  height: 17px;
+}
+
+.result-source,
+.result-note,
+.result-message {
+  margin: 0;
+  padding: 0;
+  line-height: 1.8;
+}
+
+.result-source {
+  background: transparent;
+  border: 0;
+  white-space: pre-wrap;
+}
+
+.result-questions {
+  display: grid;
+  gap: 0;
+  list-style: none;
+  padding: 0;
+  margin: 0;
+  counter-reset: question;
+}
+
+.result-questions li {
+  position: relative;
+  padding: 12px 0 12px 32px;
+  background: transparent;
+  border: 0;
+  line-height: 1.75;
+  counter-increment: question;
+}
+
+.result-questions li + li {
+  border-top: 1px solid rgba(132, 141, 231, 0.12);
+}
+
+.result-questions li::before {
+  content: counter(question) ".";
+  position: absolute;
+  left: 0;
+  top: 12px;
+  width: auto;
+  height: auto;
+  border-radius: 0;
+  background: transparent;
+  color: var(--accent-strong);
+  display: inline-block;
+  font-size: 0.84rem;
+  font-weight: 700;
+}
+
+.result-note {
+  color: #726c9a;
+}
+
+.result-pending {
+  display: flex;
+  align-items: center;
+  gap: 14px;
+  padding: 4px 0;
+  background: transparent;
+}
+
+.result-pending .result-note {
+  padding: 0;
+  background: transparent;
+}
+
+.result-pending .atom-orbit-a {
+  animation: atom-orbit-a-spin 1.75s linear infinite;
+}
+
+.result-pending .atom-orbit-b {
+  animation: atom-orbit-b-spin 1.2s linear infinite;
+}
+
+.result-pending .atom-orbit-c {
+  animation: atom-orbit-c-spin 2.25s linear infinite;
+}
+
+.result-pending .atom-core {
+  animation: atom-core-pulse 1s ease-in-out infinite alternate;
+}
+
+.result-message {
+  color: #9f3d61;
+}
+
+.result-message-inline {
+  margin: 0 0 14px;
+}
+
+.landing-panel {
+  margin: 0 18px 18px;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1.2fr) minmax(280px, 0.95fr);
+  gap: 16px;
+}
+
+.landing-card {
+  padding: 20px 20px 18px;
+  border-radius: 24px;
+  background: linear-gradient(180deg, rgba(250, 249, 255, 0.98), rgba(255, 255, 255, 0.94));
+  border: 1px solid rgba(143, 154, 238, 0.16);
+  box-shadow: 0 14px 28px rgba(92, 99, 231, 0.06);
+  display: grid;
+  gap: 14px;
+}
+
+.landing-card-head {
+  padding: 14px 16px;
+  border-radius: 18px;
+  border: 1px solid rgba(146, 156, 239, 0.14);
+  background: rgba(255, 255, 255, 0.78);
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.72);
+  display: flex;
+  align-items: start;
+  justify-content: space-between;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.landing-kicker,
+.landing-card-note,
+.landing-guide-list {
+  margin: 0;
+}
+
+.landing-kicker {
+  font-size: 0.8rem;
+  font-weight: 800;
+  letter-spacing: 0.04em;
+  color: #7b75a6;
+  flex: none;
+}
+
+.landing-card-note {
+  font-size: 0.88rem;
+  line-height: 1.65;
+  color: #807aa8;
+  flex: 1 1 220px;
+  min-width: 0;
+}
+
+.landing-samples .landing-card-head {
+  display: grid;
+  grid-template-columns: 1fr;
+  align-items: start;
+  gap: 8px;
+}
+
+.landing-samples .landing-kicker {
+  white-space: nowrap;
+}
+
+.landing-samples .landing-card-note {
+  white-space: normal;
+}
+
+.landing-samples .landing-card-note {
+  font-size: 0.84rem;
+  line-height: 1.4;
+}
+
+.landing-guide-list {
+  padding: 0;
+  list-style: none;
+  counter-reset: landing-step;
+  display: grid;
+  gap: 10px;
+  color: #4f4a79;
+  line-height: 1.65;
+}
+
+.landing-guide-list li {
+  position: relative;
+  padding: 14px 16px 14px 50px;
+  border-radius: 18px;
+  border: 1px solid rgba(146, 156, 239, 0.14);
+  background: rgba(255, 255, 255, 0.78);
+  counter-increment: landing-step;
+}
+
+.landing-guide-list li::before {
+  content: counter(landing-step);
+  position: absolute;
+  left: 16px;
+  top: 14px;
+  width: 22px;
+  height: 22px;
+  border-radius: 999px;
+  background: rgba(92, 99, 231, 0.12);
+  color: var(--accent-strong);
+  display: inline-grid;
+  place-items: center;
+  font-size: 0.76rem;
+  font-weight: 800;
+  line-height: 1;
+}
+
+.landing-guide-list strong {
+  color: var(--accent-strong);
+}
+
+.landing-sample-grid {
+  display: grid;
+  gap: 12px;
+}
+
+.sample-card {
+  width: 100%;
+  padding: 14px 16px;
+  border: 1px solid rgba(146, 156, 239, 0.16);
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.84);
+  color: inherit;
+  display: grid;
+  gap: 6px;
+  text-align: left;
+  cursor: pointer;
+  transition: transform 0.18s ease, box-shadow 0.18s ease, border-color 0.18s ease, background 0.18s ease;
+}
+
+.sample-card:hover {
+  transform: translateY(-1px);
+  border-color: rgba(92, 99, 231, 0.24);
+  background: rgba(255, 255, 255, 0.96);
+  box-shadow: 0 12px 22px rgba(92, 99, 231, 0.08);
+}
+
+.sample-card strong,
+.sample-card span {
+  display: block;
+}
+
+.sample-card strong {
+  font-size: 0.95rem;
+  color: #474271;
+}
+
+.sample-card span {
+  font-size: 0.84rem;
+  line-height: 1.55;
+  color: #7d78a6;
+}
+
+.landing-runtime-badge {
+  min-height: 30px;
+  padding: 0 12px;
+  border-radius: 999px;
+  display: inline-flex;
+  align-items: center;
+  flex: none;
+  font-size: 0.78rem;
+  font-weight: 800;
+  letter-spacing: 0.02em;
+}
+
+.landing-runtime-badge.is-ready {
+  background: rgba(227, 244, 233, 0.92);
+  color: #2f8a54;
+}
+
+.landing-runtime-badge.is-pending {
+  background: rgba(236, 238, 255, 0.92);
+  color: var(--accent-strong);
+}
+
+.landing-runtime-badge.is-error {
+  background: rgba(255, 235, 240, 0.92);
+  color: #b44c70;
+}
+
+.landing-system > .landing-card-note {
+  padding: 14px 16px;
+  border-radius: 18px;
+  border: 1px solid rgba(146, 156, 239, 0.14);
+  background: rgba(255, 255, 255, 0.78);
+}
+
+.landing-system-list {
+  display: grid;
+  gap: 10px;
+}
+
+.landing-system-row {
+  display: grid;
+  gap: 4px;
+  padding: 14px 16px;
+  border: 1px solid rgba(146, 156, 239, 0.14);
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.78);
+}
+
+.landing-system-row:first-child {
+  padding-top: 14px;
+}
+
+.landing-system-row span,
+.landing-system-row strong {
+  display: block;
+}
+
+.landing-system-row span {
+  font-size: 0.76rem;
+  font-weight: 700;
+  letter-spacing: 0.03em;
+  color: #8b86b2;
+}
+
+.landing-system-row strong {
+  font-size: 0.96rem;
+  line-height: 1.45;
+  color: #474271;
+  overflow-wrap: anywhere;
+  word-break: break-word;
+}
+
+.composer {
+  margin: 0 18px 18px;
+  padding: 20px 22px;
+  border-radius: 28px;
+  background: linear-gradient(180deg, rgba(247, 248, 255, 0.96), rgba(255, 255, 255, 0.94));
+  border-color: rgba(143, 154, 238, 0.22);
+}
+
+.input-shell {
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+  gap: 18px;
+  min-height: 128px;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  transition:
+    min-height 0.22s ease,
+    padding 0.22s ease;
+}
+
+.input-shell.is-expanded {
+  min-height: 172px;
+}
+
+.visually-hidden {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
+.input-shell textarea {
+  width: 100%;
+  min-height: 30px;
+  max-height: 240px;
+  border: 0;
+  outline: none;
+  resize: none;
+  background: transparent;
+  color: #4b4670;
+  line-height: 1.72;
+  padding: 0;
+  transition: height 0.18s ease;
+}
+
+.input-shell textarea::placeholder {
+  color: #8e88b6;
+}
+
+.voice-status {
+  min-height: 0;
+  font-size: 0.82rem;
+  color: #7f7aa8;
+  line-height: 1.5;
+  max-width: min(100%, 420px);
+  text-align: right;
+}
+
+.voice-status.is-empty {
+  display: none;
+}
+
+.voice-status.is-active {
+  color: var(--accent-strong);
+}
+
+.voice-status.is-error {
+  color: #b44c70;
+}
+
+.voice-button {
+  width: 42px;
+  min-width: 42px;
+  min-height: 42px;
+  padding: 0;
+  border: 1px solid rgba(128, 138, 235, 0.2);
+  border-radius: 999px;
+  background: rgba(240, 242, 255, 0.82);
+  color: #5f5aa0;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  transition:
+    transform 0.18s ease,
+    box-shadow 0.18s ease,
+    border-color 0.18s ease,
+    background 0.18s ease,
+    color 0.18s ease;
+}
+
+.voice-button:hover:not(:disabled) {
+  transform: translateY(-1px);
+  border-color: rgba(92, 99, 231, 0.3);
+  background: rgba(235, 238, 255, 0.94);
+  box-shadow: 0 10px 20px rgba(92, 99, 231, 0.08);
+}
+
+.voice-button.is-listening {
+  border-color: rgba(224, 96, 124, 0.28);
+  background: rgba(255, 235, 240, 0.92);
+  color: #b44c70;
+  box-shadow: 0 0 0 6px rgba(224, 96, 124, 0.08);
+}
+
+.voice-button:disabled,
+.voice-button.is-unsupported {
+  opacity: 0.56;
+  cursor: not-allowed;
+  box-shadow: none;
+}
+
+.voice-button-icon {
+  width: 18px;
+  height: 18px;
+  display: inline-flex;
+}
+
+.voice-button-icon svg {
+  width: 100%;
+  height: 100%;
+}
+
+.composer-actions {
+  display: flex;
+  align-items: end;
+  justify-content: space-between;
+  gap: 14px;
+  padding-top: 16px;
+  border-top: 1px solid rgba(132, 141, 231, 0.12);
+}
+
+.action-cluster {
+  min-width: 0;
+  margin-left: auto;
+  display: grid;
+  justify-items: end;
+  gap: 10px;
+}
+
+.action-buttons {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 10px;
+  min-width: 0;
+}
+
+.count-shell {
+  min-height: 0;
+  padding: 0;
+  display: inline-grid;
+  gap: 8px;
+  color: #6a6493;
+  white-space: nowrap;
+}
+
+.count-label {
+  font-size: 0.78rem;
+  font-weight: 500;
+  color: #7a75a6;
+}
+
+.count-stepper {
+  display: inline-grid;
+  grid-template-columns: 42px minmax(62px, auto) 42px;
+  align-items: center;
+  gap: 8px;
+}
+
+.count-button {
+  width: 42px;
+  height: 42px;
+  border: 0;
+  border-radius: 12px;
+  background: linear-gradient(180deg, rgba(231, 235, 255, 0.98), rgba(246, 244, 255, 0.96));
+  color: var(--accent-strong);
+  display: inline-grid;
+  place-items: center;
+  font-weight: 700;
+  cursor: pointer;
+  transition: transform 0.18s ease, box-shadow 0.18s ease, opacity 0.18s ease;
+}
+
+.count-button:hover:not(:disabled) {
+  transform: translateY(-1px);
+  box-shadow: 0 10px 20px rgba(92, 99, 231, 0.14);
+}
+
+.count-button:disabled {
+  opacity: 0.42;
+  cursor: default;
+}
+
+.count-button span {
+  font-size: 1.3rem;
+  line-height: 1;
+}
+
+.count-value {
+  min-width: 62px;
+  min-height: 42px;
+  border-radius: 12px;
+  background: rgba(240, 242, 255, 0.7);
+  color: #4f4a7a;
+  display: inline-grid;
+  place-items: center;
+  font-weight: 800;
+}
+
+.generate-button {
+  min-width: 214px;
+  min-height: 58px;
+  padding: 0 20px 0 62px;
+  border-radius: 16px;
+  border: 0;
+  background: linear-gradient(135deg, var(--accent), var(--warm));
+  box-shadow: 0 14px 30px rgba(93, 99, 190, 0.22);
+  color: #fff;
+  position: relative;
+  overflow: hidden;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 12px;
+  cursor: pointer;
+  transition: transform 0.18s ease, box-shadow 0.18s ease;
+}
+
+.generate-button:hover:not(:disabled) {
+  transform: translateY(-1px);
+  box-shadow: 0 18px 34px rgba(93, 99, 190, 0.26);
+}
+
+.generate-button:disabled {
+  cursor: wait;
+}
+
+.generate-button::before {
+  content: "";
+  position: absolute;
+  inset: 1px;
+  border-radius: inherit;
+  background: linear-gradient(135deg, rgba(255, 255, 255, 0.12), transparent 48%, rgba(255, 255, 255, 0.1));
+}
+
+.generate-button .atom-loader {
+  --atom-border: rgba(255, 255, 255, 0.34);
+  --atom-glow: rgba(255, 255, 255, 0.28);
+  opacity: 0.94;
+  transition: transform 0.24s ease, opacity 0.24s ease, filter 0.24s ease;
+}
+
+.generate-button .atom-core {
+  background: radial-gradient(circle at 35% 35%, #ffffff 0%, #ffe7ed 30%, #ffc9d4 58%, #ffffff 100%);
+  box-shadow:
+    0 0 0 calc(var(--atom-size) * 0.085) rgba(255, 255, 255, 0.16),
+    0 0 calc(var(--atom-size) * 0.26) rgba(255, 255, 255, 0.22);
+}
+
+.generate-button.is-loading .atom-loader {
+  opacity: 1;
+  filter: drop-shadow(0 0 14px rgba(255, 255, 255, 0.32));
+}
+
+.button-label {
+  font-size: 0.96rem;
+  font-weight: 700;
+  position: relative;
+  z-index: 1;
+}
+
+@keyframes result-card-in {
+  from {
+    opacity: 0;
+    transform: translateY(16px);
+  }
+
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes atom-core-pulse {
+  from {
+    transform: scale(0.92);
+  }
+
+  to {
+    transform: scale(1.1);
+  }
+}
+
+@keyframes atom-orbit-a-spin {
+  from {
+    transform: rotate(10deg);
+  }
+
+  to {
+    transform: rotate(370deg);
+  }
+}
+
+@keyframes atom-orbit-b-spin {
+  from {
+    transform: rotate(72deg);
+  }
+
+  to {
+    transform: rotate(-288deg);
+  }
+}
+
+@keyframes atom-orbit-c-spin {
+  from {
+    transform: rotate(-58deg);
+  }
+
+  to {
+    transform: rotate(302deg);
+  }
+}
+
+@keyframes title-sheen {
+  0% {
+    transform: translateX(-135%) skewX(-18deg);
+  }
+
+  100% {
+    transform: translateX(135%) skewX(-18deg);
+  }
+}
+
+@media (max-width: 1180px) {
+  .landing-panel {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .landing-system {
+    grid-column: 1 / -1;
+  }
+
+  .composer-actions {
+    flex-direction: column;
+    align-items: stretch;
+  }
+
+  .action-cluster {
+    width: 100%;
+    justify-items: stretch;
+  }
+
+  .action-buttons {
+    width: 100%;
+    justify-content: flex-start;
+  }
+
+  .voice-status {
+    max-width: none;
+    text-align: left;
+  }
+
+  .count-shell {
+    width: 100%;
+  }
+
+  .action-buttons .generate-button {
+    width: auto;
+    min-width: 0;
+    flex: 1 1 auto;
+  }
+}
+
+@media (max-width: 900px) {
+  .page-shell {
+    width: 100%;
+    min-height: 100vh;
+    margin: 0;
+    border-radius: 0;
+    grid-template-columns: 1fr;
+  }
+
+  body.sidebar-open .page-shell,
+  .page-shell {
+    grid-template-columns: 1fr;
+  }
+
+  .sidebar {
+    border-right: 0;
+    border-bottom: 1px solid var(--line);
+  }
+
+  .topbar,
+  .hero-panel {
+    padding-left: 20px;
+    padding-right: 20px;
+  }
+
+  .result-card {
+    margin-left: 20px;
+    margin-right: 20px;
+  }
+
+  .landing-panel {
+    margin-left: 12px;
+    margin-right: 12px;
+    grid-template-columns: 1fr;
+  }
+
+  .landing-system {
+    grid-column: auto;
+  }
+
+  .landing-samples .landing-card-head {
+    grid-template-columns: 1fr;
+  }
+
+  .landing-samples .landing-kicker,
+  .landing-samples .landing-card-note {
+    white-space: normal;
+  }
+
+  .composer {
+    margin-left: 12px;
+    margin-right: 12px;
+  }
+}
+
+@media (max-width: 760px) {
+  .identity-copy h1,
+  .hero-copy h2 {
+    white-space: normal;
+  }
+}
+
+@media (max-width: 640px) {
+  .topbar {
+    padding-top: 30px;
+  }
+
+  .logo {
+    width: 68px;
+    height: 68px;
+  }
+
+  .hero-copy h2 {
+    font-size: clamp(1.35rem, 7.4vw, 2.1rem);
+    min-height: auto;
+  }
+
+  .result-card {
+    min-height: 180px;
+    padding: 0;
+  }
+
+  .generate-button {
+    min-width: 0;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    animation: none !important;
+    transition: none !important;
+    scroll-behavior: auto !important;
+  }
+}

HVU_QA/generate_question.py

@@ -0,0 +1,383 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import threading
+from pathlib import Path
+from typing import Any
+
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+
+
+def raise_missing_dependency_error(exc: ModuleNotFoundError) -> None:
+    root = Path(__file__).resolve().parent
+    requirements = root / "requirements.txt"
+    message = [
+        f"Thiếu thư viện Python: {exc.name}",
+        f"Interpreter hiện tại: {sys.executable}",
+    ]
+    if requirements.exists():
+        message.extend(
+            [
+                "Cài đặt dependencies bằng lệnh:",
+                f"{sys.executable} -m pip install -r {requirements}",
+            ]
+        )
+    raise SystemExit("\n".join(message)) from exc
+
+
+try:
+    import torch
+    from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+except ModuleNotFoundError as exc:
+    raise_missing_dependency_error(exc)
+
+
+APP_TITLE = "Mô hình sinh câu hỏi thường gặp"
+TASK_PREFIX = "sinh câu hỏi"
+QUESTION_LIMIT = 100
+GENERATION_PASSES = (
+    (0.9, 0.95, None, 1, 4),
+    (1.0, 0.97, 16, 1, 5),
+    (1.08, 0.99, 8, 2, 6),
+)
+
+
+def normalize_text(text: Any) -> str:
+    return " ".join(str(text or "").split())
+
+
+def unique_text(items: list[str]) -> list[str]:
+    seen: set[str] = set()
+    output: list[str] = []
+    for item in items:
+        value = normalize_text(item)
+        key = value.lower()
+        if key and key not in seen:
+            seen.add(key)
+            output.append(value)
+    return output
+
+
+def parse_question_count(value: Any, default: int = 5) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        parsed = default
+    return max(1, min(parsed, QUESTION_LIMIT))
+
+
+def format_questions(items: list[str]) -> str:
+    if not items:
+        return "Không sinh được câu hỏi phù hợp."
+    return "\n".join(f"{index}. {item}" for index, item in enumerate(items, 1))
+
+
+def resolve_model_dir(model_dir: str | Path, prefer_nested_model: bool = True) -> Path:
+    model_root = Path(model_dir).expanduser().resolve()
+    nested_candidates = [model_root / "best-model", model_root / "final-model"]
+    candidates = [*nested_candidates, model_root] if prefer_nested_model else [model_root, *nested_candidates]
+    for candidate in candidates:
+        if candidate.is_dir() and (candidate / "config.json").exists():
+            return candidate
+    raise FileNotFoundError(f"Không tìm thấy thư mục mô hình hợp lệ: {model_root}")
+
+
+def parse_dtype(value: str) -> torch.dtype:
+    normalized = value.strip().lower()
+    mapping = {
+        "float16": torch.float16,
+        "fp16": torch.float16,
+        "float32": torch.float32,
+        "fp32": torch.float32,
+        "bfloat16": torch.bfloat16,
+        "bf16": torch.bfloat16,
+    }
+    if normalized not in mapping:
+        raise ValueError(f"Không hỗ trợ gpu_dtype={value}")
+    return mapping[normalized]
+
+
+class QuestionGenerator:
+    def __init__(
+        self,
+        model_dir: str | Path = "t5-viet-qg-finetuned",
+        task_prefix: str = TASK_PREFIX,
+        max_source_length: int = 512,
+        max_new_tokens: int = 64,
+        device: str = "auto",
+        cpu_threads: int | None = None,
+        gpu_dtype: str = "auto",
+        prefer_nested_model: bool = True,
+    ) -> None:
+        self.model_root = Path(model_dir).expanduser().resolve()
+        self.model_dir = resolve_model_dir(model_dir, prefer_nested_model=prefer_nested_model)
+        self.task_prefix = task_prefix
+        self.max_source_length = max_source_length
+        self.max_new_tokens = max_new_tokens
+        self.requested_device = device
+        self.cpu_threads = cpu_threads
+        self.gpu_dtype = gpu_dtype
+        self.prefer_nested_model = prefer_nested_model
+        self.device: torch.device | None = None
+        self.dtype: torch.dtype | None = None
+        self.tokenizer = None
+        self.model = None
+        self._load_lock = threading.Lock()
+
+    def _resolve_device(self) -> torch.device:
+        requested = self.requested_device.lower()
+        if requested == "cpu":
+            return torch.device("cpu")
+        if requested == "cuda":
+            if not torch.cuda.is_available():
+                raise RuntimeError("Bạn đã chọn device=cuda nhưng máy hiện tại không có CUDA.")
+            return torch.device("cuda")
+        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def _resolve_dtype(self) -> torch.dtype:
+        if self.device is None or self.device.type != "cuda":
+            return torch.float32
+        if self.gpu_dtype == "auto":
+            if hasattr(torch.cuda, "is_bf16_supported") and torch.cuda.is_bf16_supported():
+                return torch.bfloat16
+            return torch.float16
+        return parse_dtype(self.gpu_dtype)
+
+    def _configure_runtime(self) -> None:
+        if self.device is None:
+            return
+        if self.device.type == "cpu":
+            if self.cpu_threads:
+                torch.set_num_threads(max(1, int(self.cpu_threads)))
+                if hasattr(torch, "set_num_interop_threads"):
+                    torch.set_num_interop_threads(max(1, min(int(self.cpu_threads), 4)))
+            return
+
+        if hasattr(torch.backends, "cuda") and hasattr(torch.backends.cuda, "matmul"):
+            torch.backends.cuda.matmul.allow_tf32 = True
+        if hasattr(torch.backends, "cudnn"):
+            torch.backends.cudnn.allow_tf32 = True
+            torch.backends.cudnn.benchmark = True
+
+    def load(self) -> None:
+        if self.model is not None and self.tokenizer is not None:
+            return
+
+        with self._load_lock:
+            if self.model is not None and self.tokenizer is not None:
+                return
+
+            self.device = self._resolve_device()
+            self.dtype = self._resolve_dtype()
+            self._configure_runtime()
+
+            model_kwargs: dict[str, Any] = {}
+            if self.device.type == "cuda":
+                model_kwargs["torch_dtype"] = self.dtype
+                model_kwargs["low_cpu_mem_usage"] = True
+
+            self.tokenizer = AutoTokenizer.from_pretrained(str(self.model_dir), use_fast=True)
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(str(self.model_dir), **model_kwargs)
+            self.model.to(self.device)
+            self.model.eval()
+
+    def metadata(self) -> dict[str, Any]:
+        active_device = self.device.type if self.device is not None else None
+        predicted_device = "cuda" if torch.cuda.is_available() and self.requested_device != "cpu" else "cpu"
+        return {
+            "title": APP_TITLE,
+            "model_root": str(self.model_root),
+            "model_dir": str(self.model_dir),
+            "requested_device": self.requested_device,
+            "active_device": active_device,
+            "predicted_device": predicted_device,
+            "loaded": self.model is not None,
+            "gpu_available": torch.cuda.is_available(),
+            "gpu_dtype": None if self.dtype is None else str(self.dtype).replace("torch.", ""),
+            "cpu_threads": torch.get_num_threads(),
+        }
+
+    def _candidate_answers(self, text: str, limit: int) -> list[str]:
+        text = normalize_text(text)
+        if not text:
+            return []
+
+        candidates: list[str] = []
+        split_pattern = r"(?<=[.!?])\s+|\n+"
+        for sentence in [normalize_text(part) for part in re.split(split_pattern, text) if normalize_text(part)]:
+            if 3 <= len(sentence.split()) <= 30:
+                candidates.append(sentence)
+            for clause in (normalize_text(part) for part in re.split(r"\s*[,;:]\s*", sentence)):
+                if 3 <= len(clause.split()) <= 20:
+                    candidates.append(clause)
+
+        if not candidates:
+            words = text.split()
+            candidates = [" ".join(words[: min(12, len(words))])] if words else [text]
+
+        ranked = sorted(unique_text(candidates), key=lambda item: (abs(len(item.split()) - 10), len(item)))
+        return ranked[:limit]
+
+    def _build_prompt(self, context: str, answer: str) -> str:
+        return f"{self.task_prefix}:\nngữ cảnh: {context}\nđáp án: {answer}"
+
+    @torch.inference_mode()
+    def _sample(self, context: str, answer: str, count: int, temperature: float, top_p: float) -> list[str]:
+        if self.tokenizer is None or self.model is None or self.device is None:
+            raise RuntimeError("Model chưa được load.")
+
+        inputs = self.tokenizer(
+            self._build_prompt(context, answer),
+            return_tensors="pt",
+            truncation=True,
+            max_length=self.max_source_length,
+        ).to(self.device)
+        outputs = self.model.generate(
+            **inputs,
+            max_new_tokens=self.max_new_tokens,
+            do_sample=True,
+            temperature=temperature,
+            top_p=top_p,
+            num_return_sequences=count,
+            no_repeat_ngram_size=3,
+            repetition_penalty=1.1,
+        )
+        questions: list[str] = []
+        for token_ids in outputs:
+            question = normalize_text(self.tokenizer.decode(token_ids, skip_special_tokens=True))
+            if question:
+                questions.append(question if question.endswith("?") else f"{question}?")
+        return [question for question in unique_text(questions) if len(question.split()) >= 3]
+
+    @torch.inference_mode()
+    def _beam_search(self, context: str, answer: str, count: int) -> list[str]:
+        if self.tokenizer is None or self.model is None or self.device is None:
+            raise RuntimeError("Model chưa được load.")
+
+        inputs = self.tokenizer(
+            self._build_prompt(context, answer),
+            return_tensors="pt",
+            truncation=True,
+            max_length=self.max_source_length,
+        ).to(self.device)
+        outputs = self.model.generate(
+            **inputs,
+            max_new_tokens=self.max_new_tokens,
+            num_beams=max(4, count),
+            num_return_sequences=min(count, 4),
+            early_stopping=True,
+            no_repeat_ngram_size=3,
+            repetition_penalty=1.1,
+        )
+        questions: list[str] = []
+        for token_ids in outputs:
+            question = normalize_text(self.tokenizer.decode(token_ids, skip_special_tokens=True))
+            if question:
+                questions.append(question if question.endswith("?") else f"{question}?")
+        return [question for question in unique_text(questions) if len(question.split()) >= 3]
+
+    def generate(self, text: str, count: int = 5) -> list[str]:
+        self.load()
+        context = normalize_text(text)
+        if not context:
+            raise ValueError("Vui lòng nhập đoạn văn.")
+
+        count = parse_question_count(count)
+        pool = unique_text(
+            self._candidate_answers(context, max(32, count * 5)) + [context[:180], context[:280], context]
+        )
+        output: list[str] = []
+        seen: set[str] = set()
+
+        for temperature, top_p, limit, rounds, floor in GENERATION_PASSES:
+            answers = pool[:limit] if limit else pool
+            for _ in range(rounds):
+                for answer in answers:
+                    remaining = count - len(output)
+                    if remaining <= 0:
+                        return output[:count]
+                    sample_count = min(8, max(floor, remaining * 2))
+                    for question in self._sample(context, answer, sample_count, temperature, top_p):
+                        key = question.lower()
+                        if key not in seen:
+                            seen.add(key)
+                            output.append(question)
+                            if len(output) >= count:
+                                return output[:count]
+
+        for answer in pool[: min(8, len(pool))]:
+            remaining = count - len(output)
+            if remaining <= 0:
+                break
+            for question in self._beam_search(context, answer, remaining):
+                key = question.lower()
+                if key not in seen:
+                    seen.add(key)
+                    output.append(question)
+                    if len(output) >= count:
+                        break
+
+        return output[:count]
+
+
+def read_input_text(args: argparse.Namespace) -> str:
+    if args.text:
+        return args.text
+    if args.input_file:
+        return Path(args.input_file).read_text(encoding="utf-8")
+    if sys.stdin.isatty():
+        return input("Nhập đoạn văn cần sinh câu hỏi:\n").strip()
+    return sys.stdin.read().strip()
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Sinh câu hỏi từ đoạn văn bằng model T5 fine-tuned.")
+    parser.add_argument("--model_dir", default="t5-viet-qg-finetuned")
+    parser.add_argument("--task_prefix", default=TASK_PREFIX)
+    parser.add_argument("--max_source_length", type=int, default=512)
+    parser.add_argument("--max_new_tokens", type=int, default=64)
+    parser.add_argument("--num_questions", type=int, default=100)
+    parser.add_argument("--device", choices=["auto", "cpu", "cuda"], default="auto")
+    parser.add_argument("--cpu_threads", type=int, default=None)
+    parser.add_argument("--gpu_dtype", default="auto")
+    parser.add_argument("--text", default=None)
+    parser.add_argument("--input_file", default=None)
+    parser.add_argument("--output_format", choices=["text", "json"], default="text")
+    return parser
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")
+    generator = QuestionGenerator(
+        model_dir=args.model_dir,
+        task_prefix=args.task_prefix,
+        max_source_length=args.max_source_length,
+        max_new_tokens=args.max_new_tokens,
+        device=args.device,
+        cpu_threads=args.cpu_threads,
+        gpu_dtype=args.gpu_dtype,
+        prefer_nested_model=True,
+    )
+    text = read_input_text(args)
+    questions = generator.generate(text, parse_question_count(args.num_questions))
+    payload = {
+        "text": normalize_text(text),
+        "questions": questions,
+        "formatted": format_questions(questions),
+        "meta": generator.metadata(),
+    }
+    if args.output_format == "json":
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+        return
+    print(payload["formatted"])
+
+
+if __name__ == "__main__":
+    main()

HVU_QA/main.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import os
+import threading
+import webbrowser
+
+from backend import create_app
+
+app = create_app()
+
+
+def _as_bool(value: str | None, default: bool) -> bool:
+    if value is None:
+        return default
+    return value.strip().lower() not in {"0", "false", "no", "off"}
+
+
+def _open_browser_later(host: str, port: int) -> None:
+    if not _as_bool(os.getenv("HVU_OPEN_BROWSER"), True):
+        return
+    target_host = "127.0.0.1" if host in {"0.0.0.0", "::"} else host
+    url = f"http://{target_host}:{port}"
+    threading.Timer(1.2, lambda: webbrowser.open(url)).start()
+
+
+if __name__ == "__main__":
+    host = os.getenv("HVU_HOST", "127.0.0.1")
+    port = int(os.getenv("HVU_PORT", "5000"))
+    debug = _as_bool(os.getenv("HVU_DEBUG"), False)
+    _open_browser_later(host, port)
+    app.run(host=host, port=port, debug=debug, use_reloader=False)

HVU_QA/readme.md

@@ -0,0 +1,392 @@
+# HVU_QA
+
+Ứng dụng sinh câu hỏi từ đoạn văn bản bằng mô hình T5 tiếng Việt.
+
+Repo này hiện hỗ trợ **2 cách sử dụng**:
+
+- **Full project**: tải toàn bộ source code để dùng, chỉnh sửa, kiểm thử và phát triển tiếp.
+- **Standalone tool**: chỉ cần `HVU_QA_tool.py` hoặc `HVU_QA_tool.py` + `HVU_QA_tool.bat` để launcher tự dựng runtime, tự cài dependency, tự tải model và mở app.
+
+## 1. Cấu trúc project
+
+```text
+HVU_QA/
+├── backend/
+│   ├── __init__.py
+│   └── app.py
+├── frontend/
+│   ├── app.js
+│   ├── index.html
+│   └── style.css
+├── t5-viet-qg-finetuned/
+│   ├── config.json
+│   ├── model.safetensors
+│   ├── ...
+│   └── best-model/
+├── 40k_train.json
+├── fine_tune_qg.py
+├── generate_question.py
+├── HVU.png
+├── HVU_QA_end_to_end_guide.ipynb
+├── HVU_QA_tool.py
+├── HVU_QA_tool.bat
+├── main.py
+├── readme.md
+└── requirements.txt
+```
+
+## 2. Thành phần chính
+
+- `main.py`: điểm chạy chính của web app Flask trong full project.
+- `backend/app.py`: route web và API backend của full project.
+- `frontend/index.html`, `frontend/app.js`, `frontend/style.css`: giao diện và logic frontend của full project.
+- `generate_question.py`: lõi load model và sinh câu hỏi, đồng thời hỗ trợ CLI.
+- `fine_tune_qg.py`: script fine-tune model.
+- `HVU_QA_tool.py`: launcher đa chế độ.
+  - Nếu đứng trong full project: dùng source hiện tại.
+  - Nếu chỉ có mỗi file tool: tự tạo `.hvu_qa_tool_venv/` và `HVU_QA_runtime/`.
+- `HVU_QA_tool.bat`: file chạy nhanh cho Windows.
+- `HVU_QA_end_to_end_guide.ipynb`: notebook đã tách riêng 2 luồng `Full project` và `Quick tool`.
+
+## 3. Yêu cầu môi trường
+
+Khuyến nghị:
+
+- Python `3.11`
+- Windows PowerShell
+- `pip`
+
+Nếu muốn chạy bằng GPU NVIDIA, cần cài đúng bản `torch` tương thích CUDA của máy.
+
+## 4. Cách dùng A - Full project
+
+Đây là cách phù hợp nếu bạn muốn dùng và phát triển tiếp toàn bộ mã nguồn.
+
+Tạo môi trường ảo:
+
+```powershell
+python -m venv venv
+.\venv\Scripts\Activate.ps1
+```
+
+Cài dependencies:
+
+```powershell
+.\venv\Scripts\python -m pip install --upgrade pip
+.\venv\Scripts\python -m pip install -r requirements.txt
+```
+
+Nếu dùng GPU NVIDIA, nên cài đúng `torch` theo CUDA của máy trước, rồi mới cài phần còn lại trong `requirements.txt`.
+
+Đồng bộ model:
+
+```powershell
+.\venv\Scripts\python HVU_QA_tool.py --skip-run
+```
+
+Chạy app:
+
+```powershell
+.\venv\Scripts\python main.py
+```
+
+Mặc định ứng dụng chạy tại `http://127.0.0.1:5000`.
+
+## 5. Cách dùng B - Standalone tool chỉ với một file
+
+Đây là cách phù hợp cho **người dùng cuối** chỉ muốn chạy mô hình sinh câu hỏi mà không cần tải full source code.
+
+Bạn chỉ cần:
+
+- `HVU_QA_tool.py`
+- hoặc `HVU_QA_tool.py` + `HVU_QA_tool.bat`
+
+Đặt các file đó trong một thư mục trống, rồi chạy:
+
+```powershell
+python HVU_QA_tool.py
+```
+
+Hoặc trên Windows:
+
+```text
+double-click HVU_QA_tool.bat
+```
+
+Launcher sẽ tự động:
+
+1. kiểm tra xem thư mục hiện tại có full project hay không
+2. nếu không có full project, tự tạo `HVU_QA_runtime/`
+3. tự tạo `.hvu_qa_tool_venv/` nếu máy chưa chạy trong virtualenv
+4. tự cài dependency runtime còn thiếu
+5. tải model từ Hugging Face
+6. chạy ứng dụng web trong runtime vừa tạo
+
+Nguồn model mặc định:
+
+- Dataset repo: `DANGDOCAO/GeneratingQuestions`
+- Revision: `main`
+- Thư mục model từ repo: `HVU_QA/t5-viet-qg-finetuned/`
+
+Launcher tự bỏ qua các checkpoint train để tránh tải dữ liệu không cần thiết cho người dùng cuối. Trong lúc đồng bộ model, launcher hiển thị:
+
+- tiến độ theo từng file, ví dụ `[3/14] Đang tải ...`
+- thanh progress tổng theo phần trăm
+
+Lưu ý:
+
+- lần đầu chạy cần có Internet
+- nếu đang dùng standalone tool, launcher **không cần** `main.py`, `backend/`, `frontend/` hay `requirements.txt` có sẵn bên cạnh nó
+- `--best-model-only` chỉ dùng được khi repo trên Hugging Face thật sự có thư mục `best-model`
+
+Ví dụ:
+
+```powershell
+python HVU_QA_tool.py --device cpu
+python HVU_QA_tool.py --host 127.0.0.1 --port 5000
+python HVU_QA_tool.py --force-download
+python HVU_QA_tool.py --skip-run
+python HVU_QA_tool.py --no-browser
+python HVU_QA_tool.py --prepare-runtime-only
+python HVU_QA_tool.py --force-standalone-runtime
+python HVU_QA_tool.py --runtime-dir MyRuntime
+python HVU_QA_tool.py --no-venv
+```
+
+Các tuỳ chọn chính:
+
+- `--repo-id`: đổi repo Hugging Face nếu cần
+- `--revision`: chọn branch, tag hoặc commit hash
+- `--device auto|cpu|cuda`: ép thiết bị chạy model
+- `--force-download`: tải lại model và ghi đè file local
+- `--skip-download`: bỏ qua bước tải model từ Hugging Face
+- `--skip-install`: không tự cài dependency còn thiếu
+- `--skip-run`: chỉ chuẩn bị model và môi trường, không mở app
+- `--prepare-runtime-only`: chỉ dựng runtime, không tải model, không chạy app
+- `--force-standalone-runtime`: ép launcher dùng runtime standalone kể cả khi đang đứng trong full project
+- `--force-runtime-refresh`: ghi đè lại các file runtime nhúng trong launcher
+- `--runtime-dir`: đổi thư mục runtime standalone
+- `--no-venv`: không tự tạo virtualenv riêng cho launcher
+
+## 6. Notebook hướng dẫn
+
+Mở file:
+
+```text
+HVU_QA_end_to_end_guide.ipynb
+```
+
+Notebook hiện đã tách rõ:
+
+- `Phần A - Full project`
+- `Phần B - Chạy nhanh bằng tool`
+
+Phần `Quick tool` trong notebook mô phỏng đúng trường hợp chỉ có `HVU_QA_tool.py` và `HVU_QA_tool.bat`.
+
+## 7. Biến môi trường hữu ích
+
+Bạn có thể cấu hình trước khi chạy:
+
+```powershell
+$env:HVU_HOST = "127.0.0.1"
+$env:HVU_PORT = "5000"
+$env:HVU_DEBUG = "0"
+$env:HVU_OPEN_BROWSER = "1"
+$env:HVU_MODEL_DIR = "t5-viet-qg-finetuned"
+$env:HVU_TASK_PREFIX = "sinh câu hỏi"
+$env:HVU_DEVICE = "auto"      # auto | cpu | cuda
+$env:HVU_CPU_THREADS = "8"
+$env:HVU_GPU_DTYPE = "auto"   # auto | float16 | bfloat16 | float32
+$env:HVU_MAX_SOURCE_LENGTH = "512"
+$env:HVU_MAX_NEW_TOKENS = "64"
+.\venv\Scripts\python main.py
+```
+
+Ý nghĩa nhanh:
+
+- `HVU_DEVICE=auto`: tự chọn `cuda` nếu có GPU, ngược lại dùng `cpu`
+- `HVU_OPEN_BROWSER=0`: không tự mở trình duyệt
+- `HVU_MODEL_DIR`: đổi thư mục model mặc định của backend
+- `HVU_TASK_PREFIX`: đổi tiền tố prompt đưa vào model
+- `HVU_CPU_THREADS`: giới hạn số luồng khi chạy CPU
+
+## 8. Cách dùng giao diện full project
+
+Sau khi mở web:
+
+1. Nhập hoặc dán đoạn văn bản vào ô nhập.
+2. Tăng `Số câu hỏi` từ `1` trở lên.
+3. Nếu cần, chọn model ở thanh bên.
+4. Nhấn `Sinh câu hỏi`.
+
+Giao diện full project hiện có thêm:
+
+- `Lịch sử`: lưu các lần sinh câu hỏi gần đây trong `localStorage`
+- `Ví dụ mẫu`: chèn nhanh văn bản luật mẫu để thử
+- `Trạng thái model`: hiển thị model đang dùng và thiết bị xử lý
+- `Tác giả`: thông tin nhóm thực hiện
+
+## 9. Nhập bằng giọng nói
+
+Mic trên giao diện full project dùng `Web Speech API` của trình duyệt, không ghi file âm thanh cục bộ.
+
+Lưu ý:
+
+- nên dùng Chrome hoặc Edge
+- chỉ hoạt động tốt trên `https://...` hoặc `http://localhost`
+- cần cấp quyền micro cho trình duyệt
+
+## 10. Model đang được hỗ trợ
+
+Backend full project tự dò model khả dụng trong thư mục project.
+
+Hiện logic đang hỗ trợ:
+
+- thư mục model gốc có `config.json`
+- model lồng bên trong `best-model/`
+- model lồng bên trong `final-model/`
+
+Ví dụ với project hiện tại, dropdown thường sẽ thấy:
+
+- `t5-viet-qg-finetuned`
+- `best-model`
+
+## 11. Chạy bằng dòng lệnh
+
+Bạn có thể sinh câu hỏi trực tiếp mà không cần mở web:
+
+```powershell
+.\venv\Scripts\python generate_question.py --text "Cơ sở giáo dục đại học có nhiệm vụ đào tạo, nghiên cứu khoa học và phục vụ cộng đồng." --num_questions 5 --output_format text
+```
+
+Đọc từ file:
+
+```powershell
+.\venv\Scripts\python generate_question.py --input_file input.txt --num_questions 5 --output_format json
+```
+
+Một số tham số thường dùng:
+
+- `--model_dir`
+- `--task_prefix`
+- `--num_questions`
+- `--device auto|cpu|cuda`
+- `--cpu_threads`
+- `--gpu_dtype auto|float16|bfloat16|float32`
+- `--max_source_length`
+- `--max_new_tokens`
+
+## 12. API backend
+
+### `GET /api/info`
+
+Trả về:
+
+- tiêu đề hệ thống
+- model đang chọn
+- danh sách model khả dụng
+- trạng thái thiết bị và việc model đã được load hay chưa
+
+### `POST /api/model`
+
+Dùng để đổi model đang hoạt động.
+
+Body mẫu:
+
+```json
+{
+  "model_id": "t5-viet-qg-finetuned/best-model"
+}
+```
+
+### `POST /api/generate`
+
+Dùng để sinh câu hỏi từ văn bản.
+
+Body mẫu:
+
+```json
+{
+  "model_id": "t5-viet-qg-finetuned/best-model",
+  "text": "Cơ sở giáo dục đại học có nhiệm vụ tổ chức đào tạo, nghiên cứu khoa học và phục vụ cộng đồng.",
+  "num_questions": 5
+}
+```
+
+Response thành công sẽ chứa:
+
+- `ok`
+- `text`
+- `num_questions`
+- `questions`
+- `formatted`
+- `elapsed_ms`
+- `model_name`
+- `selected_model_id`
+- `meta`
+
+## 13. Fine-tune model
+
+Nếu muốn huấn luyện lại model, dùng `fine_tune_qg.py`.
+
+Ví dụ:
+
+```powershell
+.\venv\Scripts\python fine_tune_qg.py --device cpu --output_dir t5-viet-qg-finetuned-cpu
+```
+
+Hoặc với GPU:
+
+```powershell
+.\venv\Scripts\python fine_tune_qg.py --device cuda --fp16 --gradient_checkpointing --output_dir t5-viet-qg-finetuned
+```
+
+Một số tham số nên biết thêm khi fine-tune:
+
+- `--model_name`
+- `--validation_file`
+- `--resume_from_latest` hoặc `--resume_checkpoint`
+- `--min_free_gpu_mb`
+- `--skip_gpu_preflight`
+- `--use_first_answer_only`
+- `--require_answer_in_context`
+
+## 14. Một số lỗi thường gặp
+
+Thiếu thư viện Python:
+
+- kích hoạt lại `venv`
+- chạy lại `python -m pip install -r requirements.txt`
+
+Không kích hoạt được `venv` trên PowerShell:
+
+- chạy `Set-ExecutionPolicy -Scope Process Bypass`
+- rồi chạy lại `.\venv\Scripts\Activate.ps1`
+
+Không tải được model từ Hugging Face:
+
+- kiểm tra lại Internet
+- kiểm tra repo `DANGDOCAO/GeneratingQuestions` còn public
+- thử chạy lại với `--force-download`
+
+Không thấy model trong dropdown:
+
+- kiểm tra thư mục `t5-viet-qg-finetuned/` có `config.json`
+- kiểm tra lại cấu trúc `best-model/` hoặc `final-model/`
+- restart server sau khi thêm model mới
+
+Mic không hoạt động:
+
+- dùng Chrome hoặc Edge
+- cấp quyền micro
+- chạy bằng `localhost` hoặc `https`
+
+Sinh câu hỏi chậm:
+
+- lần chạy đầu có thể chậm do model đang được load
+- nếu máy không có GPU, app sẽ chạy bằng CPU
+
+## 15. Ghi chú
+
+- Lịch sử full project được lưu ở trình duyệt, không dùng cơ sở dữ liệu.
+- Standalone tool dùng runtime tối thiểu để chạy nhanh cho người dùng cuối, không thay thế toàn bộ source code phát triển.

HVU_QA/requirements.txt

@@ -0,0 +1,11 @@
+# Runtime + training dependencies for HVU_QA.
+# Nếu dùng NVIDIA GPU, hãy cài bản torch đúng với CUDA của máy theo hướng dẫn chính thức của PyTorch.
+accelerate>=1.1.0,<2.0.0
+datasets>=2.19.0,<4.0.0
+Flask>=3.0.0,<4.0.0
+huggingface_hub>=0.23.0,<1.0.0
+numpy>=1.26.0,<3.0.0
+safetensors>=0.4.3,<1.0.0
+sentencepiece>=0.2.0,<1.0.0
+torch>=2.2.0,<3.0.0
+transformers>=4.41.0,<5.0.0