feat: 基于 LLaMA-Factory 实现模型推理引擎

利用容器内已有的 LLaMA-Factory ChatModel (huggingface 后端) 实现真实
模型推理，无需额外安装 vLLM。

Compute 端新增:
- compute/engines/llama_factory/inference.py
  InferenceSession: 模型加载/卸载/对话/流式输出
  支持 base model 和 LoRA adapter，线程安全
- compute/api/main.py 新增 5 个推理端点:
  POST /inference/load      - 加载模型
  POST /inference/unload    - 卸载释放 GPU 显存
  GET  /inference/status    - 查询会话状态
  POST /inference/chat      - 非流式对话
  POST /inference/chat/stream - SSE 流式对话

后端新增:
- platform.py 推理代理端点（local/chat, local/chat/stream,
  local/preload, local/unload, local/status, trained/preload）
- ComputeNodeClient._request 通用请求方法
- _select_first_online_node 自动选择在线节点

Co-Authored-By: Claude <noreply@anthropic.com>

backend/app/api/v1/endpoints/platform.py

@@ -6,7 +6,9 @@ from pathlib import Path
 from typing import Any
 
 from fastapi import APIRouter, BackgroundTasks, Body, File, HTTPException, Query, UploadFile
-from fastapi.responses import PlainTextResponse
+from fastapi.responses import PlainTextResponse, StreamingResponse
+
+import httpx
 
 from app.core.config import get_settings
 from app.db.platform_store import get_platform_store
@@ -20,6 +22,15 @@ def ok(data: Any = None, message: str = "ok") -> dict[str, Any]:
     return {"code": 0, "message": message, "data": data}
 
 
+def _select_first_online_node(store: Any) -> dict[str, Any] | None:
+    """Select the first online compute node for inference."""
+    nodes = store.compute_nodes()
+    for node in nodes:
+        if node.get("enabled") and node.get("scheduler_status") == "online":
+            return node
+    return None
+
+
 def fail(status_code: int, message: str) -> HTTPException:
     return HTTPException(status_code=status_code, detail={"code": status_code, "message": message, "data": None})
 
@@ -1102,17 +1113,99 @@ async def model_chat_batch(payload: dict[str, Any] = Body(...)) -> dict[str, Any
 
 @router.post("/model-chat/local/chat")
 async def model_chat_local(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
-    return ok({"response": "local chat adapter is not connected yet", "request": payload})
+    """Proxy chat to the compute node running the inference model."""
+    store = get_platform_store()
+    node = _select_first_online_node(store)
+    if not node:
+        return ok({"response": "no online compute node available for inference", "request": payload})
+    try:
+        client = ComputeNodeClient(node["api_base_url"])
+        result = await client._request("POST", "/inference/chat", json_data=payload)
+        return ok(result)
+    except Exception as exc:
+        return ok({"response": f"inference failed: {exc}", "request": payload})
+
+
+@router.post("/model-chat/local/chat/stream")
+async def model_chat_local_stream(payload: dict[str, Any] = Body(...)) -> StreamingResponse:
+    """Stream chat from the compute node."""
+    store = get_platform_store()
+    node = _select_first_online_node(store)
+    if not node:
+        return StreamingResponse(
+            iter(['data: {"error": "no online compute node"}\n\n']),
+            media_type="text/event-stream",
+        )
+    client = ComputeNodeClient(node["api_base_url"])
+
+    async def stream_proxy():
+        async with httpx.AsyncClient(timeout=300) as http:
+            url = f"{node['api_base_url'].rstrip('/')}/modelTF/inference/chat/stream"
+            async with http.stream("POST", url, json=payload, headers=client.headers()) as resp:
+                async for chunk in resp.aiter_bytes():
+                    yield chunk
+
+    return StreamingResponse(stream_proxy(), media_type="text/event-stream")
 
 
 @router.post("/model-chat/local/preload")
 async def model_chat_local_preload(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
-    return ok({"loaded": True, "request": payload})
+    """Load a model on the compute node for inference."""
+    store = get_platform_store()
+    node = _select_first_online_node(store)
+    if not node:
+        return ok({"loaded": False, "error": "no online compute node"})
+    try:
+        client = ComputeNodeClient(node["api_base_url"])
+        result = await client._request("POST", "/inference/load", json_data=payload)
+        return ok(result)
+    except Exception as exc:
+        return ok({"loaded": False, "error": str(exc)})
+
+
+@router.post("/model-chat/local/unload")
+async def model_chat_local_unload() -> dict[str, Any]:
+    """Unload the inference model from the compute node."""
+    store = get_platform_store()
+    node = _select_first_online_node(store)
+    if not node:
+        return ok({"unloaded": False, "error": "no online compute node"})
+    try:
+        client = ComputeNodeClient(node["api_base_url"])
+        result = await client._request("POST", "/inference/unload", json_data={})
+        return ok(result)
+    except Exception as exc:
+        return ok({"unloaded": False, "error": str(exc)})
+
+
+@router.get("/model-chat/local/status")
+async def model_chat_local_status() -> dict[str, Any]:
+    """Get inference session status from compute node."""
+    store = get_platform_store()
+    node = _select_first_online_node(store)
+    if not node:
+        return ok({"loaded": False, "error": "no online compute node"})
+    try:
+        client = ComputeNodeClient(node["api_base_url"])
+        result = await client._request("GET", "/inference/status")
+        return ok(result)
+    except Exception as exc:
+        return ok({"loaded": False, "error": str(exc)})
 
 
 @router.post("/model-chat/trained/preload")
 async def model_chat_trained_preload(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
-    return ok({"loaded": True, "request": payload})
+    """Load a trained model (base + adapter) on the compute node for inference."""
+    store = get_platform_store()
+    node = _select_first_online_node(store)
+    if not node:
+        return ok({"loaded": False, "error": "no online compute node"})
+    try:
+        client = ComputeNodeClient(node["api_base_url"])
+        result = await client._request("POST", "/inference/load", json_data=payload)
+        return ok(result)
+    except Exception as exc:
+        return ok({"loaded": False, "error": str(exc)})
 
 
 @router.get("/compute/nodes")

backend/app/modules/compute_gateway/client.py

@@ -182,6 +182,17 @@ class ComputeNodeClient:
             response.raise_for_status()
             return _unwrap_dict(response.json())
 
+    async def _request(self, method: str, path: str, json_data: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Generic request method for compute API endpoints."""
+        url = _join_url(self.api_base_url, f"{self.route_prefix}{path}")
+        async with httpx.AsyncClient(timeout=300, headers=self.headers()) as client:
+            if method.upper() == "GET":
+                response = await client.get(url)
+            else:
+                response = await client.post(url, json=json_data)
+            response.raise_for_status()
+            return _unwrap_dict(response.json())
+
     async def upload_file(
         self,
         filename: str,