2026-07-21 14:25:38 +08:00
43 changed files with 3632 additions and 814 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -12,6 +12,8 @@ __pycache__/
 build/
 develop-eggs/
 dist/
+node_modules/
+*.tsbuildinfo
 downloads/
 eggs/
 .eggs/
@@ -37,6 +39,15 @@ MANIFEST
 pip-log.txt
 pip-delete-this-directory.txt

+# Runtime data and logs
+runtime/
+backend/runtime/
+logs/
+backend/logs/
+*.db
+*.sqlite
+*.sqlite3
+
 # Unit test / coverage reports
 htmlcov/
 .tox/
--- a/README.md
+++ b/README.md
@@ -1,12 +1,14 @@
 # YG_FT 模型微调平台

-YG_FT 是一个面向企业治理场景的完整模型微调平台，覆盖用户中心、多租户、项目隔离、数据集管理、模型管理、训练任务、评测、推理、审批流、审计留存、算力调度和训练引擎适配。当前前端已存在基础页面，后端与算力平台已按多人协作开发方式建立工程骨架。
+YG_FT 是一个面向企业治理场景的模型微调平台，覆盖用户中心、多租户、项目隔离、数据集管理、模型管理、训练任务、评测、推理、审批流、审计留存、算力调度和训练引擎适配。
+
+当前前端已有基础页面，后端与算力平台已按多人协作开发方式建立工程骨架，并开始实现第一版可演示闭环能力。第一版实现不是临时代码，工程模块、配置项、接口标签和数据库对象均按后续正式开发可延续的方式命名。

 ## 总体架构

 ```text
 YG_FT/
-  frontend/                 # 前端应用，承载训练平台控制台页面
+  frontend/                 # 前端控制台
  backend/                  # FastAPI 应用平台后端
    app/
      api/v1/               # 对前端暴露的 REST API
@@ -23,7 +25,7 @@ YG_FT/
    engines/llama_factory/  # LLaMA-Factory 适配器
    file_gateway/           # 本地文件上传、下载、导入、产物管理
  docs/                     # 需求、接口、数据库、开发计划和部署文档
-  docker/                   # Nginx 等容器化配置
+  docker/                   # 容器化配置
 ```

 ## 平台分层
@@ -32,20 +34,19 @@ YG_FT/
 | --- | --- | --- |
 | 前端控制台 | 用户操作入口、任务看板、项目/模型/数据集/训练/审批/审计页面 | `frontend/` |
 | 应用平台后端 | 用户中心、多租户、RBAC/ABAC、项目隔离、元数据、审批流、审计、API 编排 | `backend/` |
-| 算力平台 | GPU 发现、资源锁定、训练进程管理、日志采集、产物归档、任务状态回传 | `compute/` |
+| 算力平台 | GPU 发现、资源锁定、训练进程管理、日志采集、产物归档、任务状态同步 | `compute/` |
 | 训练引擎 | 当前固定接入 LLaMA-Factory，预留其他训练平台适配标准 | `compute/engines/` |
 | 数据层 | PostgreSQL、Redis、本地文件存储、日志归档 | `docs/postgres-schema.sql` |

-## 关键能力
+## 第一版能力

- 多租户：租户级数据隔离、租户配置、租户成员和角色。
- 权限控制：支持项目、模型、数据集级隔离，后续可扩展到字段级和操作级策略。
- 审批流：覆盖数据集发布、模型发布、训练资源申请、推理服务上线等企业流程。
- 审计留存：操作审计、安全审计、审批审计、任务审计，支持留存周期策略。
- 训练任务：训练参数管理、单机多 GPU 调度、任务状态同步、训练日志、产物管理。
- 引擎适配：默认 LLaMA-Factory，预留统一 Engine Adapter 接口接入其他微调框架。
- 文件存储：当前使用本地磁盘，按租户/项目/数据集/任务分区。
- 日志采集：后端 JSON Lines 日志，主日志和错误日志拆分，便于 ELK/日志平台采集。
+- 使用 FastAPI 提供统一 API 响应结构 `{ code, message, data }`。
+- 本地运行阶段使用 SQLite 初始化样例用户、模型、数据集、算力节点、GPU 和微调任务。
+- 支持登录、模型管理、数据集管理、微调任务创建/启动/停止/进度轮询。
+- 支持训练日志、loss 指标、checkpoint 和训练产物的模拟生成。
+- 支持多算力节点、GPU、任务队列、资源副本和资源同步状态接口。
+- 前端新增 `/compute` 算力节点页面，展示节点地址、权重、标签、启用状态、GPU、队列和资源副本。
+- `compute/engines/llama_factory/adapter.py` 提供 LLaMA-Factory 参数校验、命令生成和日志解析基础能力。

 ## 后端启动

@@ -54,15 +55,45 @@ cd backend
 python -m venv .venv
 .venv\Scripts\activate
 pip install -r requirements.txt
-uvicorn app.main:app --reload
+uvicorn app.main:app --reload --port 17861
 ```

-默认健康检查：
+默认 API 前缀为 `/api`，例如：

 ```text
-GET /api/v1/health
+GET /api/health
+POST /api/login
+GET /api/model-manage
+GET /api/dataset-manage
+GET /api/fine-tune
+GET /api/compute/nodes
 ```

+本地运行时默认数据库路径：
+
+```text
+LOCAL_DB_PATH=./runtime/platform.db
+```
+
+## 前端启动
+
+```bash
+cd frontend
+npm install
+npm run dev
+```
+
+前端开发服务默认运行在 `http://localhost:16801`，并通过 Vite proxy 将 `/api` 转发到 `http://localhost:17861`。
+
+## 算力服务启动
+
+```bash
+cd compute
+uvicorn api.main:app --reload --port 19100
+```
+
+第一版默认 `COMPUTE_MODE=simulator`。后续真实 GPU 接入时，在算力服务器上部署 Compute API、Agent、File Gateway 和 LLaMA-Factory，应用平台通过 `compute_nodes.api_base_url` 和 `compute_nodes.file_gateway_url` 主动轮询。
+
 ## 日志

 后端日志模块位于 `backend/app/core/logging.py`，说明文档见：
@@ -84,22 +115,11 @@ logs/error-YYYY-MM-DD.log
 - `docs/backend-api-design.md`：FastAPI 接口分组、参数定义、权限说明。
 - `docs/postgres-schema.sql`：PostgreSQL 数据库脚本，包含权限、用户中心、多租户、审批、审计等模型。
 - `docs/system-development-plan.md`：多人协作开发计划，按前端、后端、DB、部署拆分。
+- `docs/first-version-development-plan.md`：第一版可演示闭环开发计划，覆盖前端、后端、DB、Compute Simulator、GPU 和 LLaMA-Factory 适配。
 - `docs/backend-logging.md`：后端日志模块使用说明。
 - `docs/deployment-plan.md`：后期部署方案，覆盖单机算力服务器部署与应用/算力分离部署。
- `docs/demo-development-plan.md`：可演示 Demo 开发计划，覆盖前端、后端、DB、Compute Simulator、GPU 和 LLaMA-Factory 适配。
 - `docker/README.md`：Docker 部署入口，包含应用服务器和算力服务器两套 Compose 使用方式。

-## 部署模式
-
-平台支持两种主要部署模式：
-
-1. 所有服务部署在算力服务器：适合 PoC、内网试点、小团队单机多 GPU 使用。
-2. 应用服务和算力/训练服务独立部署：适合企业生产环境，应用平台部署在业务服务区，算力平台和 LLaMA-Factory 部署在 GPU 服务器。
-
-生产环境建议采用第二种模式。算力平台与训练框架应部署在 GPU 算力服务器上，应用平台不直接控制 GPU 进程，而是通过内部 Compute API 调度训练任务。
-
-详细方案见 `docs/deployment-plan.md`。
-
 ## Docker 部署入口

 应用服务器：
@@ -107,8 +127,7 @@ logs/error-YYYY-MM-DD.log
 ```bash
 cd docker/app
 cp .env.example .env
-docker compose --profile build run --rm frontend-builder
-docker compose up -d --build
+docker compose up -d
 ```

 算力服务器：
@@ -116,19 +135,10 @@ docker compose up -d --build
 ```bash
 cd docker/compute
 cp .env.example .env
-docker compose up -d --build
+docker compose up -d
 ```

-两套 Compose 均采用代码外挂方式运行，镜像只包含运行时环境和第三方依赖。详细说明见 `docker/README.md`。
-
-项目根目录不再保留 `Dockerfile` 和 `docker-compose.yml`，部署时统一进入 `docker/app` 或 `docker/compute` 目录执行。
-
-当前 Docker 约定：
-
- PostgreSQL/Redis 开发阶段使用项目自带 Compose 服务，生产阶段保留切换企业统一基础设施的配置入口。
- 算力服务器上的 LLaMA-Factory 使用宿主机目录挂载，默认 `/opt/LLaMA-Factory`。
- 应用平台通过定时轮询 Compute API 同步训练状态，默认不要求算力服务器回调应用服务器。
- 多算力节点阶段，每台单机多 GPU 服务器都独立部署 `docker/compute`、Compute API、Agent、File Gateway 和 LLaMA-Factory；节点之间默认不互访，由应用平台通过 `compute_nodes`、`resource_replicas` 和 `resource_sync_jobs` 统一调度与同步。
+两套 Compose 均采用代码外挂方式运行，镜像只包含运行时环境和第三方依赖。项目根目录不再保留 `Dockerfile` 和 `docker-compose.yml`，部署时统一进入 `docker/app` 或 `docker/compute` 目录执行。

 ## 后续开发原则

--- a/backend/app/api/v1/endpoints/health.py
+++ b/backend/app/api/v1/endpoints/health.py
@@ -1,12 +1,14 @@
-from fastapi import APIRouter
+from fastapi import APIRouter

 from app.core.logging import get_logger
+from app.db.platform_store import get_platform_store

 router = APIRouter()
 logger = get_logger(__name__)


@router.get("/health")
-async def health_check() -> dict[str, str]:
+async def health_check() -> dict[str, object]:
    logger.info("health check requested")
-    return {"status": "ok"}
+    return {"code": 0, "message": "ok", "data": get_platform_store().health_metrics()}
+
--- a/backend/app/api/v1/endpoints/platform.py
+++ b/backend/app/api/v1/endpoints/platform.py
@@ -0,0 +1,450 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Body, File, HTTPException, Query, UploadFile
+from fastapi.responses import PlainTextResponse
+
+from app.db.platform_store import get_platform_store
+
+router = APIRouter()
+
+
+def ok(data: Any = None, message: str = "ok") -> dict[str, Any]:
+    return {"code": 0, "message": message, "data": data}
+
+
+def fail(status_code: int, message: str) -> HTTPException:
+    return HTTPException(status_code=status_code, detail={"code": status_code, "message": message, "data": None})
+
+
+@router.post("/login")
+async def login(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    user = get_platform_store().login(payload.get("username", ""), payload.get("password", ""))
+    if not user:
+        raise fail(401, "invalid username or password")
+    return ok({"token": f"platform-token-{user['id']}", "user": user})
+
+
+@router.get("/me")
+async def me() -> dict[str, Any]:
+    return ok(get_platform_store().users()[0])
+
+
+@router.get("/dashboard/overview")
+async def dashboard_overview() -> dict[str, Any]:
+    store = get_platform_store()
+    tasks = store.tasks()
+    return ok(
+        {
+            "models": len(store.models()),
+            "datasets": len(store.datasets()),
+            "fine_tune_tasks": len(tasks),
+            "running_tasks": len([t for t in tasks if t["status"] in {"syncing", "queued", "running"}]),
+            "compute_nodes": len(store.compute_nodes()),
+            "gpus": len(store.gpus()),
+        }
+    )
+
+
+@router.get("/system-info")
+async def system_info() -> dict[str, Any]:
+    return ok(get_platform_store().system_info())
+
+
+@router.get("/users")
+async def users() -> dict[str, Any]:
+    return ok(get_platform_store().users())
+
+
+@router.post("/users")
+async def create_user(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return ok(get_platform_store().create_user(payload))
+
+
+@router.put("/users/{user_id}")
+async def update_user(user_id: str, payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().update_user(user_id, payload))
+    except KeyError:
+        raise fail(404, "user not found")
+
+
+@router.delete("/users/{user_id}")
+async def delete_user(user_id: str, current_username: str | None = Query(default=None)) -> dict[str, Any]:
+    try:
+        get_platform_store().delete_user(user_id)
+        return ok({"deleted": user_id, "current_username": current_username})
+    except KeyError:
+        raise fail(404, "user not found")
+    except ValueError as exc:
+        raise fail(400, str(exc))
+
+
+@router.get("/model-manage/local-models")
+async def local_models() -> dict[str, Any]:
+    models = [{"path": item.get("path") or "", "name": item["name"]} for item in get_platform_store().models()]
+    return ok({"models": models})
+
+
+@router.get("/model-manage/trained-models")
+async def trained_models() -> dict[str, Any]:
+    return ok({"models": get_platform_store().trained_models()})
+
+
+@router.delete("/model-manage/trained-models/{model_id}")
+async def delete_trained_model(model_id: str, type: str = Query(default="merged")) -> dict[str, Any]:
+    return ok({"deleted": model_id, "type": type})
+
+
+@router.get("/model-manage/name/{name}")
+async def model_by_name(name: str) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().model_by_name(name))
+    except KeyError:
+        raise fail(404, "model not found")
+
+
+@router.get("/model-manage")
+async def model_list() -> dict[str, Any]:
+    return ok(get_platform_store().models())
+
+
+@router.post("/model-manage")
+async def create_model(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return ok(get_platform_store().create_model(payload))
+
+
+@router.get("/model-manage/{model_id}")
+async def model_detail(model_id: str) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().model(model_id))
+    except KeyError:
+        raise fail(404, "model not found")
+
+
+@router.put("/model-manage/{model_id}")
+async def update_model(model_id: str, payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().update_model(model_id, payload))
+    except KeyError:
+        raise fail(404, "model not found")
+
+
+@router.put("/model-manage/{model_id}/purpose")
+async def update_model_purpose(model_id: str, payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().update_model(model_id, {"purpose": payload.get("purpose", "training")}))
+    except KeyError:
+        raise fail(404, "model not found")
+
+
+@router.delete("/model-manage/{model_id}")
+async def delete_model(model_id: str) -> dict[str, Any]:
+    get_platform_store().delete_model(model_id)
+    return ok({"deleted": model_id})
+
+
+@router.post("/model-manage/merge")
+async def merge_model(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return ok({"job_id": "merge-sample-job", "status": "queued", **payload})
+
+
+@router.get("/dataset-manage/preview/{file_id}")
+async def dataset_preview(file_id: str) -> dict[str, Any]:
+    try:
+        row = get_platform_store().dataset_file(file_id)
+        return ok({"content": row["content"]})
+    except KeyError:
+        raise fail(404, "dataset file not found")
+
+
+@router.get("/dataset-manage/versions/{file_id}")
+async def dataset_versions(file_id: str) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().file_versions(file_id))
+    except KeyError:
+        raise fail(404, "dataset file not found")
+
+
+@router.get("/dataset-manage/versions/{file_id}/{version_id}")
+async def dataset_version_content(file_id: str, version_id: str) -> dict[str, Any]:
+    try:
+        row = get_platform_store().dataset_file(file_id)
+        versions = get_platform_store().file_versions(file_id)["versions"]
+        version = next((item for item in versions if item["id"] == version_id), None)
+        if not version:
+            raise KeyError(version_id)
+        return ok({"version": version, "content": row["content"]})
+    except KeyError:
+        raise fail(404, "dataset version not found")
+
+
+@router.post("/dataset-manage/versions/{file_id}")
+async def create_dataset_version(file_id: str, payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().create_file_version(file_id, payload))
+    except KeyError:
+        raise fail(404, "dataset file not found")
+
+
+@router.put("/dataset-manage/versions/{file_id}/active")
+async def activate_dataset_version(file_id: str, payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().activate_file_version(file_id, payload["version_id"]))
+    except KeyError:
+        raise fail(404, "dataset version not found")
+
+
+@router.delete("/dataset-manage/versions/{file_id}/{version_id}")
+async def delete_dataset_version(file_id: str, version_id: str) -> dict[str, Any]:
+    return ok(get_platform_store().file_versions(file_id))
+
+
+@router.post("/dataset-manage/upload/{dataset_id}")
+async def upload_dataset_files(dataset_id: str, files: list[UploadFile] = File(default=[])) -> dict[str, Any]:
+    created: list[dict[str, Any]] = []
+    store = get_platform_store()
+    try:
+        store.dataset(dataset_id)
+    except KeyError:
+        raise fail(404, "dataset not found")
+    with store.connect() as conn:
+        for file in files:
+            raw = await file.read()
+            content = raw.decode("utf-8", errors="replace")
+            created.append(store.add_dataset_file(conn, dataset_id, file.filename or "upload.jsonl", content))
+    return ok({"files": created})
+
+
+@router.get("/dataset-manage/download/{dataset_id}")
+async def download_dataset(dataset_id: str) -> PlainTextResponse:
+    dataset = get_platform_store().dataset(dataset_id)
+    content = "\n".join([f"{file['name']}" for file in dataset.get("files", [])])
+    return PlainTextResponse(content, media_type="text/plain")
+
+
+@router.get("/dataset-manage/download/{dataset_id}/{file_id}")
+async def download_dataset_file(dataset_id: str, file_id: str, version_id: str | None = Query(default=None)) -> PlainTextResponse:
+    row = get_platform_store().dataset_file(file_id)
+    return PlainTextResponse(row["content"], media_type="text/plain")
+
+
+@router.get("/dataset-manage")
+async def dataset_list() -> dict[str, Any]:
+    return ok(get_platform_store().datasets())
+
+
+@router.post("/dataset-manage")
+async def create_dataset(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    dataset = get_platform_store().create_dataset(payload)
+    return ok({"id": dataset["id"]})
+
+
+@router.get("/dataset-manage/{dataset_id}")
+async def dataset_detail(dataset_id: str) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().dataset(dataset_id))
+    except KeyError:
+        raise fail(404, "dataset not found")
+
+
+@router.put("/dataset-manage/{dataset_id}")
+async def update_dataset(dataset_id: str, payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().update_dataset(dataset_id, payload))
+    except KeyError:
+        raise fail(404, "dataset not found")
+
+
+@router.delete("/dataset-manage/{dataset_id}")
+async def delete_dataset(dataset_id: str) -> dict[str, Any]:
+    get_platform_store().delete_dataset(dataset_id)
+    return ok({"deleted": dataset_id})
+
+
+@router.get("/fine-tune/check-name")
+async def check_fine_tune_name(name: str = Query(...)) -> dict[str, Any]:
+    exists = any(task["name"] == name for task in get_platform_store().tasks())
+    return ok({"exists": exists})
+
+
+@router.get("/fine-tune/progress/{task_id}")
+async def fine_tune_progress(task_id: str) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().progress(task_id))
+    except KeyError:
+        raise fail(404, "fine tune task not found")
+
+
+@router.post("/fine-tune/tensorboard/start")
+async def tensorboard_start() -> dict[str, Any]:
+    return ok({"status": "running", "url": "http://localhost:6006"})
+
+
+@router.get("/fine-tune")
+async def fine_tune_list() -> dict[str, Any]:
+    return ok(get_platform_store().tasks())
+
+
+@router.post("/fine-tune")
+async def create_fine_tune(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    task = get_platform_store().create_task(payload)
+    return ok({"id": task["id"]})
+
+
+@router.post("/fine-tune/start")
+async def start_fine_tune(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().start_task(payload))
+    except KeyError:
+        raise fail(404, "fine tune task not found")
+    except RuntimeError as exc:
+        raise fail(409, str(exc))
+
+
+@router.get("/fine-tune/{task_id}")
+async def fine_tune_detail(task_id: str) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().task(task_id))
+    except KeyError:
+        raise fail(404, "fine tune task not found")
+
+
+@router.put("/fine-tune/{task_id}")
+async def update_fine_tune(task_id: str, payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().update_task(task_id, payload))
+    except KeyError:
+        raise fail(404, "fine tune task not found")
+
+
+@router.post("/fine-tune/stop/{task_id}")
+async def stop_fine_tune(task_id: str) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().stop_task(task_id))
+    except KeyError:
+        raise fail(404, "fine tune task not found")
+
+
+@router.post("/fine-tune/{task_id}/stop")
+async def stop_fine_tune_alt(task_id: str) -> dict[str, Any]:
+    return await stop_fine_tune(task_id)
+
+
+@router.delete("/fine-tune/{task_id}")
+async def delete_fine_tune(task_id: str) -> dict[str, Any]:
+    get_platform_store().delete_task(task_id)
+    return ok({"deleted": task_id})
+
+
+@router.get("/fine-tune/{task_id}/overview")
+async def fine_tune_overview(task_id: str) -> dict[str, Any]:
+    task = get_platform_store().task(task_id)
+    return ok({"task": task, "progress": get_platform_store().progress(task_id)})
+
+
+@router.get("/fine-tune/{task_id}/checkpoints")
+async def fine_tune_checkpoints(task_id: str) -> dict[str, Any]:
+    task = get_platform_store().task(task_id)
+    checkpoints = []
+    for step in [50, 100, 150]:
+        if task.get("progress", 0) >= min(100, step // 2):
+            checkpoints.append({"step": step, "path": f"/data/yg-ft/outputs/{task['name']}/checkpoint-{step}"})
+    return ok(checkpoints)
+
+
+@router.get("/compute/nodes")
+async def compute_nodes() -> dict[str, Any]:
+    return ok(get_platform_store().compute_nodes())
+
+
+@router.post("/compute/nodes")
+async def create_compute_node(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return ok({"id": "node_sample_new", **payload, "status": "created"})
+
+
+@router.put("/compute/nodes/{node_id}")
+async def update_compute_node(node_id: str, payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().update_compute_node(node_id, payload))
+    except KeyError:
+        raise fail(404, "compute node not found")
+
+
+@router.post("/compute/nodes/{node_id}/test-connection")
+async def test_compute_node(node_id: str) -> dict[str, Any]:
+    return ok({"node_id": node_id, "success": True, "latency_ms": 12})
+
+
+@router.post("/compute/nodes/{node_id}/enable")
+async def enable_compute_node(node_id: str) -> dict[str, Any]:
+    return ok(get_platform_store().update_compute_node(node_id, {"enabled": True, "scheduler_status": "online"}))
+
+
+@router.post("/compute/nodes/{node_id}/disable")
+async def disable_compute_node(node_id: str) -> dict[str, Any]:
+    return ok(get_platform_store().update_compute_node(node_id, {"enabled": False, "scheduler_status": "offline"}))
+
+
+@router.post("/compute/nodes/{node_id}/drain")
+async def drain_compute_node(node_id: str) -> dict[str, Any]:
+    return ok(get_platform_store().update_compute_node(node_id, {"scheduler_status": "draining"}))
+
+
+@router.get("/compute/nodes/{node_id}/replicas")
+async def compute_node_replicas(node_id: str) -> dict[str, Any]:
+    return ok(get_platform_store().replicas(node_id))
+
+
+@router.get("/compute/gpus")
+async def compute_gpus() -> dict[str, Any]:
+    return ok(get_platform_store().gpus())
+
+
+@router.get("/compute/queue")
+async def compute_queue() -> dict[str, Any]:
+    return ok(get_platform_store().queue())
+
+
+@router.post("/internal/compute-sync/resources")
+async def create_compute_sync(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    sync_id = get_platform_store().create_sync_job(payload.get("target_node_id", "node_01"), payload)
+    return ok(get_platform_store().sync_job(sync_id))
+
+
+@router.get("/internal/compute-sync/resources/{sync_id}")
+async def compute_sync_detail(sync_id: str) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().sync_job(sync_id))
+    except KeyError:
+        raise fail(404, "sync job not found")
+
+
+@router.get("/training-log-files")
+async def training_log_files() -> dict[str, Any]:
+    return ok(get_platform_store().training_log_files())
+
+
+@router.get("/training-log-content")
+async def training_log_content(file: str = Query(...)) -> dict[str, Any]:
+    try:
+        return ok(get_platform_store().training_log_content(file))
+    except KeyError:
+        raise fail(404, "training log not found")
+
+
+@router.get("/log-files")
+async def log_files(date: str | None = Query(default=None)) -> dict[str, Any]:
+    return ok(get_platform_store().log_files(date))
+
+
+@router.get("/log-content")
+async def log_content(file: str = Query(...)) -> dict[str, Any]:
+    return ok(get_platform_store().log_content(file))
+
+
+@router.post("/web-log")
+async def web_log(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+    return ok({"received": True, **payload})
+
--- a/backend/app/api/v1/router.py
+++ b/backend/app/api/v1/router.py
@@ -1,6 +1,9 @@
-from fastapi import APIRouter
+from fastapi import APIRouter

+from app.api.v1.endpoints.platform import router as platform_router
 from app.api.v1.endpoints.health import router as health_router

 api_router = APIRouter()
 api_router.include_router(health_router, tags=["health"])
+api_router.include_router(platform_router, tags=["platform"])
+
--- a/backend/app/core/config.py
+++ b/backend/app/core/config.py
@@ -1,4 +1,4 @@
-from dataclasses import dataclass
+from dataclasses import dataclass
 from functools import lru_cache
 import os

@@ -15,6 +15,11 @@ class Settings:
    app_name: str = os.getenv("APP_NAME", "YG Fine-Tune Platform API")
    app_env: str = os.getenv("APP_ENV", "local")
    api_prefix: str = os.getenv("API_PREFIX", "/api")
+    app_mode: str = os.getenv("APP_MODE", "local")
+    local_db_path: str = os.getenv("LOCAL_DB_PATH", "./runtime/platform.db")
+    compute_mode: str = os.getenv("COMPUTE_MODE", "simulator")
+    compute_status_sync_mode: str = os.getenv("COMPUTE_STATUS_SYNC_MODE", "polling")
+    compute_poll_interval_seconds: int = _int_env("COMPUTE_POLL_INTERVAL_SECONDS", 3)
    log_level: str = os.getenv("LOG_LEVEL", "INFO")
    log_dir: str = os.getenv("LOG_DIR", "./logs")
    log_file_prefix: str = os.getenv("LOG_FILE_PREFIX", "backend")
@@ -26,3 +31,4 @@ class Settings:
@lru_cache
 def get_settings() -> Settings:
    return Settings()
+
--- a/backend/app/db/platform_store.py
+++ b/backend/app/db/platform_store.py
--- a/backend/app/db/session.py
+++ b/backend/app/db/session.py
@@ -1,4 +1,41 @@
-"""Database session factory placeholder.
+from __future__ import annotations
+
+import os
+from collections.abc import Generator
+from contextlib import contextmanager
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session, sessionmaker
+
+
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///./runtime/platform.db")
+
+engine = create_engine(
+    DATABASE_URL,
+    pool_pre_ping=True,
+    future=True,
+    connect_args={"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {},
+)
+SessionLocal = sessionmaker(bind=engine, autoflush=False, autocommit=False, expire_on_commit=False, future=True)
+
+
+def get_db() -> Generator[Session, None, None]:
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+@contextmanager
+def session_scope() -> Generator[Session, None, None]:
+    db = SessionLocal()
+    try:
+        yield db
+        db.commit()
+    except Exception:
+        db.rollback()
+        raise
+    finally:
+        db.close()

-Implement SQLAlchemy/SQLModel session management here when database development starts.
-"""
--- a/compute/api/main.py
+++ b/compute/api/main.py
@@ -1,13 +1,105 @@
 from __future__ import annotations

 import os
+import math
+import time
 from pathlib import Path
+from typing import Any

-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
+
+from compute.engines.llama_factory.adapter import build_command, parse_log_line


 def create_app() -> FastAPI:
    app = FastAPI(title="YG Fine-Tune Compute API")
+    jobs: dict[str, dict[str, Any]] = {}
+
+    def now() -> float:
+        return time.time()
+
+    def host_id() -> str:
+        return os.getenv("COMPUTE_HOST_ID", "gpu-node-01")
+
+    def job_status(job: dict[str, Any]) -> dict[str, Any]:
+        elapsed = max(0, int(now() - job["created_at"]))
+        if job["status"] not in {"stopped", "failed", "completed"}:
+            if elapsed < 5:
+                job["status"] = "queued"
+                job["progress"] = 12 + elapsed * 3
+            elif elapsed < 60:
+                job["status"] = "running"
+                job["progress"] = min(96, 25 + int((elapsed - 5) / 55 * 70))
+            else:
+                job["status"] = "completed"
+                job["progress"] = 100
+        job["logs"] = generate_logs(job)
+        return job
+
+    def generate_logs(job: dict[str, Any]) -> str:
+        progress = int(job.get("progress", 0) or 0)
+        points = max(1, min(80, progress))
+        lines = [
+            f"[INFO] compute_host_id={host_id()} job_id={job['id']} engine=llama_factory mode=simulator",
+            f"[INFO] command={' '.join(job['command'])}",
+        ]
+        for step in range(1, points + 1):
+            if step % 4 != 0 and step != points:
+                continue
+            loss = max(0.11, 2.5 * math.exp(-step / 40))
+            grad_norm = 0.4 + (step % 5) * 0.04
+            lr = 0.0002 * max(0.05, 1 - step / 100)
+            epoch = round(step / points * 3, 4)
+            lines.append(
+                "{"
+                f"'loss': {loss:.4f}, 'grad_norm': {grad_norm:.4f}, "
+                f"'learning_rate': {lr:.8f}, 'epoch': {epoch:.4f}"
+                "}"
+            )
+        if job.get("status") == "completed":
+            lines.extend(
+                [
+                    "***** train metrics *****",
+                    "epoch = 3",
+                    "train_loss = 0.1181",
+                    "train_runtime = 1m 0s",
+                    "***** train metrics end *****",
+                ]
+            )
+        return "\n".join(lines)
+
+    def gpu_resources() -> list[dict[str, Any]]:
+        active_jobs = [job_status(job) for job in jobs.values() if job["status"] in {"queued", "running"}]
+        gpus: list[dict[str, Any]] = []
+        for idx in range(4):
+            task = next((job for job in active_jobs if idx in job.get("gpus", [])), None)
+            busy = task is not None and task["status"] == "running"
+            reserved = task is not None and task["status"] == "queued"
+            gpus.append(
+                {
+                    "id": idx,
+                    "uuid": f"GPU-{host_id().upper()}-{idx}",
+                    "name": os.getenv("COMPUTE_GPU_NAME", "NVIDIA A800-SXM4-80GB"),
+                    "status": "busy" if busy else "reserved" if reserved else "idle",
+                    "gpu_percent": 88 if busy else 25 if reserved else 4,
+                    "memory_used_gb": 58 if busy else 12 if reserved else 2,
+                    "memory_total_gb": 80,
+                    "temperature": 61 if busy else 45 if reserved else 36,
+                    "power_w": 215 if busy else 80 if reserved else 25,
+                    "power_limit_w": 300,
+                    "processes": [
+                        {
+                            "pid": task["pid"],
+                            "name": "llamafactory-cli",
+                            "task_name": task["name"],
+                            "memory_used_gb": 58 if busy else 12,
+                        }
+                    ]
+                    if task
+                    else [],
+                }
+            )
+        return gpus

    @app.get("/health")
    async def health_check() -> dict[str, str]:
@@ -19,7 +111,7 @@ def create_app() -> FastAPI:
    @app.get("/api/v1/compute/health")
    async def compute_health_check() -> dict[str, str | bool]:
        data_root = Path(os.getenv("YG_FT_DATA_ROOT", "/data/yg-ft"))
-        llama_factory_home = Path(os.getenv("LLAMA_FACTORY_HOME", "/opt/LLaMA-Factory"))
+        llama_factory_home = Path(os.getenv("LLAMA_FACTORY_HOME", "/app/LLaMA-Factory"))
        return {
            "status": "ok",
            "compute_host_id": os.getenv("COMPUTE_HOST_ID", "unknown"),
@@ -31,8 +123,73 @@ def create_app() -> FastAPI:
        }

    @app.get("/api/v1/compute/jobs")
-    async def list_jobs() -> dict[str, list[dict[str, str]]]:
-        return {"items": []}
+    async def list_jobs_alias() -> dict[str, list[dict[str, Any]]]:
+        return {"items": [job_status(job) for job in jobs.values()]}
+
+    @app.get("/compute/resources/gpus")
+    async def list_gpus() -> dict[str, Any]:
+        return {"items": gpu_resources(), "compute_host_id": host_id()}
+
+    @app.post("/compute/jobs")
+    async def create_job(payload: dict[str, Any]) -> dict[str, Any]:
+        try:
+            command = build_command(payload, os.getenv("LLAMA_FACTORY_HOME", "/app/LLaMA-Factory"))
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc))
+        job_id = str(payload.get("id") or f"job_{int(now() * 1000)}")
+        job = {
+            "id": job_id,
+            "name": payload.get("name", job_id),
+            "status": "queued",
+            "progress": 10,
+            "pid": int(52000 + now() % 10000),
+            "gpus": payload.get("gpus") or [0],
+            "created_at": now(),
+            "command": command.command,
+            "work_dir": command.work_dir,
+            "artifacts": [],
+            "logs": "",
+        }
+        jobs[job_id] = job
+        return job_status(job)
+
+    @app.get("/compute/jobs")
+    async def list_jobs() -> dict[str, Any]:
+        return {"items": [job_status(job) for job in jobs.values()]}
+
+    @app.get("/compute/jobs/{job_id}")
+    async def get_job(job_id: str) -> dict[str, Any]:
+        job = jobs.get(job_id)
+        if not job:
+            raise HTTPException(status_code=404, detail="job not found")
+        return job_status(job)
+
+    @app.post("/compute/jobs/{job_id}/stop")
+    async def stop_job(job_id: str) -> dict[str, Any]:
+        job = jobs.get(job_id)
+        if not job:
+            raise HTTPException(status_code=404, detail="job not found")
+        job["status"] = "stopped"
+        job["progress"] = min(job.get("progress", 0), 99)
+        return job
+
+    @app.get("/compute/jobs/{job_id}/logs")
+    async def job_logs(job_id: str) -> dict[str, Any]:
+        job = jobs.get(job_id)
+        if not job:
+            raise HTTPException(status_code=404, detail="job not found")
+        job = job_status(job)
+        metrics = [parse_log_line(line) for line in job["logs"].splitlines()]
+        return {"job_id": job_id, "content": job["logs"], "metrics": [m for m in metrics if m]}
+
+    @app.post("/compute/files/upload")
+    async def upload_file(payload: dict[str, Any]) -> dict[str, Any]:
+        file_id = str(payload.get("id") or f"file_{int(now() * 1000)}")
+        return {"id": file_id, "status": "available", "local_path": f"/data/yg-ft/uploads/{file_id}"}
+
+    @app.get("/compute/files/{file_id}/download")
+    async def download_file(file_id: str) -> dict[str, Any]:
+        return {"id": file_id, "status": "ready", "download_url": f"/compute/files/{file_id}/download"}

    return app

--- a/compute/engines/llama_factory/adapter.py
+++ b/compute/engines/llama_factory/adapter.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class LlamaFactoryCommand:
+    command: list[str]
+    work_dir: str
+    env: dict[str, str]
+
+
+def validate_config(config: dict[str, Any]) -> list[str]:
+    errors: list[str] = []
+    if not config.get("base_model") and not config.get("model_name_or_path"):
+        errors.append("base_model or model_name_or_path is required")
+    if not config.get("dataset") and not config.get("dataset_dir"):
+        errors.append("dataset or dataset_dir is required")
+    learning_rate = float(config.get("learning_rate", 0.0002))
+    if learning_rate <= 0:
+        errors.append("learning_rate must be greater than zero")
+    epochs = int(config.get("n_epochs", config.get("num_train_epochs", 1)))
+    if epochs <= 0:
+        errors.append("n_epochs must be greater than zero")
+    return errors
+
+
+def build_command(config: dict[str, Any], llama_factory_home: str = "/app/LLaMA-Factory") -> LlamaFactoryCommand:
+    errors = validate_config(config)
+    if errors:
+        raise ValueError("; ".join(errors))
+
+    model_path = config.get("base_model") or config.get("model_name_or_path")
+    dataset = config.get("dataset") or config.get("dataset_dir")
+    output_dir = config.get("output_dir") or f"/data/yg-ft/outputs/{config.get('name', 'sample-job')}"
+    command = [
+        "llamafactory-cli",
+        "train",
+        "--stage",
+        str(config.get("stage", "sft")).lower(),
+        "--do_train",
+        "true",
+        "--model_name_or_path",
+        str(model_path),
+        "--dataset",
+        str(dataset),
+        "--template",
+        str(config.get("template", "qwen")),
+        "--finetuning_type",
+        str(config.get("train_method", config.get("finetuning_type", "lora"))),
+        "--output_dir",
+        str(output_dir),
+        "--per_device_train_batch_size",
+        str(config.get("batch_size", 2)),
+        "--learning_rate",
+        str(config.get("learning_rate", 0.0002)),
+        "--num_train_epochs",
+        str(config.get("n_epochs", 3)),
+        "--save_steps",
+        str(config.get("save_steps", 50)),
+    ]
+    quantization_bit = int(config.get("quantization_bit", 0) or 0)
+    if quantization_bit in {4, 8}:
+        command.extend(["--quantization_bit", str(quantization_bit)])
+    return LlamaFactoryCommand(command=command, work_dir=str(Path(llama_factory_home)), env={})
+
+
+def parse_log_line(line: str) -> dict[str, float] | None:
+    if "loss" not in line or "learning_rate" not in line:
+        return None
+    result: dict[str, float] = {}
+    for key in ["loss", "grad_norm", "learning_rate", "epoch"]:
+        match = re.search(rf"['\"]?{key}['\"]?\s*:\s*([-+]?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)", line)
+        if match:
+            result[key] = float(match.group(1))
+    return result or None
+
--- a/docker/README.md
+++ b/docker/README.md
@@ -1,60 +1,106 @@
 # Docker 部署说明

-本文档对应 `docs/deployment-plan.md`，按应用服务器和算力服务器拆分 Dockerfile 与 Docker Compose 文件。所有业务代码均通过 volume 外挂到容器内，镜像只包含运行时环境和第三方依赖。
+本目录按应用服务器和算力服务器拆分 Dockerfile 与 Docker Compose 文件。Compose 文件不包含 `build:`，不会在 `docker compose up` 时自动构建业务镜像。所有业务镜像需要先通过手动 `docker build` 构建，再由 Compose 启动。

-## 目录
+## 基础镜像

-```text
-docker/
-  app/
-    Dockerfile.backend
-    Dockerfile.frontend
-    docker-compose.yml
-    .env.example
-  compute/
-    Dockerfile.compute
-    docker-compose.yml
-    .env.example
+| 镜像 | 用途 |
+| --- | --- |
+| `python:3.12-slim` | 应用后端基础镜像，后端运行环境要求 Python 3.12 及以上 |
+| `nginx:1.27-alpine` | 前端静态资源与 `/api` 反向代理运行镜像 |
+| `hiyouga/llamafactory:latest` | 算力服务基础镜像，基于 LLaMA-Factory 官方镜像扩展 Compute API |
+| `postgres:16-alpine` | 开发阶段内置 PostgreSQL |
+| `redis:7-alpine` | 开发阶段内置 Redis |
+
+一键拉取基础镜像：
+
+```bash
+docker pull python:3.12-slim && \
+docker pull nginx:1.27-alpine && \
+docker pull hiyouga/llamafactory:latest && \
+docker pull postgres:16-alpine && \
+docker pull redis:7-alpine
 ```

-项目根目录不再保留 `Dockerfile` 和 `docker-compose.yml`，避免与应用服务器、算力服务器拆分部署入口混淆。
+Windows PowerShell：
+
+```powershell
+$images = @(
+  "python:3.12-slim",
+  "nginx:1.27-alpine",
+  "hiyouga/llamafactory:latest",
+  "postgres:16-alpine",
+  "redis:7-alpine"
+)
+$images | ForEach-Object { docker pull $_ }
+```
+
+如果部署环境不能访问外网，需要提前在可联网环境执行上述拉取命令，再用 `docker save` / `docker load` 导出导入。
+
+## 业务镜像
+
+| 镜像 | Dockerfile | 构建命令 |
+| --- | --- | --- |
+| `yg-ft-backend-api:latest` | `docker/app/Dockerfile.backend` | `docker build -f docker/app/Dockerfile.backend -t yg-ft-backend-api:latest .` |
+| `yg-ft-frontend-runtime:latest` | `docker/app/Dockerfile.frontend` | `docker build -f docker/app/Dockerfile.frontend -t yg-ft-frontend-runtime:latest .` |
+| `yg-ft-compute-api:latest` | `docker/compute/Dockerfile.compute` | `docker build -f docker/compute/Dockerfile.compute -t yg-ft-compute-api:latest .` |
+
+## 对外端口
+
+所有宿主机对外端口统一使用 5 位端口。容器内部端口保持镜像默认端口，便于容器内服务和健康检查稳定。
+
+| 服务 | 宿主机对外端口 | 容器内部端口 | 说明 |
+| --- | --- | --- | --- |
+| 前端 Nginx | `16801` | `80` | 前端页面入口 |
+| 后端 API | `17861` | `8000` | FastAPI 服务 |
+| PostgreSQL | `15432` | `5432` | 开发阶段内置数据库 |
+| Redis | `16379` | `6379` | 开发阶段内置缓存 |
+| Compute API | `19100` | `9100` | 算力服务器 API |
+| File Gateway | `19101` | 后续服务端口 | 当前预留，后续拆出文件网关服务时使用 |
+
+对应配置文件：
+
+- `docker/app/.env.example`
+  - `FRONTEND_PORT=16801`
+  - `BACKEND_API_PORT=17861`
+  - `POSTGRES_PORT=15432`
+  - `REDIS_PORT=16379`
+- `docker/compute/.env.example`
+  - `COMPUTE_API_PORT=19100`
+  - `FILE_GATEWAY_PORT=19101`

 ## 应用服务器部署

 应用服务器包含前端 Nginx、Backend API、PostgreSQL、Redis。

-开发阶段默认由项目自带 PostgreSQL/Redis：
-
-```env
-USE_BUILTIN_POSTGRES=true
-USE_BUILTIN_REDIS=true
-DATABASE_URL=postgresql+asyncpg://yg_ft:change_me@postgres:5432/yg_ft
-REDIS_URL=redis://redis:6379/0
-```
-
-后续切换企业统一基础设施时，保留应用配置方式，只需要：
-
- 修改 `DATABASE_URL` 指向企业 PostgreSQL。
- 修改 `REDIS_URL` 指向企业 Redis。
- 从 Compose 中移除或禁用 `postgres`、`redis` 服务。
- 保留 `docs/postgres-schema.sql` 作为数据库初始化或迁移参考。
-
-首次部署前先构建前端产物：
+首次部署：

 ```bash
+cd <repo-root>
+
+# 1. 使用当前 Windows/宿主机 npm 构建前端静态产物
+cd frontend
+npm ci
+npm run build
+cd ..
+
+# 2. 手动构建业务镜像
+docker build -f docker/app/Dockerfile.backend -t yg-ft-backend-api:latest .
+docker build -f docker/app/Dockerfile.frontend -t yg-ft-frontend-runtime:latest .
+
+# 3. 启动应用服务
 cd docker/app
 cp .env.example .env
-docker compose --profile build run --rm frontend-builder
-docker compose up -d --build
+docker compose up -d
 ```

 默认访问地址：

 ```text
-http://<app-server-ip>:6801
+http://<app-server-ip>:16801
 ```

-应用侧代码外挂：
+应用侧代码和数据外挂：

 ```text
 ../../backend -> /app
@@ -63,157 +109,128 @@ http://<app-server-ip>:6801
 ../../runtime/app/data -> /data/yg-ft
 ```

-如果算力服务独立部署，需要在 `docker/app/.env` 中修改：
+如果使用企业统一 PostgreSQL/Redis，修改 `docker/app/.env`：

 ```env
-COMPUTE_API_BASE_URL=http://<compute-server-ip>:9100
-FILE_GATEWAY_BASE_URL=http://<compute-server-ip>:9101
-COMPUTE_SERVICE_TOKEN=change_me
-COMPUTE_STATUS_SYNC_MODE=polling
-COMPUTE_POLL_INTERVAL_SECONDS=10
-COMPUTE_POLL_BATCH_SIZE=100
+DATABASE_URL=postgresql+asyncpg://<user>:<password>@<postgres-host>:15432/<db>
+REDIS_URL=redis://<redis-host>:16379/0
+USE_BUILTIN_POSTGRES=false
+USE_BUILTIN_REDIS=false
 ```

-状态同步采用应用侧定时轮询 Compute API 为主，避免算力服务器需要访问应用服务器，从而减少双向网络策略开通。
-
-## 应用服务与算力服务交互
-
-应用服务与算力服务之间只要求应用服务器主动访问算力服务器：
-
-```text
-Frontend
-  -> Backend API
-    -> Compute API
-      -> Compute Agent / LLaMA-Factory
-      -> 本地数据盘 / 模型目录 / 训练产物
-    <- Backend Worker 定时轮询 Compute API
-```
-
-默认交互流程：
-
- `Backend API` 读取 `COMPUTE_API_BASE_URL`，向 `Compute API` 提交训练、评测、合并、导出等任务。
- `Compute API` 在算力服务器上调度 `Compute Agent`。
- `Compute Agent` 通过宿主机挂载目录调用 LLaMA-Factory，并读写 `/data/yg-ft` 下的数据集、模型和训练产物。
- `Backend Worker` 按 `COMPUTE_POLL_INTERVAL_SECONDS` 定时轮询 Compute API，同步任务状态、训练指标、日志摘要和产物索引。
- 前端只访问应用服务；文件下载和产物访问由应用服务完成权限校验后，再通过 `FILE_GATEWAY_BASE_URL` 获取受控资源。
-
-当前支持通过环境变量动态配置算力服务地址：
-
-```env
-COMPUTE_API_BASE_URL=http://<compute-server-ip>:9100
-FILE_GATEWAY_BASE_URL=http://<compute-server-ip>:9101
-COMPUTE_SERVICE_TOKEN=change_me
-COMPUTE_STATUS_SYNC_MODE=polling
-COMPUTE_POLL_INTERVAL_SECONDS=10
-COMPUTE_POLL_BATCH_SIZE=100
-```
-
-后续多算力节点阶段建议升级为数据库配置：在 `compute_nodes` 表中维护节点地址、服务 token、启用状态、权重、标签和健康状态，并通过“算力节点管理”页面动态启停节点，避免每次调整地址都重启应用服务。
+生产环境如完全使用外部基础设施，可以删除或注释 Compose 中的 `postgres`、`redis` 服务及 `backend-api.depends_on` 中对应依赖。

 ## 算力服务器部署

-算力服务器包含 Compute API、后续 Compute Agent、后续 File Gateway、GPU runtime、本地训练数据目录和宿主机挂载的 LLaMA-Factory。
+算力服务器包含 Compute API、后续 Compute Agent、File Gateway、GPU runtime、本地训练数据目录和 LLaMA-Factory。`Dockerfile.compute` 基于 LLaMA-Factory 官方镜像：
+
+```dockerfile
+FROM hiyouga/llamafactory:latest
+```

 部署前需要安装：

- NVIDIA Driver。
- NVIDIA Container Toolkit。
- Docker Engine 和 Docker Compose Plugin。
- LLaMA-Factory 宿主机目录，默认 `/opt/LLaMA-Factory`。
- 本地训练数据盘，默认 `/data/yg-ft`。
+- NVIDIA Driver
+- NVIDIA Container Toolkit
+- Docker Engine 和 Docker Compose Plugin
+- 本地训练数据目录，默认 `/data/yg-ft`

-算力服务器上的 LLaMA-Factory 使用宿主机挂载方式，不在当前 Compose 中重新构建 LLaMA-Factory 镜像：
-
-```env
-LLAMA_FACTORY_HOME=/opt/LLaMA-Factory
-LLAMA_FACTORY_HOST_PATH=/opt/LLaMA-Factory
-```
-
-启动：
+首次部署：

 ```bash
+cd <repo-root>
+
+# 手动构建算力业务镜像
+docker build -f docker/compute/Dockerfile.compute -t yg-ft-compute-api:latest .
+
+# 启动算力服务
 cd docker/compute
 cp .env.example .env
-docker compose up -d --build
+docker compose up -d
 ```

 健康检查：

 ```text
-GET http://<compute-server-ip>:9100/health
-GET http://<compute-server-ip>:9100/api/v1/compute/health
+GET http://<compute-server-ip>:19100/health
+GET http://<compute-server-ip>:19100/api/v1/compute/health
 ```

 算力侧代码和数据外挂：

 ```text
 ../../compute -> /app/compute
-${LLAMA_FACTORY_HOST_PATH} -> /opt/LLaMA-Factory
 ${YG_FT_DATA_ROOT_HOST} -> /data/yg-ft
 ../../runtime/compute/logs -> /opt/yg-ft/logs/compute
 ../../runtime/compute/training-logs -> /opt/yg-ft/logs/training
 ```

-算力侧只需要允许应用服务器访问 Compute API/File Gateway，不要求访问应用服务器：
+## 应用与算力分离部署
+
+应用服务器只需要主动访问算力服务器，不要求算力服务器回调应用服务器。
+
+在 `docker/app/.env` 中配置：

 ```env
-ENABLE_APP_CALLBACK=false
+COMPUTE_API_BASE_URL=http://<compute-server-ip>:19100
+FILE_GATEWAY_BASE_URL=http://<compute-server-ip>:19101
 COMPUTE_SERVICE_TOKEN=change_me
+COMPUTE_STATUS_SYNC_MODE=polling
+COMPUTE_POLL_INTERVAL_SECONDS=10
+COMPUTE_POLL_BATCH_SIZE=100
+```
+
+交互链路：
+
+```text
+Frontend
+  -> Backend API
+    -> Compute API
+      -> Compute Agent / LLaMA-Factory
+      -> 本地数据目录 / 模型目录 / 训练产物
+    <- Backend Worker 定时轮询 Compute API
 ```

 ## 多算力节点部署

-多算力节点仍按“单机多 GPU 节点”部署。每台 GPU 服务器都需要独立部署一套算力服务和宿主机挂载的 LLaMA-Factory：
+多算力节点仍按“单机多 GPU 节点”部署。每台 GPU 服务器都独立部署一套 `docker/compute`：

 ```text
-gpu-node-01: docker/compute + /opt/LLaMA-Factory + /data/yg-ft
-gpu-node-02: docker/compute + /opt/LLaMA-Factory + /data/yg-ft
-gpu-node-03: docker/compute + /opt/LLaMA-Factory + /data/yg-ft
+gpu-node-01: docker/compute + /data/yg-ft + 19100/19101
+gpu-node-02: docker/compute + /data/yg-ft + 19100/19101
+gpu-node-03: docker/compute + /data/yg-ft + 19100/19101
 ```

-节点之间默认不互相访问。应用服务器主动访问每个节点的 Compute API/File Gateway，并通过 `compute_nodes` 表或算力节点管理页面维护：
+节点之间默认不互访。应用平台主动访问每个节点的 Compute API/File Gateway，并通过 `compute_nodes`、`resource_replicas`、`resource_sync_jobs` 统一调度和同步。

- `api_base_url`
- `file_gateway_url`
- `enabled`
- `scheduler_status`
- `scheduler_weight`
- `tags`
- `data_root`
- `model_root`
- `log_root`
+## 常用命令

-长期使用每台算力服务器本地磁盘时，需要由应用平台维护资源副本关系。调度前先检查目标节点是否已有数据集和模型副本；如果没有，应用平台通过目标节点 File Gateway 创建资源同步任务，同步完成后再提交训练任务。
+重新构建应用镜像：

-## 单机所有服务部署在算力服务器
+```bash
+docker build -f docker/app/Dockerfile.backend -t yg-ft-backend-api:latest .
+docker build -f docker/app/Dockerfile.frontend -t yg-ft-frontend-runtime:latest .
+```

-在同一台 GPU 服务器上分别启动两套 Compose：
+重新构建算力镜像：
+
+```bash
+docker build -f docker/compute/Dockerfile.compute -t yg-ft-compute-api:latest .
+```
+
+启动服务：

 ```bash
 cd docker/app
-docker compose --profile build run --rm frontend-builder
-docker compose up -d --build
+docker compose up -d

 cd ../compute
-docker compose up -d --build
+docker compose up -d
 ```

-应用侧 `.env` 中可使用：
+查看服务：

-```env
-COMPUTE_API_BASE_URL=http://host.docker.internal:9100
-FILE_GATEWAY_BASE_URL=http://host.docker.internal:9101
-COMPUTE_STATUS_SYNC_MODE=polling
+```bash
+docker compose ps
+docker compose logs -f
 ```
-
-Linux 环境如需容器访问宿主机地址，可在应用侧 Compose 中按需增加 `extra_hosts: ["host.docker.internal:host-gateway"]`，或直接配置算力服务器内网 IP。
-
-## 生产注意事项
-
- 当前 Compose 是工程部署骨架，后续 Backend Worker、Compute Agent、File Gateway 有可运行入口后，再拆分为独立服务。
- PostgreSQL 和 Redis 开发阶段采用项目自带部署，生产阶段保留切换企业统一基础设施的配置入口。
- 生产环境请把 `change_me` 替换为强密码或密钥管理系统注入。
- 当前镜像默认优先保证宿主机外挂日志和数据目录可写；生产环境如需非 root 运行，需要统一宿主机目录 UID/GID 后在 Compose 中增加 `user` 配置。
- Compute API 不应暴露公网，建议通过防火墙限制只允许应用服务器访问。
- GPU 容器需要 NVIDIA Container Toolkit，否则 `gpus: all` 无法生效。
- 前端 Nginx 默认挂载 `frontend/dist`，发布前需要先运行 `frontend-builder` 或由 CI 构建产物。
--- a/docker/app/.env.example
+++ b/docker/app/.env.example
@@ -2,6 +2,15 @@ APP_ENV=prod
 APP_NAME=YG Fine-Tune Platform API
 API_PREFIX=/api

+FRONTEND_IMAGE=yg-ft-frontend-runtime:latest
+BACKEND_API_IMAGE=yg-ft-backend-api:latest
+
+# Five-digit host ports exposed outside the application server.
+FRONTEND_PORT=16801
+BACKEND_API_PORT=17861
+POSTGRES_PORT=15432
+REDIS_PORT=16379
+
 POSTGRES_DB=yg_ft
 POSTGRES_USER=yg_ft
 POSTGRES_PASSWORD=change_me
@@ -23,7 +32,7 @@ LOG_RETENTION_DAYS=10

 API_PROXY_PASS=http://backend-api:8000

-# Split deployment: set these to the compute server address, for example http://10.10.20.31:9100.
+# Split deployment: set these to the compute server address, for example http://10.10.20.31:19100.
 COMPUTE_API_BASE_URL=http://compute-api:9100
 COMPUTE_SERVICE_TOKEN=change_me
 FILE_GATEWAY_BASE_URL=http://compute-api:9101
--- a/docker/app/Dockerfile.backend
+++ b/docker/app/Dockerfile.backend
@@ -1,6 +1,4 @@
-# syntax=docker/dockerfile:1
-
-FROM python:3.11-slim
+FROM python:3.12-slim

 ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
--- a/docker/app/Dockerfile.frontend
+++ b/docker/app/Dockerfile.frontend
@@ -1,4 +1,3 @@
-# syntax=docker/dockerfile:1

 FROM nginx:1.27-alpine

--- a/docker/app/docker-compose.yml
+++ b/docker/app/docker-compose.yml
@@ -1,25 +1,12 @@
 services:
-  frontend-builder:
-    image: node:20-alpine
-    profiles:
-      - build
-    working_dir: /workspace
-    volumes:
-      - ../../frontend:/workspace
-      - frontend_node_modules:/workspace/node_modules
-    command: sh -c "npm ci && npm run build"
-
  frontend:
-    build:
-      context: ../..
-      dockerfile: docker/app/Dockerfile.frontend
-    image: yg-ft-frontend-runtime:latest
+    image: ${FRONTEND_IMAGE:-yg-ft-frontend-runtime:latest}
    container_name: yg-ft-frontend
    depends_on:
      backend-api:
        condition: service_started
    ports:
-      - "6801:80"
+      - "${FRONTEND_PORT:-16801}:80"
    environment:
      API_PROXY_PASS: ${API_PROXY_PASS:-http://backend-api:8000}
    volumes:
@@ -30,10 +17,7 @@ services:
    restart: unless-stopped

  backend-api:
-    build:
-      context: ../..
-      dockerfile: docker/app/Dockerfile.backend
-    image: yg-ft-backend-api:latest
+    image: ${BACKEND_API_IMAGE:-yg-ft-backend-api:latest}
    container_name: yg-ft-backend-api
    depends_on:
      postgres:
@@ -42,6 +26,8 @@ services:
        condition: service_healthy
    expose:
      - "8000"
+    ports:
+      - "${BACKEND_API_PORT:-17861}:8000"
    environment:
      APP_ENV: ${APP_ENV:-prod}
      APP_NAME: ${APP_NAME:-YG Fine-Tune Platform API}
@@ -88,6 +74,8 @@ services:
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ../../docs/postgres-schema.sql:/docker-entrypoint-initdb.d/001-schema.sql:ro
+    ports:
+      - "${POSTGRES_PORT:-15432}:5432"
    networks:
      - yg-ft-app
    healthcheck:
@@ -103,6 +91,8 @@ services:
    command: ["redis-server", "--appendonly", "yes"]
    volumes:
      - redis_data:/data
+    ports:
+      - "${REDIS_PORT:-16379}:6379"
    networks:
      - yg-ft-app
    healthcheck:
@@ -117,6 +107,5 @@ networks:
    name: yg-ft-app

 volumes:
-  frontend_node_modules:
  postgres_data:
  redis_data:
--- a/docker/compute/.env.example
+++ b/docker/compute/.env.example
@@ -1,14 +1,16 @@
 COMPUTE_ENV=prod
 COMPUTE_HOST_ID=gpu-node-01
-COMPUTE_API_PORT=9100
-FILE_GATEWAY_PORT=9101
+# Five-digit host ports exposed outside the compute server.
+COMPUTE_API_PORT=19100
+FILE_GATEWAY_PORT=19101
+COMPUTE_API_IMAGE=yg-ft-compute-api:latest

 # The application server actively polls Compute API; compute server does not need reverse access.
 COMPUTE_SERVICE_TOKEN=change_me
 ENABLE_APP_CALLBACK=false

-LLAMA_FACTORY_HOME=/opt/LLaMA-Factory
-LLAMA_FACTORY_HOST_PATH=/opt/LLaMA-Factory
+# LLaMA-Factory is provided by the official hiyouga/llamafactory base image.
+LLAMA_FACTORY_HOME=/app/LLaMA-Factory

 YG_FT_DATA_ROOT=/data/yg-ft
 YG_FT_DATA_ROOT_HOST=/data/yg-ft
--- a/docker/compute/Dockerfile.compute
+++ b/docker/compute/Dockerfile.compute
@@ -1,6 +1,5 @@
-# syntax=docker/dockerfile:1

-FROM nvidia/cuda:12.4.1-cudnn-runtime-ubuntu22.04
+FROM hiyouga/llamafactory:latest

 ENV DEBIAN_FRONTEND=noninteractive \
    PYTHONDONTWRITEBYTECODE=1 \
@@ -10,25 +9,16 @@ ENV DEBIAN_FRONTEND=noninteractive \
 WORKDIR /app

 RUN apt-get update \
-    && apt-get install -y --no-install-recommends \
-      python3 \
-      python3-pip \
-      python3-venv \
-      git \
-      curl \
-      ca-certificates \
-      tini \
-    && ln -sf /usr/bin/python3 /usr/local/bin/python \
-    && ln -sf /usr/bin/pip3 /usr/local/bin/pip \
+    && apt-get install -y --no-install-recommends tini \
    && rm -rf /var/lib/apt/lists/*

 COPY compute/requirements.txt /tmp/requirements.txt
-RUN pip install --upgrade pip \
-    && pip install -r /tmp/requirements.txt \
+RUN pip install --upgrade pip -i https://pypi.tuna.tsinghua.edu.cn/simple \
+    && pip install -r /tmp/requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple \
    && rm -f /tmp/requirements.txt

-RUN mkdir -p /opt/yg-ft/logs/compute /opt/yg-ft/logs/training /data/yg-ft /opt/LLaMA-Factory \
-    && chmod -R 0775 /opt/yg-ft /data/yg-ft /opt/LLaMA-Factory
+RUN mkdir -p /opt/yg-ft/logs/compute /opt/yg-ft/logs/training /data/yg-ft /app/LLaMA-Factory \
+    && chmod -R 0775 /opt/yg-ft /data/yg-ft /app/LLaMA-Factory

 ENTRYPOINT ["/usr/bin/tini", "--"]

--- a/docker/compute/docker-compose.yml
+++ b/docker/compute/docker-compose.yml
@@ -1,19 +1,16 @@
 services:
  compute-api:
-    build:
-      context: ../..
-      dockerfile: docker/compute/Dockerfile.compute
-    image: yg-ft-compute-api:latest
+    image: ${COMPUTE_API_IMAGE:-yg-ft-compute-api:latest}
    container_name: yg-ft-compute-api
    gpus: all
    ports:
-      - "${COMPUTE_API_PORT:-9100}:9100"
+      - "${COMPUTE_API_PORT:-19100}:9100"
    environment:
      COMPUTE_ENV: ${COMPUTE_ENV:-prod}
      COMPUTE_HOST_ID: ${COMPUTE_HOST_ID:-gpu-node-01}
      COMPUTE_SERVICE_TOKEN: ${COMPUTE_SERVICE_TOKEN:-change_me}
      ENABLE_APP_CALLBACK: ${ENABLE_APP_CALLBACK:-false}
-      LLAMA_FACTORY_HOME: ${LLAMA_FACTORY_HOME:-/opt/LLaMA-Factory}
+      LLAMA_FACTORY_HOME: ${LLAMA_FACTORY_HOME:-/app/LLaMA-Factory}
      YG_FT_DATA_ROOT: ${YG_FT_DATA_ROOT:-/data/yg-ft}
      LOG_DIR: ${LOG_DIR:-/opt/yg-ft/logs/compute}
      CUDA_VISIBLE_DEVICES: ${CUDA_VISIBLE_DEVICES:-all}
@@ -22,7 +19,6 @@ services:
      PYTHONPATH: /app
    volumes:
      - ../../compute:/app/compute:ro
-      - ${LLAMA_FACTORY_HOST_PATH:-/opt/LLaMA-Factory}:${LLAMA_FACTORY_HOME:-/opt/LLaMA-Factory}
      - ${YG_FT_DATA_ROOT_HOST:-/data/yg-ft}:${YG_FT_DATA_ROOT:-/data/yg-ft}
      - ../../runtime/compute/logs:/opt/yg-ft/logs/compute
      - ../../runtime/compute/training-logs:/opt/yg-ft/logs/training
--- a/docs/backend-api-design.md
+++ b/docs/backend-api-design.md
@@ -868,8 +868,8 @@ page=1&page_size=20&keyword=xxx&sort=-created_at
  "id": "uuid",
  "code": "gpu-node-01",
  "name": "A800 Node 01",
-  "api_base_url": "http://10.10.20.31:9100",
-  "file_gateway_url": "http://10.10.20.31:9101",
+  "api_base_url": "http://10.10.20.31:19100",
+  "file_gateway_url": "http://10.10.20.31:19101",
  "enabled": true,
  "scheduler_status": "online",
  "scheduler_weight": 100,
--- a/docs/demo-development-plan.md
+++ b/docs/demo-development-plan.md
@@ -1,545 +0,0 @@
-# Demo 开发计划
-
-本文档用于指导后续开发一个可演示的模型微调平台 Demo。Demo 不是纯前端展示，而是包含前端、FastAPI 后端、PostgreSQL、算力服务、GPU 状态、LLaMA-Factory 适配器和训练任务主链路的工程化演示版本。
-
-## 1. Demo 目标
-
-Demo 目标是在没有完整生产环境的条件下，跑通一条可信的模型微调平台主链路：
-
-```text
-登录
- -> 数据集管理
- -> 模型管理
- -> 创建微调任务
- -> 自动/手动选择算力节点
- -> 检查模型/数据集资源副本
- -> 缺失资源则同步到目标节点
- -> 启动训练任务
- -> 查看 GPU 占用、训练日志、loss 曲线、checkpoint
- -> 训练完成后登记训练产物
- -> 可进入评测/推理演示
-```
-
-Demo 支持两种算力运行模式：
-
-| 模式 | 说明 | 适用场景 |
-| --- | --- | --- |
-| `simulator` | 模拟 GPU、训练进程、训练日志、loss、checkpoint | 无 GPU、无 LLaMA-Factory 环境 |
-| `real` | 调用 `nvidia-smi` 和 LLaMA-Factory 启动真实训练 | 有 GPU 和训练环境 |
-
-第一版优先实现 `simulator`，同时保留 `real` 模式接口和适配器边界。
-
-## 2. 技术范围
-
-### 2.1 前端
-
-基于现有 `frontend/` 页面开发，逐步从 Mock 切换到 Demo 后端接口。
-
-优先联调页面：
-
- `/login`
- `/dashboard`
- `/dataset`
- `/dataset/create`
- `/dataset/:id/preview`
- `/model-manage`
- `/model-manage/create`
- `/fine-tune`
- `/fine-tune/create`
- `/training-log/:id`
- `/compute`
- `/compute/gpus`
- `/compute/queue`
- `/compute/nodes`
-
-### 2.2 后端
-
-基于 `backend/` FastAPI 工程实现 Demo API：
-
- 用户登录和当前用户。
- 数据集、模型、训练任务。
- 算力节点、GPU、队列。
- 资源副本和同步任务。
- 训练日志、指标、checkpoint。
- 审计日志最小记录。
-
-### 2.3 数据库
-
-开发阶段使用项目自带 PostgreSQL。Demo 使用 `docs/postgres-schema.sql` 的核心子集，并通过 seed 数据初始化演示数据。
-
-### 2.4 算力服务
-
-基于 `compute/` 开发内部 Compute API：
-
- `simulator` 模式：模拟 GPU 与训练生命周期。
- `real` 模式：预留真实 GPU 和 LLaMA-Factory 调用。
-
-每个算力节点仍按“单机多 GPU 节点”设计。多节点 Demo 可以通过多条 `compute_nodes` 记录模拟，也可以在多台机器上分别部署 `docker/compute`。
-
-## 3. 模块开发清单
-
-### 3.1 后端基础模块
-
-目录建议：
-
-```text
-backend/app/modules/
-  auth/
-  dataset/
-  model/
-  fine_tune/
-  compute_gateway/
-  audit/
-```
-
-接口：
-
-| 方法 | 路径 | 说明 |
-| --- | --- | --- |
-| POST | `/api/login` | 登录，Demo 可使用固定账号 |
-| GET | `/api/me` | 当前用户 |
-| GET | `/api/dashboard/overview` | Demo 看板 |
-| GET | `/api/health` | 应用健康检查 |
-
-验收：
-
- 能通过前端登录。
- 能返回菜单权限。
- 前端退出后可重新登录。
-
-### 3.2 数据集 Demo
-
-接口：
-
-| 方法 | 路径 | 说明 |
-| --- | --- | --- |
-| GET | `/api/dataset-manage` | 数据集列表 |
-| POST | `/api/dataset-manage` | 创建数据集 |
-| GET | `/api/dataset-manage/{id}` | 数据集详情 |
-| POST | `/api/dataset-manage/upload/{dataset_id}` | 上传或模拟上传文件 |
-| GET | `/api/dataset-manage/preview/{file_id}` | 文件预览 |
-| GET | `/api/dataset-manage/versions/{file_id}` | 文件版本 |
-
-Demo 行为：
-
- 创建数据集后写入 PostgreSQL。
- 文件内容可以存本地 demo 目录或数据库小样本字段。
- 预览支持 JSONL 和文本。
- 数据集创建后生成一条 `storage_objects` 记录。
-
-### 3.3 模型 Demo
-
-接口：
-
-| 方法 | 路径 | 说明 |
-| --- | --- | --- |
-| GET | `/api/model-manage` | 模型列表 |
-| POST | `/api/model-manage` | 新增模型 |
-| GET | `/api/model-manage/{id}` | 模型详情 |
-| GET | `/api/model-manage/local-models` | 本地模型路径列表 |
-| GET | `/api/model-manage/trained-models` | 训练产物列表 |
-| POST | `/api/model-manage/merge` | 模拟权重合并任务 |
-
-Demo 行为：
-
- 新增本地模型时登记路径，不要求真实权重存在。
- 训练完成后自动生成 `trained_models` 记录。
- 权重合并可创建一个 `compute_jobs` 模拟任务。
-
-### 3.4 算力节点与 GPU Demo
-
-接口：
-
-| 方法 | 路径 | 说明 |
-| --- | --- | --- |
-| GET | `/api/compute/nodes` | 算力节点列表 |
-| POST | `/api/compute/nodes` | 新增节点 |
-| PUT | `/api/compute/nodes/{id}` | 编辑节点 |
-| POST | `/api/compute/nodes/{id}/test-connection` | 测试连接 |
-| POST | `/api/compute/nodes/{id}/enable` | 启用 |
-| POST | `/api/compute/nodes/{id}/disable` | 禁用 |
-| POST | `/api/compute/nodes/{id}/drain` | 维护模式 |
-| GET | `/api/compute/gpus` | GPU 状态 |
-| GET | `/api/compute/queue` | 队列 |
-
-Demo 行为：
-
- 默认 seed 两个算力节点：
-  - `gpu-node-01`，4 张模拟 GPU。
-  - `gpu-node-02`，4 张模拟 GPU。
- 支持节点标签：`A800`、`4090`、`80GB`、`llama_factory`。
- 支持节点状态：`online`、`offline`、`draining`、`maintenance`。
- GPU 状态随训练任务变化：`idle -> reserved -> running -> idle`。
-
-### 3.5 资源副本与同步 Demo
-
-接口：
-
-| 方法 | 路径 | 说明 |
-| --- | --- | --- |
-| GET | `/api/compute/nodes/{id}/replicas` | 节点资源副本 |
-| POST | `/api/internal/compute-sync/resources` | 创建资源同步任务 |
-| GET | `/api/internal/compute-sync/resources/{id}` | 同步任务详情 |
-
-Demo 行为：
-
- 训练任务启动前检查目标节点是否已有模型和数据集副本。
- 如果缺失，创建 `resource_sync_jobs`。
- 同步任务状态模拟：`pending -> running -> completed`。
- 同步完成后写入 `resource_replicas`。
- Demo 不需要真实复制大文件，可以创建本地占位文件或只写元数据。
-
-### 3.6 微调任务 Demo
-
-接口：
-
-| 方法 | 路径 | 说明 |
-| --- | --- | --- |
-| GET | `/api/fine-tune` | 训练任务列表 |
-| POST | `/api/fine-tune` | 创建训练任务 |
-| POST | `/api/fine-tune/start` | 启动训练任务 |
-| GET | `/api/fine-tune/{id}` | 任务详情 |
-| GET | `/api/fine-tune/{id}/overview` | 训练概览 |
-| GET | `/api/fine-tune/{id}/events` | 训练事件 |
-| POST | `/api/fine-tune/{id}/stop` | 停止任务 |
-| POST | `/api/fine-tune/{id}/retry` | 重试任务 |
-| GET | `/api/fine-tune/{id}/checkpoints` | checkpoint 列表 |
-
-创建任务参数需要支持：
-
-```json
-{
-  "name": "demo-sft-task",
-  "project_id": "uuid",
-  "base_model_id": "uuid",
-  "train_dataset_id": "uuid",
-  "engine": "llama_factory",
-  "scheduler": {
-    "mode": "auto",
-    "requested_node_id": null,
-    "required_tags": ["llama_factory"],
-    "min_gpu_memory_mb": 24000
-  },
-  "training_args": {
-    "stage": "sft",
-    "finetuning_type": "lora",
-    "epochs": 3,
-    "learning_rate": 0.0002
-  }
-}
-```
-
-Demo 行为：
-
- 自动调度：选择 `enabled + online` 节点，优先资源副本命中，按空闲 GPU、队列长度、权重排序。
- 手动调度：使用用户指定的 `requested_node_id`。
- 任务状态模拟：`pending -> syncing -> queued -> running -> completed`。
- 训练期间每 2-5 秒追加日志和指标。
- 完成后生成 checkpoint 和 trained model。
-
-### 3.7 Compute API Demo
-
-算力服务内部接口：
-
-| 方法 | 路径 | 说明 |
-| --- | --- | --- |
-| GET | `/health` | 节点健康 |
-| GET | `/api/v1/compute/health` | 节点详细健康 |
-| GET | `/compute/resources/gpus` | GPU 状态 |
-| POST | `/compute/jobs` | 创建任务 |
-| GET | `/compute/jobs/{id}` | 查询任务 |
-| POST | `/compute/jobs/{id}/stop` | 停止任务 |
-| GET | `/compute/jobs/{id}/logs` | 拉取日志 |
-| POST | `/compute/files/upload` | 文件网关上传 |
-| GET | `/compute/files/{id}/download` | 文件网关下载 |
-
-`simulator` 模式行为：
-
- 在内存或 SQLite/PostgreSQL 中维护任务状态。
- 使用后台线程/async task 模拟训练进度。
- 生成结构化日志、loss 曲线和 checkpoint。
-
-`real` 模式预留：
-
- `nvidia-smi` 采集 GPU。
- `subprocess.Popen` 启动 LLaMA-Factory。
- 解析真实训练日志。
- 扫描真实 checkpoint 和 adapter。
-
-### 3.8 LLaMA-Factory Adapter Demo
-
-目录建议：
-
-```text
-compute/engines/llama_factory/
-  adapter.py
-  schemas.py
-  command_builder.py
-  log_parser.py
-  simulator.py
-```
-
-能力：
-
- `validate_config(config)`：校验训练参数。
- `prepare_workspace(job)`：准备工作目录。
- `build_command(job)`：生成 LLaMA-Factory 命令。
- `start(job)`：启动真实或模拟训练。
- `stop(job_id)`：停止任务。
- `status(job_id)`：查询状态。
- `parse_log(line)`：解析 loss、epoch、step、learning rate。
- `collect_artifacts(job_id)`：收集 checkpoint、adapter、merged model。
-
-Demo 阶段必须完成：
-
- `dry_run` 命令生成。
- `simulator` 训练。
- 日志解析器单元测试。
-
-真实训练阶段再完成：
-
- `real` 进程启动。
- 真实停止。
- 真实产物扫描。
-
-## 4. 数据库 Demo 子集
-
-第一版 Demo 最小使用表：
-
- `users`
- `tenants`
- `projects`
- `models`
- `trained_models`
- `datasets`
- `dataset_files`
- `storage_objects`
- `fine_tune_tasks`
- `fine_tune_metrics`
- `fine_tune_checkpoints`
- `compute_nodes`
- `compute_node_engines`
- `gpu_devices`
- `compute_jobs`
- `gpu_allocations`
- `resource_replicas`
- `resource_sync_jobs`
- `audit_logs`
-
-Seed 数据：
-
- 管理员用户：`admin / admin123`。
- 租户：`demo-tenant`。
- 项目：`demo-project`。
- 模型：
-  - `Qwen2.5-7B-Instruct`
-  - `Llama-3.1-8B-Instruct`
- 数据集：
-  - `finance-sft-demo`
-  - `customer-service-demo`
- 算力节点：
-  - `gpu-node-01`
-  - `gpu-node-02`
- GPU：每个节点 4 张模拟 GPU。
- 训练任务：至少 3 条，分别处于 `pending`、`running`、`completed`。
-
-## 5. 目录和配置建议
-
-### 5.1 应用后端配置
-
-```env
-APP_ENV=demo
-DATABASE_URL=postgresql+asyncpg://yg_ft:change_me@postgres:5432/yg_ft
-REDIS_URL=redis://redis:6379/0
-COMPUTE_STATUS_SYNC_MODE=polling
-COMPUTE_POLL_INTERVAL_SECONDS=3
-DEMO_MODE=true
-```
-
-### 5.2 算力服务配置
-
-```env
-COMPUTE_MODE=simulator
-COMPUTE_HOST_ID=gpu-node-01
-LLAMA_FACTORY_HOME=/opt/LLaMA-Factory
-YG_FT_DATA_ROOT=/data/yg-ft
-ENABLE_APP_CALLBACK=false
-```
-
-### 5.3 本地文件目录
-
-```text
-runtime/
-  app/
-    data/
-    logs/backend/
-  compute/
-    logs/
-    training-logs/
-    data/
-      tenants/
-```
-
-## 6. 开发阶段计划
-
-### 阶段 1：后端和 DB 最小闭环
-
-目标：
-
- FastAPI 能启动。
- PostgreSQL 能初始化。
- Seed 数据可导入。
- 前端能登录并读取真实接口。
-
-任务：
-
- 实现 DB session。
- 建立 Alembic 或 SQL 初始化流程。
- 实现 `auth`、`dashboard`、`dataset`、`model` 基础接口。
- 完成 Docker app 启动说明。
-
-验收：
-
- `GET /api/health` 正常。
- `POST /api/login` 成功。
- 前端模型/数据集列表来自后端 DB。
-
-### 阶段 2：Compute Simulator
-
-目标：
-
- 算力节点、GPU、队列可演示。
- 训练任务可以模拟运行。
-
-任务：
-
- 实现 `compute/api/main.py` 内部接口。
- 实现模拟 GPU 状态。
- 实现模拟任务生命周期。
- 实现训练日志和 loss 生成。
- 实现应用后端轮询同步。
-
-验收：
-
- 前端 `/compute/gpus` 可看到 GPU 动态状态。
- 创建训练任务后 GPU 状态变化。
- `/training-log/:id` 能看到日志和曲线。
-
-### 阶段 3：微调主链路
-
-目标：
-
- 训练任务从创建到完成可完整演示。
-
-任务：
-
- 实现调度器。
- 实现资源副本检查。
- 实现资源同步任务模拟。
- 实现 checkpoint 和 trained model 登记。
- 前端微调创建页接入真实后端。
-
-验收：
-
- 自动调度能选择节点。
- 手动指定节点能生效。
- 缺资源时先同步再训练。
- 训练完成后模型产物出现在模型管理页。
-
-### 阶段 4：LLaMA-Factory Adapter Dry Run
-
-目标：
-
- 即使没有真实 GPU，也能展示平台如何生成 LLaMA-Factory 命令和配置。
-
-任务：
-
- 实现参数校验。
- 实现 YAML/命令生成。
- 实现日志解析器。
- 在训练详情页展示命令预览。
-
-验收：
-
- 创建训练任务后能查看 LLaMA-Factory 命令。
- 参数错误能返回可读错误。
- 日志解析器能从样例日志提取 loss。
-
-### 阶段 5：真实 GPU/LLaMA-Factory 可选接入
-
-目标：
-
- 在有 GPU 环境时可切换为真实训练。
-
-任务：
-
- 接入 `nvidia-smi`。
- 检查 CUDA/Driver/PyTorch。
- 启动 LLaMA-Factory 训练进程。
- 停止训练进程。
- 扫描真实 checkpoint。
-
-验收：
-
- `COMPUTE_MODE=real` 时能读取真实 GPU。
- 能启动一个最小 LLaMA-Factory 样例任务。
- 真实日志能显示在训练日志页。
-
-## 7. 前后端联调顺序
-
-1. 登录。
-2. 看板。
-3. 模型列表。
-4. 数据集列表。
-5. 算力节点和 GPU。
-6. 微调创建。
-7. 训练任务列表。
-8. 训练日志详情。
-9. 模型产物列表。
-10. 推理对话 Mock/后端接口。
-
-## 8. Demo 验收标准
-
-必须满足：
-
- 不依赖真实 GPU 时，Demo 仍可完整跑通。
- 前端核心页面不再只依赖静态 Mock。
- 数据写入 PostgreSQL，刷新页面后仍存在。
- 训练任务状态会自动流转。
- GPU 状态会随任务变化。
- 训练日志会持续追加。
- loss 曲线会随训练推进变化。
- 训练完成后生成 checkpoint 和训练产物。
- 多算力节点页面能展示节点权重、标签、启用状态和维护状态。
- 资源副本页面能展示模型/数据集在哪些节点已有缓存。
-
-可选满足：
-
- 接入真实 `nvidia-smi`。
- 接入真实 LLaMA-Factory。
- 支持真实文件上传到算力节点本地磁盘。
-
-## 9. 风险和约束
-
-| 风险 | 影响 | Demo 处理 |
-| --- | --- | --- |
-| 无 GPU 环境 | 不能真实训练 | 使用 `COMPUTE_MODE=simulator` |
-| 无 LLaMA-Factory | 不能启动训练框架 | 使用 adapter `dry_run` 和 simulator |
-| 文件太大 | 本地 Demo 慢或失败 | Demo 只使用小样本和占位文件 |
-| 前端页面仍有 Mock 依赖 | 联调不完整 | 逐页替换 API，不一次性重写 |
-| 多节点真实网络不可用 | 无法多机演示 | 用多条 `compute_nodes` 模拟多节点 |
-
-## 10. 建议第一批开发任务
-
-第一批建议只做 8 个任务：
-
-1. 后端 DB session 和配置。
-2. Seed 数据脚本。
-3. 登录、模型、数据集基础接口。
-4. Compute simulator 基础接口。
-5. GPU 动态状态模拟。
-6. 微调任务创建和状态机。
-7. 训练日志/指标模拟。
-8. 前端微调主链路接入后端。
-
-完成这 8 个任务后，就可以形成第一版可演示 Demo。
--- a/docs/deployment-plan.md
+++ b/docs/deployment-plan.md
@@ -111,11 +111,11 @@ flowchart LR
 | 服务 | 端口 | 暴露范围 |
 | --- | --- | --- |
 | Nginx | 80/443 | 用户网段 |
-| Backend API | 8000 | 仅 Nginx、本机 |
-| Compute API | 9100 | 仅 Backend API、本机 |
-| File Gateway | 9101 | 仅 Backend API、本机 |
-| PostgreSQL | 5432 | 本机或内网 |
-| Redis | 6379 | 本机或内网 |
+| Backend API | 17861 | 仅 Nginx、本机 |
+| Compute API | 19100 | 仅 Backend API、本机 |
+| File Gateway | 19101 | 仅 Backend API、本机 |
+| PostgreSQL | 15432 | 本机或内网 |
+| Redis | 16379 | 本机或内网 |

 ## 5. 方案二：应用服务与算力/训练服务独立部署

@@ -275,9 +275,9 @@ API_PREFIX=/api
 DATABASE_URL=postgresql+asyncpg://yg_ft:***@postgres:5432/yg_ft
 REDIS_URL=redis://redis:6379/0
 LOG_DIR=/opt/yg-ft/logs/backend
-COMPUTE_API_BASE_URL=https://compute.internal:9100
+COMPUTE_API_BASE_URL=https://compute.internal:19100
 COMPUTE_SERVICE_TOKEN=***
-FILE_GATEWAY_BASE_URL=https://compute.internal:9101
+FILE_GATEWAY_BASE_URL=https://compute.internal:19101
 COMPUTE_STATUS_SYNC_MODE=polling
 COMPUTE_POLL_INTERVAL_SECONDS=10
 COMPUTE_POLL_BATCH_SIZE=100
@@ -288,12 +288,11 @@ COMPUTE_POLL_BATCH_SIZE=100
 ```env
 COMPUTE_ENV=prod
 COMPUTE_HOST_ID=gpu-node-01
-COMPUTE_API_PORT=9100
-FILE_GATEWAY_PORT=9101
+COMPUTE_API_PORT=19100
+FILE_GATEWAY_PORT=19101
 COMPUTE_SERVICE_TOKEN=***
 ENABLE_APP_CALLBACK=false
-LLAMA_FACTORY_HOME=/opt/LLaMA-Factory
-LLAMA_FACTORY_HOST_PATH=/opt/LLaMA-Factory
+LLAMA_FACTORY_HOME=/app/LLaMA-Factory
 YG_FT_DATA_ROOT=/data/yg-ft
 LOG_DIR=/opt/yg-ft/logs/compute
 CUDA_VISIBLE_DEVICES=0,1,2,3
@@ -360,8 +359,7 @@ docker/
 ```bash
 cd docker/app
 cp .env.example .env
-docker compose --profile build run --rm frontend-builder
-docker compose up -d --build
+docker compose up -d
 ```

 算力服务器启动：
@@ -369,14 +367,14 @@ docker compose up -d --build
 ```bash
 cd docker/compute
 cp .env.example .env
-docker compose up -d --build
+docker compose up -d
 ```

 应用服务器与算力服务器独立部署时，需要在 `docker/app/.env` 中配置：

 ```env
-COMPUTE_API_BASE_URL=http://<compute-server-ip>:9100
-FILE_GATEWAY_BASE_URL=http://<compute-server-ip>:9101
+COMPUTE_API_BASE_URL=http://<compute-server-ip>:19100
+FILE_GATEWAY_BASE_URL=http://<compute-server-ip>:19101
 COMPUTE_SERVICE_TOKEN=change_me
 ```

@@ -385,9 +383,9 @@ COMPUTE_SERVICE_TOKEN=change_me
 多节点后，每台算力服务器各自进入 `docker/compute` 启动一套算力服务，并在应用平台中登记为一条 `compute_nodes` 记录：

 ```text
-gpu-node-01 -> http://10.10.20.31:9100 / http://10.10.20.31:9101
-gpu-node-02 -> http://10.10.20.32:9100 / http://10.10.20.32:9101
-gpu-node-03 -> http://10.10.20.33:9100 / http://10.10.20.33:9101
+gpu-node-01 -> http://10.10.20.31:19100 / http://10.10.20.31:19101
+gpu-node-02 -> http://10.10.20.32:19100 / http://10.10.20.32:19101
+gpu-node-03 -> http://10.10.20.33:19100 / http://10.10.20.33:19101
 ```

 算力服务器需要在 `docker/compute/.env` 中配置：
@@ -395,7 +393,6 @@ gpu-node-03 -> http://10.10.20.33:9100 / http://10.10.20.33:9101
 ```env
 ENABLE_APP_CALLBACK=false
 COMPUTE_SERVICE_TOKEN=change_me
-LLAMA_FACTORY_HOST_PATH=/opt/LLaMA-Factory
 YG_FT_DATA_ROOT_HOST=/data/yg-ft
 ```

--- a/docs/first-version-development-plan.md
+++ b/docs/first-version-development-plan.md
@@ -0,0 +1,135 @@
+# 第一版系统开发计划
+
+> 说明：本计划虽然以“可演示闭环”为阶段目标，但实现内容按正式系统第一版开发，不在工程模块、配置项、接口标签、数据库对象中使用临时代码命名。初始化数据仅作为样例种子数据，后续可在此基础上继续扩展为生产能力。
+
+## 1. 阶段目标
+
+第一版系统需要在没有完整生产环境、没有真实 GPU 或没有 LLaMA-Factory 运行环境时，仍然可以跑通模型微调平台的主链路：
+
+```text
+登录
+ -> 模型管理
+ -> 数据集管理
+ -> 创建微调任务
+ -> 调度算力节点与 GPU
+ -> 模拟资源副本检查和同步
+ -> 启动训练任务
+ -> 查看任务状态、GPU 占用、训练日志、loss 曲线
+ -> 训练完成后登记训练产物
+```
+
+该阶段不是一次性展示代码，而是后续系统继续开发的基础版本。算力、训练框架、资源同步、任务状态机均按真实平台边界设计，当前仅以 `simulator` 模式补齐无 GPU 环境下的可运行能力。
+
+## 2. 运行模式
+
+| 模式 | 说明 | 当前状态 |
+| --- | --- | --- |
+| `simulator` | 模拟 GPU、训练进程、日志、指标、checkpoint 和训练产物 | 第一版默认实现 |
+| `real` | 预留真实 `nvidia-smi`、LLaMA-Factory 进程启动、真实日志解析和产物扫描 | 后续接入 |
+
+第一版实现必须保留 `real` 模式边界，不允许把训练命令直接写死在应用平台后端。训练相关能力统一沉淀在 `compute/engines/` 适配层。
+
+## 3. 第一批开发范围
+
+### 3.1 应用平台后端
+
+对应目录：
+
+```text
+backend/app/
+  api/v1/endpoints/platform.py
+  db/platform_store.py
+  db/session.py
+```
+
+已覆盖能力：
+- 统一 API 响应结构 `{ code, message, data }`。
+- 初始化样例用户、模型、数据集、算力节点、GPU 和微调任务。
+- 登录、当前用户、用户列表与权限。
+- 模型管理、训练产物列表、权重合并任务占位。
+- 数据集管理、文件上传、预览、版本管理和下载。
+- 微调任务创建、启动、停止、删除、进度查询、checkpoint 查询。
+- 系统健康指标、系统信息、训练日志、系统日志。
+- 算力节点、GPU、队列、资源副本、资源同步任务接口。
+
+开发约定：
+- 当前本地可运行存储使用 SQLite，配置项为 `LOCAL_DB_PATH`。
+- 生产数据库仍以 PostgreSQL 为目标，正式表结构以 `docs/postgres-schema.sql` 为准。
+- `backend/app/db/session.py` 已提供 SQLAlchemy session 入口，后续替换正式 ORM 时从此处收口。
+
+### 3.2 算力平台服务
+
+对应目录：
+
+```text
+compute/
+  api/main.py
+  engines/llama_factory/adapter.py
+```
+
+已覆盖能力：
+- `/health` 与 `/api/v1/compute/health` 节点健康检查。
+- `/compute/resources/gpus` GPU 状态模拟。
+- `/compute/jobs` 创建、查询、停止训练任务。
+- `/compute/jobs/{id}/logs` 拉取训练日志与解析指标。
+- `/compute/files/upload` 与 `/compute/files/{id}/download` 文件网关占位。
+- LLaMA-Factory 参数校验、命令生成、日志指标解析。
+
+设计约定：
+- 多算力节点阶段，每台单机多 GPU 服务器都部署一套 Compute API、Agent、File Gateway 和训练框架。
+- 应用平台通过 `compute_nodes` 中维护的 `api_base_url`、`file_gateway_url` 主动轮询算力节点。
+- 算力节点之间默认不互访，资源副本和同步状态由应用平台统一编排。
+
+### 3.3 前端页面
+
+已接入页面：
+- `/login`：登录接口。
+- `/model-manage`：模型列表与模型来源。
+- `/dataset`、`/dataset/:id/preview`：数据集列表、预览和版本。
+- `/fine-tune`、`/fine-tune/create`：微调任务创建、启动、状态轮询。
+- `/training-log/:id`：训练日志和 loss 曲线。
+- `/hardware`：平台 GPU 与系统性能。
+- `/compute`：算力节点、GPU、队列、资源副本。
+
+新增前端能力：
+- `frontend/src/api/modules/compute.ts`：算力节点 API 包装。
+- `frontend/src/views/compute/ComputeNodesView.vue`：节点、GPU、队列、资源副本四个视图。
+- 权限枚举增加 `compute`，菜单增加“算力节点”入口。
+
+### 3.4 数据库
+
+第一版运行时使用本地 SQLite 以降低开发环境门槛，但数据库模型仍按 PostgreSQL 正式设计推进。
+
+核心表范围：
+- 用户、租户、项目、角色、权限。
+- 模型、训练产物、数据集、数据集文件、存储对象。
+- 微调任务、训练指标、checkpoint、审计日志。
+- 算力节点、GPU 设备、算力任务、GPU 分配。
+- 资源副本、资源同步任务。
+
+优化方向：
+- 任务状态、租户/项目隔离字段、资源副本定位字段需要建立索引。
+- 审计日志、训练指标、日志归档后续建议按时间分区。
+- 大文件只落本地磁盘或对象存储，数据库保存元数据和版本关系。
+
+## 4. 验收标准
+
+第一版完成后应满足：
+- 前端不启用静态 Mock 时，可以通过 FastAPI 获取主要页面数据。
+- 登录后可以看到模型、数据集、微调任务和算力节点。
+- 创建微调任务后可以启动任务，任务状态自动流转。
+- GPU 状态会随任务进入 `syncing`、`queued`、`running` 发生变化。
+- 训练日志持续生成，日志详情页能解析 loss、grad norm、learning rate、epoch。
+- 任务完成后训练产物出现在模型管理的训练产物列表中。
+- 算力节点页面可展示节点地址、权重、标签、启用状态、队列和资源副本。
+- 工程命名、配置和接口分组均可作为后续正式开发基础。
+
+## 5. 后续开发计划
+
+| 阶段 | 重点 | 说明 |
+| --- | --- | --- |
+| 第二阶段 | PostgreSQL ORM 与 Alembic | 将 `platform_store.py` 的能力迁移为正式 ORM、迁移脚本和 repository/service 分层 |
+| 第三阶段 | 真实 Compute Agent | 接入 `nvidia-smi`、GPU 锁定、进程管理、训练日志文件采集 |
+| 第四阶段 | LLaMA-Factory 真实训练 | 生成 YAML/命令、启动训练进程、停止任务、扫描 checkpoint 和 adapter |
+| 第五阶段 | 企业治理 | 多租户、项目/模型/数据集隔离、审批流、审计留存、配额和资源申请 |
+| 第六阶段 | 多节点调度 | 基于 `compute_nodes`、资源副本和节点标签实现自动/手动调度策略 |
--- a/docs/superpowers/plans/2026-07-10-data-process-create-wizard.md
+++ b/docs/superpowers/plans/2026-07-10-data-process-create-wizard.md
@@ -431,9 +431,9 @@ Expected: 三项检查全部 PASS。

 - [ ] **Step 3: 启动页面并逐步验证四步交互**

-Run: `cd frontend && npm run dev -- --host 0.0.0.0 --port 6801`
+Run: `cd frontend && npm run dev -- --host 0.0.0.0 --port 16801`

-Browser checks at `http://localhost:6801/data-process/create`:
+Browser checks at `http://localhost:16801/data-process/create`:

 1. 第一步上传文本并选择非结构化数据。
 2. 第二步点击至少三个右侧切片，确认左侧滚动目标和高亮范围变化。
--- a/frontend/README.md
+++ b/frontend/README.md
@@ -22,9 +22,9 @@ npm install
 npm run dev
 ```

-开发服务器默认运行在 `http://localhost:6801`。
+开发服务器默认运行在 `http://localhost:16801`。

-后端 API 默认通过 Vite 代理转发到 `http://localhost:7861`（见 `vite.config.ts`）。
+后端 API 默认通过 Vite 代理转发到 `http://localhost:17861`（见 `vite.config.ts`）。

 开发环境默认启用前端 Mock。如需联调真实后端，使用：

--- a/frontend/src/api/modules/compute.ts
+++ b/frontend/src/api/modules/compute.ts
@@ -0,0 +1,85 @@
+import { get, post, put } from '../request'
+
+export interface ComputeNode {
+  id: string
+  code: string
+  name: string
+  api_base_url: string
+  file_gateway_url: string
+  enabled: boolean
+  scheduler_status: string
+  scheduler_weight: number
+  tags: string[]
+  gpu_count: number
+  current_running_jobs: number
+  max_parallel_jobs: number
+  data_root: string
+  model_root: string
+  log_root: string
+  last_health_check_at?: string
+}
+
+export interface ComputeGpu {
+  id: number
+  node_id: string
+  node_code: string
+  node_name: string
+  name: string
+  uuid: string
+  status: string
+  gpu_percent: number
+  memory_used_gb: number
+  memory_total_gb: number
+  memory_percent: number
+  temperature: number
+  power_w: number
+  power_limit_w: number
+  processes?: Array<{
+    pid: number
+    name: string
+    memory_used_gb: number
+    task_name?: string
+    user?: string
+  }>
+}
+
+export interface ComputeQueueItem {
+  id: string
+  name: string
+  status: string
+  progress: number
+  compute_node_id?: string
+  gpus: number[]
+  create_time?: string
+}
+
+export interface ResourceReplica {
+  id: string
+  node_id: string
+  resource_type: string
+  resource_id: string
+  local_path: string
+  status: string
+  sync_status: string
+  create_time: string
+}
+
+export const getComputeNodes = () => get<ComputeNode[]>('/compute/nodes')
+
+export const updateComputeNode = (id: string, data: Partial<ComputeNode>) =>
+  put<ComputeNode>(`/compute/nodes/${id}`, data)
+
+export const testComputeNode = (id: string) =>
+  post<{ node_id: string; success: boolean; latency_ms: number }>(`/compute/nodes/${id}/test-connection`)
+
+export const enableComputeNode = (id: string) => post<ComputeNode>(`/compute/nodes/${id}/enable`)
+
+export const disableComputeNode = (id: string) => post<ComputeNode>(`/compute/nodes/${id}/disable`)
+
+export const drainComputeNode = (id: string) => post<ComputeNode>(`/compute/nodes/${id}/drain`)
+
+export const getComputeGpus = () => get<ComputeGpu[]>('/compute/gpus')
+
+export const getComputeQueue = () => get<ComputeQueueItem[]>('/compute/queue')
+
+export const getNodeReplicas = (id: string) => get<ResourceReplica[]>(`/compute/nodes/${id}/replicas`)
--- a/frontend/src/api/request.ts
+++ b/frontend/src/api/request.ts
@@ -12,7 +12,7 @@ export interface ApiResult<T = any> {
 }

 const service: AxiosInstance = axios.create({
-  // 统一走相对路径，由 Vite 代理转发到 http://localhost:7861
+  // Use a relative path; Vite proxies /api to http://localhost:17861 in local development.
  baseURL: '/api',
  timeout: 30000,
 })
--- a/frontend/src/assets/login-hero-flow.jpg
+++ b/frontend/src/assets/login-hero-flow.jpg
--- a/frontend/src/components/AppSidebar.vue
+++ b/frontend/src/components/AppSidebar.vue
@@ -68,6 +68,12 @@ const menuGroups: MenuGroup[] = [
    title: '其他工具',
    items: [{ key: 'data-convert', label: '数据类型转换', icon: 'fa-exchange', to: '/data-convert', permission: 'data-convert' }],
  },
+  {
+    title: '算力资源',
+    items: [
+      { key: 'compute', label: '算力节点', icon: 'fa-microchip', to: '/compute', permission: 'compute' },
+    ],
+  },
  {
    title: '系统设置',
    items: [
--- a/frontend/src/mock/users.ts
+++ b/frontend/src/mock/users.ts
@@ -0,0 +1,144 @@
+import type {
+  CreateUserPayload,
+  LoginResponse,
+  PermissionCode,
+  SystemUser,
+  UpdateUserAccessPayload,
+} from '@/types'
+
+const STORAGE_KEY = 'mock:system-users'
+
+const allPermissions: PermissionCode[] = [
+  'dashboard',
+  'fine-tune',
+  'model-eval',
+  'model-inference',
+  'model-manage',
+  'dataset',
+  'data-process',
+  'data-convert',
+  'compute',
+  'hardware',
+  'logs',
+  'user-settings',
+]
+
+const defaultPasswords: Record<string, string> = {
+  admin: 'admin123',
+  operator: 'operator123',
+}
+
+export class UserMutationError extends Error {
+  status: number
+
+  constructor(message: string, status = 400) {
+    super(message)
+    this.name = 'UserMutationError'
+    this.status = status
+  }
+}
+
+function defaultUsers(): SystemUser[] {
+  return [
+    {
+      id: 'u_admin',
+      username: 'admin',
+      display_name: 'Platform Admin',
+      role: 'admin',
+      status: 'active',
+      permissions: allPermissions,
+      create_time: '2026-01-01T00:00:00Z',
+      protected: true,
+    },
+    {
+      id: 'u_operator',
+      username: 'operator',
+      display_name: 'Platform Operator',
+      role: 'operator',
+      status: 'active',
+      permissions: allPermissions.filter((item) => item !== 'user-settings'),
+      create_time: '2026-01-01T00:00:00Z',
+      protected: false,
+    },
+  ]
+}
+
+function readUsers(): SystemUser[] {
+  const raw = localStorage.getItem(STORAGE_KEY)
+  if (!raw) return defaultUsers()
+  try {
+    const users = JSON.parse(raw) as SystemUser[]
+    return users.length ? users : defaultUsers()
+  } catch {
+    return defaultUsers()
+  }
+}
+
+function writeUsers(users: SystemUser[]) {
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(users))
+}
+
+export function listMockUsers(): SystemUser[] {
+  return readUsers()
+}
+
+export function authenticateMockUser(username: string, password: string): LoginResponse {
+  const users = readUsers()
+  const user = users.find((item) => item.username === username)
+  if (!user || user.status !== 'active') {
+    throw new UserMutationError('Invalid username or disabled account', 401)
+  }
+  const expected = defaultPasswords[username] || 'platform123'
+  if (password !== expected) {
+    throw new UserMutationError('Invalid username or password', 401)
+  }
+  user.last_login = new Date().toISOString()
+  writeUsers(users)
+  return {
+    token: `mock-token-${user.id}`,
+    user,
+  }
+}
+
+export function createMockUser(payload: CreateUserPayload): SystemUser {
+  const users = readUsers()
+  if (users.some((item) => item.username === payload.username)) {
+    throw new UserMutationError('Username already exists', 409)
+  }
+  const user: SystemUser = {
+    id: `u_${Date.now()}`,
+    username: payload.username,
+    display_name: payload.display_name || payload.username,
+    role: payload.role,
+    status: payload.status || 'active',
+    permissions: payload.permissions || [],
+    create_time: new Date().toISOString(),
+    protected: false,
+  }
+  defaultPasswords[user.username] = payload.password || 'platform123'
+  users.push(user)
+  writeUsers(users)
+  return user
+}
+
+export function updateMockUserAccess(id: string, payload: UpdateUserAccessPayload): SystemUser {
+  const users = readUsers()
+  const user = users.find((item) => item.id === id)
+  if (!user) throw new UserMutationError('User not found', 404)
+  if (payload.role) user.role = payload.role
+  if (payload.status) user.status = payload.status
+  if (payload.permissions) user.permissions = payload.permissions
+  writeUsers(users)
+  return user
+}
+
+export function deleteMockUser(id: string, currentUsername: string): { deleted: string } {
+  const users = readUsers()
+  const user = users.find((item) => item.id === id)
+  if (!user) throw new UserMutationError('User not found', 404)
+  if (user.protected || user.username === currentUsername) {
+    throw new UserMutationError('Protected or current user cannot be deleted', 400)
+  }
+  writeUsers(users.filter((item) => item.id !== id))
+  return { deleted: id }
+}
--- a/frontend/src/plugins/echarts-hardware.ts
+++ b/frontend/src/plugins/echarts-hardware.ts
@@ -0,0 +1,17 @@
+import { use } from 'echarts/core'
+import { CanvasRenderer } from 'echarts/renderers'
+import { GaugeChart, LineChart } from 'echarts/charts'
+import {
+  GridComponent,
+  LegendComponent,
+  TooltipComponent,
+} from 'echarts/components'
+
+use([
+  CanvasRenderer,
+  LineChart,
+  GaugeChart,
+  GridComponent,
+  TooltipComponent,
+  LegendComponent,
+])
--- a/frontend/src/plugins/echarts-training-log.ts
+++ b/frontend/src/plugins/echarts-training-log.ts
@@ -0,0 +1,18 @@
+import { use } from 'echarts/core'
+import { CanvasRenderer } from 'echarts/renderers'
+import { LineChart } from 'echarts/charts'
+import {
+  DataZoomComponent,
+  GridComponent,
+  LegendComponent,
+  TooltipComponent,
+} from 'echarts/components'
+
+use([
+  CanvasRenderer,
+  LineChart,
+  GridComponent,
+  TooltipComponent,
+  LegendComponent,
+  DataZoomComponent,
+])
--- a/frontend/src/router/index.ts
+++ b/frontend/src/router/index.ts
@@ -197,6 +197,24 @@ const routes: RouteRecordRaw[] = [
        component: () => import('@/views/data-convert/DataConvertView.vue'),
        meta: { title: '数据类型转换' },
      },
+      {
+        path: 'compute',
+        name: 'compute',
+        component: () => import('@/views/compute/ComputeNodesView.vue'),
+        meta: { title: '算力节点', pageSurface: 'self', permission: 'compute' },
+      },
+      {
+        path: 'compute/gpus',
+        redirect: '/compute?tab=gpus',
+      },
+      {
+        path: 'compute/queue',
+        redirect: '/compute?tab=queue',
+      },
+      {
+        path: 'compute/nodes',
+        redirect: '/compute?tab=nodes',
+      },
      // 系统设置
      {
        path: 'permission-denied',
@@ -264,6 +282,7 @@ const permissionBySegment: Record<string, PermissionCode> = {
  dataset: 'dataset',
  'data-process': 'data-process',
  'data-convert': 'data-convert',
+  compute: 'compute',
  tools: 'data-convert',
  hardware: 'hardware',
  logs: 'logs',
--- a/frontend/src/stores/auth.ts
+++ b/frontend/src/stores/auth.ts
@@ -15,6 +15,7 @@ const allPermissions: PermissionCode[] = [
  'dataset',
  'data-process',
  'data-convert',
+  'compute',
  'hardware',
  'logs',
  'user-settings',
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -394,6 +394,7 @@ export type PermissionCode =
  | 'dataset'
  | 'data-process'
  | 'data-convert'
+  | 'compute'
  | 'hardware'
  | 'logs'
  | 'user-settings'
--- a/frontend/src/views/compute/ComputeNodesView.vue
+++ b/frontend/src/views/compute/ComputeNodesView.vue
@@ -0,0 +1,376 @@
+<script setup lang="ts">
+import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
+import { useRoute, useRouter } from 'vue-router'
+import {
+  disableComputeNode,
+  drainComputeNode,
+  enableComputeNode,
+  getComputeGpus,
+  getComputeNodes,
+  getComputeQueue,
+  getNodeReplicas,
+  testComputeNode,
+  type ComputeGpu,
+  type ComputeNode,
+  type ComputeQueueItem,
+  type ResourceReplica,
+} from '@/api/modules/compute'
+
+const route = useRoute()
+const router = useRouter()
+
+const activeTab = ref(String(route.query.tab || 'nodes'))
+const loading = ref(false)
+const nodes = ref<ComputeNode[]>([])
+const gpus = ref<ComputeGpu[]>([])
+const queue = ref<ComputeQueueItem[]>([])
+const replicas = ref<ResourceReplica[]>([])
+const selectedNodeId = ref('')
+const lastUpdated = ref('')
+let timer: ReturnType<typeof setInterval> | null = null
+
+const selectedNode = computed(() => nodes.value.find((item) => item.id === selectedNodeId.value))
+const enabledNodes = computed(() => nodes.value.filter((item) => item.enabled).length)
+const busyGpus = computed(() => gpus.value.filter((item) => item.status === 'busy' || item.status === 'reserved').length)
+const totalRunningJobs = computed(() => nodes.value.reduce((sum, item) => sum + item.current_running_jobs, 0))
+
+watch(
+  () => route.query.tab,
+  (tab) => {
+    activeTab.value = String(tab || 'nodes')
+  },
+)
+
+async function load() {
+  loading.value = true
+  try {
+    const [nodeList, gpuList, queueList] = await Promise.all([
+      getComputeNodes(),
+      getComputeGpus(),
+      getComputeQueue(),
+    ])
+    nodes.value = nodeList
+    gpus.value = gpuList
+    queue.value = queueList
+    if (!selectedNodeId.value && nodeList.length) selectedNodeId.value = nodeList[0].id
+    await loadReplicas()
+    lastUpdated.value = new Date().toLocaleTimeString('zh-CN', { hour12: false })
+  } finally {
+    loading.value = false
+  }
+}
+
+async function loadReplicas() {
+  if (!selectedNodeId.value) {
+    replicas.value = []
+    return
+  }
+  replicas.value = await getNodeReplicas(selectedNodeId.value)
+}
+
+async function changeTab(name: string | number) {
+  await router.replace({ path: '/compute', query: { tab: String(name) } })
+}
+
+async function handleNodeAction(action: 'enable' | 'disable' | 'drain' | 'test', node: any) {
+  const nodeId = String(node.id)
+  if (action === 'enable') await enableComputeNode(nodeId)
+  if (action === 'disable') await disableComputeNode(nodeId)
+  if (action === 'drain') await drainComputeNode(nodeId)
+  if (action === 'test') await testComputeNode(nodeId)
+  await load()
+}
+
+function nodeStatusType(status: string) {
+  if (status === 'online') return 'success'
+  if (status === 'draining' || status === 'maintenance') return 'warning'
+  return 'info'
+}
+
+function taskStatusType(status: string) {
+  if (status === 'running') return 'success'
+  if (status === 'syncing' || status === 'queued') return 'warning'
+  if (status === 'failed') return 'danger'
+  return 'info'
+}
+
+function gpuStatusType(status: string) {
+  if (status === 'busy') return 'success'
+  if (status === 'reserved') return 'warning'
+  return 'info'
+}
+
+onMounted(() => {
+  load()
+  timer = setInterval(load, 5000)
+})
+
+onUnmounted(() => {
+  if (timer) clearInterval(timer)
+})
+</script>
+
+<template>
+  <section class="compute-page" v-loading="loading">
+    <header class="compute-header">
+      <div>
+        <h1>算力节点</h1>
+        <p>维护训练算力节点、GPU 状态、任务队列和模型/数据集本地副本。</p>
+      </div>
+      <div class="header-actions">
+        <span v-if="lastUpdated" class="last-updated">更新 {{ lastUpdated }}</span>
+        <el-button @click="load">刷新</el-button>
+      </div>
+    </header>
+
+    <div class="summary-grid">
+      <div class="summary-tile">
+        <span>在线节点</span>
+        <strong>{{ enabledNodes }} / {{ nodes.length }}</strong>
+      </div>
+      <div class="summary-tile">
+        <span>GPU 占用</span>
+        <strong>{{ busyGpus }} / {{ gpus.length }}</strong>
+      </div>
+      <div class="summary-tile">
+        <span>运行任务</span>
+        <strong>{{ totalRunningJobs }}</strong>
+      </div>
+      <div class="summary-tile">
+        <span>队列任务</span>
+        <strong>{{ queue.length }}</strong>
+      </div>
+    </div>
+
+    <el-tabs v-model="activeTab" class="compute-tabs" @tab-change="changeTab">
+      <el-tab-pane label="节点" name="nodes">
+        <el-table :data="nodes" height="100%">
+          <el-table-column prop="code" label="节点编码" min-width="150" />
+          <el-table-column prop="name" label="节点名称" min-width="150" />
+          <el-table-column label="状态" width="120">
+            <template #default="{ row }">
+              <el-tag :type="nodeStatusType(row.scheduler_status)">{{ row.scheduler_status }}</el-tag>
+            </template>
+          </el-table-column>
+          <el-table-column label="启用" width="90">
+            <template #default="{ row }">
+              <el-tag :type="row.enabled ? 'success' : 'info'">{{ row.enabled ? '启用' : '停用' }}</el-tag>
+            </template>
+          </el-table-column>
+          <el-table-column prop="scheduler_weight" label="权重" width="90" />
+          <el-table-column label="标签" min-width="220">
+            <template #default="{ row }">
+              <el-space wrap>
+                <el-tag v-for="tag in row.tags" :key="tag" effect="plain">{{ tag }}</el-tag>
+              </el-space>
+            </template>
+          </el-table-column>
+          <el-table-column label="任务/GPU" width="120">
+            <template #default="{ row }">{{ row.current_running_jobs }} / {{ row.gpu_count }}</template>
+          </el-table-column>
+          <el-table-column label="服务地址" min-width="260">
+            <template #default="{ row }">
+              <div class="mono">{{ row.api_base_url }}</div>
+              <div class="muted mono">{{ row.file_gateway_url }}</div>
+            </template>
+          </el-table-column>
+          <el-table-column label="操作" width="260" fixed="right">
+            <template #default="{ row }">
+              <el-button size="small" @click="handleNodeAction('test', row)">测试</el-button>
+              <el-button v-if="row.enabled" size="small" @click="handleNodeAction('disable', row)">停用</el-button>
+              <el-button v-else size="small" type="primary" @click="handleNodeAction('enable', row)">启用</el-button>
+              <el-button size="small" type="warning" plain @click="handleNodeAction('drain', row)">维护</el-button>
+            </template>
+          </el-table-column>
+        </el-table>
+      </el-tab-pane>
+
+      <el-tab-pane label="GPU" name="gpus">
+        <el-table :data="gpus" height="100%">
+          <el-table-column label="GPU" min-width="220">
+            <template #default="{ row }">
+              <strong>{{ row.node_code }} / GPU {{ row.id }}</strong>
+              <div class="muted">{{ row.name }}</div>
+            </template>
+          </el-table-column>
+          <el-table-column label="状态" width="100">
+            <template #default="{ row }">
+              <el-tag :type="gpuStatusType(row.status)">{{ row.status }}</el-tag>
+            </template>
+          </el-table-column>
+          <el-table-column label="利用率" min-width="180">
+            <template #default="{ row }">
+              <el-progress :percentage="row.gpu_percent" :stroke-width="8" />
+            </template>
+          </el-table-column>
+          <el-table-column label="显存" min-width="190">
+            <template #default="{ row }">
+              <el-progress :percentage="Math.round(row.memory_percent)" :stroke-width="8" />
+              <span class="muted">{{ row.memory_used_gb }} / {{ row.memory_total_gb }} GB</span>
+            </template>
+          </el-table-column>
+          <el-table-column label="温度/功耗" width="150">
+            <template #default="{ row }">{{ row.temperature }} C / {{ row.power_w }} W</template>
+          </el-table-column>
+          <el-table-column label="进程" min-width="220">
+            <template #default="{ row }">
+              <span v-if="!row.processes?.length" class="muted">空闲</span>
+              <div v-for="process in row.processes" :key="process.pid">
+                {{ process.task_name }} <span class="muted">PID {{ process.pid }}</span>
+              </div>
+            </template>
+          </el-table-column>
+        </el-table>
+      </el-tab-pane>
+
+      <el-tab-pane label="队列" name="queue">
+        <el-table :data="queue" height="100%">
+          <el-table-column prop="name" label="任务名称" min-width="200" />
+          <el-table-column label="状态" width="110">
+            <template #default="{ row }">
+              <el-tag :type="taskStatusType(row.status)">{{ row.status }}</el-tag>
+            </template>
+          </el-table-column>
+          <el-table-column label="进度" min-width="220">
+            <template #default="{ row }">
+              <el-progress :percentage="row.progress" :stroke-width="8" />
+            </template>
+          </el-table-column>
+          <el-table-column prop="compute_node_id" label="节点" width="140" />
+          <el-table-column label="GPU" width="120">
+            <template #default="{ row }">{{ row.gpus?.join(', ') || '-' }}</template>
+          </el-table-column>
+          <el-table-column prop="create_time" label="创建时间" width="190" />
+        </el-table>
+      </el-tab-pane>
+
+      <el-tab-pane label="资源副本" name="replicas">
+        <div class="replica-toolbar">
+          <el-select v-model="selectedNodeId" filterable @change="loadReplicas">
+            <el-option v-for="node in nodes" :key="node.id" :label="`${node.code} - ${node.name}`" :value="node.id" />
+          </el-select>
+          <span v-if="selectedNode" class="muted">当前节点 {{ selectedNode.api_base_url }}</span>
+        </div>
+        <el-table :data="replicas" height="100%">
+          <el-table-column prop="resource_type" label="资源类型" width="110" />
+          <el-table-column prop="resource_id" label="资源 ID" min-width="180" />
+          <el-table-column prop="local_path" label="本地路径" min-width="300" />
+          <el-table-column prop="status" label="状态" width="110" />
+          <el-table-column prop="sync_status" label="同步状态" width="120" />
+          <el-table-column prop="create_time" label="创建时间" width="190" />
+        </el-table>
+      </el-tab-pane>
+    </el-tabs>
+  </section>
+</template>
+
+<style scoped lang="scss">
+.compute-page {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  min-height: 0;
+  height: 100%;
+  padding: 24px;
+  background: #fff;
+}
+
+.compute-header {
+  display: flex;
+  justify-content: space-between;
+  gap: 16px;
+  align-items: flex-start;
+
+  h1 {
+    margin: 0;
+    font-size: 24px;
+    font-weight: 650;
+    color: #111827;
+  }
+
+  p {
+    margin: 8px 0 0;
+    color: #64748b;
+  }
+}
+
+.header-actions {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.last-updated,
+.muted {
+  color: #64748b;
+  font-size: 12px;
+}
+
+.summary-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 12px;
+}
+
+.summary-tile {
+  border: 1px solid #e5e7eb;
+  border-radius: 8px;
+  padding: 14px 16px;
+  background: #f8fafc;
+
+  span {
+    display: block;
+    color: #64748b;
+    font-size: 12px;
+  }
+
+  strong {
+    display: block;
+    margin-top: 8px;
+    color: #111827;
+    font-size: 24px;
+  }
+}
+
+.compute-tabs {
+  flex: 1;
+  min-height: 0;
+
+  :deep(.el-tabs__content) {
+    height: calc(100% - 56px);
+  }
+
+  :deep(.el-tab-pane) {
+    height: 100%;
+  }
+}
+
+.mono {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 12px;
+}
+
+.replica-toolbar {
+  display: flex;
+  gap: 12px;
+  align-items: center;
+  margin-bottom: 12px;
+
+  .el-select {
+    width: 280px;
+  }
+}
+
+@media (max-width: 960px) {
+  .compute-header,
+  .header-actions,
+  .replica-toolbar {
+    flex-direction: column;
+    align-items: stretch;
+  }
+
+  .summary-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+</style>
--- a/frontend/src/views/eval/create/BasicMetricSetupStep.vue
+++ b/frontend/src/views/eval/create/BasicMetricSetupStep.vue
@@ -0,0 +1,78 @@
+<script setup lang="ts">
+import { ref } from 'vue'
+import type { FormInstance, FormRules } from 'element-plus'
+
+export interface BasicMetricSetupDraft {
+  bleu_enabled: boolean
+  bleu_n: number
+  rouge_enabled: boolean
+  rouge_methods: string[]
+  cosine_enabled: boolean
+  output_precision: number
+}
+
+defineProps<{
+  disabled?: boolean
+}>()
+
+const form = defineModel<BasicMetricSetupDraft>({ required: true })
+const formRef = ref<FormInstance>()
+
+const rules: FormRules<BasicMetricSetupDraft> = {
+  bleu_n: [{ required: true, type: 'number', min: 1, max: 8, message: 'BLEU ngram must be between 1 and 8', trigger: 'change' }],
+  output_precision: [{ required: true, type: 'number', min: 0, max: 8, message: 'Precision must be between 0 and 8', trigger: 'change' }],
+}
+
+async function validate() {
+  if (!formRef.value) return false
+  try {
+    return !!(await formRef.value.validate())
+  } catch {
+    return false
+  }
+}
+
+defineExpose({ validate })
+</script>
+
+<template>
+  <el-form
+    ref="formRef"
+    :model="form"
+    :rules="rules"
+    label-width="140px"
+    class="basic-metric-form"
+    :disabled="disabled"
+  >
+    <el-form-item label="BLEU">
+      <el-switch v-model="form.bleu_enabled" />
+    </el-form-item>
+    <el-form-item v-if="form.bleu_enabled" label="BLEU ngram" prop="bleu_n">
+      <el-input-number v-model="form.bleu_n" :min="1" :max="8" />
+    </el-form-item>
+
+    <el-form-item label="ROUGE">
+      <el-switch v-model="form.rouge_enabled" />
+    </el-form-item>
+    <el-form-item v-if="form.rouge_enabled" label="ROUGE methods">
+      <el-checkbox-group v-model="form.rouge_methods">
+        <el-checkbox value="rouge_1">ROUGE-1</el-checkbox>
+        <el-checkbox value="rouge_2">ROUGE-2</el-checkbox>
+        <el-checkbox value="rouge_l">ROUGE-L</el-checkbox>
+      </el-checkbox-group>
+    </el-form-item>
+
+    <el-form-item label="Cosine">
+      <el-switch v-model="form.cosine_enabled" />
+    </el-form-item>
+    <el-form-item label="Output precision" prop="output_precision">
+      <el-input-number v-model="form.output_precision" :min="0" :max="8" />
+    </el-form-item>
+  </el-form>
+</template>
+
+<style scoped>
+.basic-metric-form {
+  max-width: 760px;
+}
+</style>
--- a/frontend/src/views/eval/create/StartEvalStep.vue
+++ b/frontend/src/views/eval/create/StartEvalStep.vue
@@ -0,0 +1,49 @@
+<script setup lang="ts">
+import type { DatasetItem, GpuInfo, ModelItem, TrainedModel } from '@/types'
+import type { BasicMetricSetupDraft } from './BasicMetricSetupStep.vue'
+import type { EvalRuleSetupDraft } from './EvalRuleSetupStep.vue'
+import type { EvalTaskSetupDraft } from './EvalTaskSetupStep.vue'
+
+const props = defineProps<{
+  task: EvalTaskSetupDraft
+  llmMetric: EvalRuleSetupDraft
+  basicMetrics: BasicMetricSetupDraft
+  trainedModels: TrainedModel[]
+  evalDatasets: DatasetItem[]
+  evalModels: ModelItem[]
+  gpus: GpuInfo[]
+}>()
+
+function nameOf<T extends { id: string | number; name?: string }>(items: T[], id: string | number) {
+  return items.find((item) => item.id === id)?.name || String(id || '-')
+}
+</script>
+
+<template>
+  <div class="start-eval-step">
+    <el-descriptions :column="2" border>
+      <el-descriptions-item label="Task">{{ props.task.eval_task_name || '-' }}</el-descriptions-item>
+      <el-descriptions-item label="Model">{{ nameOf(props.trainedModels, props.task.model_id) }}</el-descriptions-item>
+      <el-descriptions-item label="GPU">GPU {{ props.task.gpu_id || 0 }}</el-descriptions-item>
+      <el-descriptions-item label="Dataset">
+        {{ props.task.data_source === 'dataset' ? nameOf(props.evalDatasets, props.task.dataset_id) : 'Inference results' }}
+      </el-descriptions-item>
+      <el-descriptions-item label="Eval model">{{ nameOf(props.evalModels, props.llmMetric.eval_model || '') }}</el-descriptions-item>
+      <el-descriptions-item label="Eval method">{{ props.llmMetric.eval_method || '-' }}</el-descriptions-item>
+      <el-descriptions-item label="Basic metrics" :span="2">
+        <el-space wrap>
+          <el-tag v-if="props.basicMetrics.bleu_enabled">BLEU-{{ props.basicMetrics.bleu_n }}</el-tag>
+          <el-tag v-if="props.basicMetrics.rouge_enabled">{{ props.basicMetrics.rouge_methods.join(', ') }}</el-tag>
+          <el-tag v-if="props.basicMetrics.cosine_enabled">Cosine</el-tag>
+          <el-tag effect="plain">Precision {{ props.basicMetrics.output_precision }}</el-tag>
+        </el-space>
+      </el-descriptions-item>
+    </el-descriptions>
+  </div>
+</template>
+
+<style scoped>
+.start-eval-step {
+  max-width: 920px;
+}
+</style>
--- a/frontend/src/views/guide/GuideView.vue
+++ b/frontend/src/views/guide/GuideView.vue
@@ -0,0 +1,12 @@
+<template>
+  <section class="simple-page">
+    <h1>使用文档</h1>
+    <p>第一版系统已接入后端、数据集、模型、微调任务、算力节点和训练日志主链路。</p>
+  </section>
+</template>
+
+<style scoped>
+.simple-page {
+  padding: 24px;
+}
+</style>
--- a/frontend/src/views/system/PermissionDeniedView.vue
+++ b/frontend/src/views/system/PermissionDeniedView.vue
@@ -0,0 +1,12 @@
+<template>
+  <section class="simple-page">
+    <h1>无权访问</h1>
+    <p>当前账号没有访问该页面的权限，请联系管理员调整角色或页面权限。</p>
+  </section>
+</template>
+
+<style scoped>
+.simple-page {
+  padding: 24px;
+}
+</style>
--- a/frontend/src/views/system/UserCreateView.vue
+++ b/frontend/src/views/system/UserCreateView.vue
@@ -0,0 +1,94 @@
+<script setup lang="ts">
+import { reactive, ref } from 'vue'
+import { useRouter } from 'vue-router'
+import { ElMessage } from 'element-plus'
+import { createUser } from '@/api/modules/system'
+import type { CreateUserPayload, PermissionCode } from '@/types'
+
+const router = useRouter()
+const submitting = ref(false)
+
+const form = reactive<CreateUserPayload>({
+  username: '',
+  display_name: '',
+  password: 'platform123',
+  role: 'viewer',
+  status: 'active',
+  permissions: ['dashboard'],
+})
+
+const permissionOptions: PermissionCode[] = [
+  'dashboard',
+  'fine-tune',
+  'model-eval',
+  'model-inference',
+  'model-manage',
+  'dataset',
+  'data-process',
+  'data-convert',
+  'compute',
+  'hardware',
+  'logs',
+  'user-settings',
+]
+
+async function submit() {
+  submitting.value = true
+  try {
+    await createUser(form)
+    ElMessage.success('用户已创建')
+    router.push('/user-settings')
+  } finally {
+    submitting.value = false
+  }
+}
+</script>
+
+<template>
+  <section class="user-create">
+    <h1>创建用户</h1>
+    <el-form :model="form" label-width="110px" class="user-form">
+      <el-form-item label="账号">
+        <el-input v-model="form.username" />
+      </el-form-item>
+      <el-form-item label="显示名称">
+        <el-input v-model="form.display_name" />
+      </el-form-item>
+      <el-form-item label="初始密码">
+        <el-input v-model="form.password" type="password" show-password />
+      </el-form-item>
+      <el-form-item label="角色">
+        <el-select v-model="form.role">
+          <el-option label="管理员" value="admin" />
+          <el-option label="操作员" value="operator" />
+          <el-option label="观察员" value="viewer" />
+        </el-select>
+      </el-form-item>
+      <el-form-item label="状态">
+        <el-radio-group v-model="form.status">
+          <el-radio value="active">启用</el-radio>
+          <el-radio value="disabled">禁用</el-radio>
+        </el-radio-group>
+      </el-form-item>
+      <el-form-item label="页面权限">
+        <el-checkbox-group v-model="form.permissions">
+          <el-checkbox v-for="item in permissionOptions" :key="item" :value="item">{{ item }}</el-checkbox>
+        </el-checkbox-group>
+      </el-form-item>
+      <el-form-item>
+        <el-button @click="router.back()">返回</el-button>
+        <el-button type="primary" :loading="submitting" @click="submit">保存</el-button>
+      </el-form-item>
+    </el-form>
+  </section>
+</template>
+
+<style scoped>
+.user-create {
+  padding: 24px;
+}
+
+.user-form {
+  max-width: 760px;
+}
+</style>
--- a/frontend/src/views/system/UserPermissionView.vue
+++ b/frontend/src/views/system/UserPermissionView.vue
@@ -0,0 +1,12 @@
+<template>
+  <section class="simple-page">
+    <h1>权限设置</h1>
+    <p>第一版已支持账号页面权限读取与保存，精细化项目/模型/数据集权限将在后续版本补齐。</p>
+  </section>
+</template>
+
+<style scoped>
+.simple-page {
+  padding: 24px;
+}
+</style>
--- a/frontend/src/views/system/UserSettingsView.vue
+++ b/frontend/src/views/system/UserSettingsView.vue
@@ -0,0 +1,65 @@
+<script setup lang="ts">
+import { onMounted, ref } from 'vue'
+import { getUsers } from '@/api/modules/system'
+import type { SystemUser } from '@/types'
+
+const loading = ref(false)
+const users = ref<SystemUser[]>([])
+
+async function loadUsers() {
+  loading.value = true
+  try {
+    users.value = await getUsers()
+  } finally {
+    loading.value = false
+  }
+}
+
+onMounted(loadUsers)
+</script>
+
+<template>
+  <section class="user-settings" v-loading="loading">
+    <header class="page-header">
+      <div>
+        <h1>用户设置</h1>
+        <p>管理平台账号、角色状态和页面权限。</p>
+      </div>
+      <el-button type="primary" @click="$router.push('/user-settings/create')">创建用户</el-button>
+    </header>
+
+    <el-table :data="users">
+      <el-table-column prop="username" label="账号" min-width="140" />
+      <el-table-column prop="display_name" label="显示名称" min-width="160" />
+      <el-table-column prop="role" label="角色" width="120" />
+      <el-table-column prop="status" label="状态" width="120" />
+      <el-table-column label="权限数" width="120">
+        <template #default="{ row }">{{ row.permissions?.length || 0 }}</template>
+      </el-table-column>
+      <el-table-column prop="create_time" label="创建时间" min-width="180" />
+    </el-table>
+  </section>
+</template>
+
+<style scoped>
+.user-settings {
+  padding: 24px;
+}
+
+.page-header {
+  display: flex;
+  justify-content: space-between;
+  gap: 16px;
+  margin-bottom: 18px;
+}
+
+.page-header h1 {
+  margin: 0;
+  font-size: 24px;
+}
+
+.page-header p {
+  margin: 8px 0 0;
+  color: #64748b;
+}
+</style>
--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -22,11 +22,11 @@ export default defineConfig({
    },
  },
  server: {
-    port: 6801,
+    port: 16801,
    proxy: {
-      // 后端服务固定在 7861 端口，前端统一走 /api 相对路径
+      // Frontend uses /api and proxies to the local five-digit backend port.
      '/api': {
-        target: 'http://localhost:7861',
+        target: 'http://localhost:17861',
        changeOrigin: true,
      },
    },