From ad71259ba52168ad40507ff70e745e1e925b0071 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=83=91=E9=BE=99=E6=8D=B7?=
<7803802+sh_lelouch@user.noreply.gitee.com>
Date: Wed, 2 Sep 2026 09:54:03 +0800
Subject: [PATCH 1/3] feat: add A-card operations frontend and backend
foundation
---
.env.example | 19 +
CLAUDE.md | 6 +-
backend/Dockerfile | 2 +
backend/README.md | 39 +-
backend/pyproject.toml | 1 +
.../src/backend/api/operations/__init__.py | 10 +
backend/src/backend/api/operations/_deps.py | 139 +
backend/src/backend/api/operations/health.py | 71 +
backend/src/backend/api/operations/models.py | 105 +
backend/src/backend/main.py | 37 +
.../backend/schemas/operations/__init__.py | 15 +
.../src/backend/schemas/operations/models.py | 37 +
.../backend/schemas/operations/monitoring.py | 18 +
.../backend/services/operations/__init__.py | 17 +
.../src/backend/services/operations/cache.py | 112 +
.../backend/services/operations/mock_data.py | 105 +
.../services/operations/model_queries.py | 339 ++
.../backend/services/operations/streams.py | 126 +
backend/tests/test_operations_queries.py | 233 ++
backend/tests/test_operations_redis.py | 110 +
common/src/common/config.py | 55 +
common/src/common/db/__init__.py | 2 +
.../common/db/models/operations/__init__.py | 31 +
.../src/common/db/models/operations/base.py | 40 +
.../common/db/models/operations/governance.py | 155 +
.../src/common/db/models/operations/models.py | 114 +
.../common/db/models/operations/monitoring.py | 182 +
.../common/db/models/operations/reference.py | 64 +
common/src/common/db/session.py | 16 +
docker-compose.yml | 9 +
...模型运维模块-后端架构与数据库设计-V0.2.md | 308 ++
.../A卡模型运维模块-数据域关系-V0.2.png | Bin 0 -> 445855 bytes
.../A卡模型运维模块-数据域关系-V0.2.svg | 331 ++
.../A卡模型运维模块-数据域关系-V0.2.yaml | 71 +
.../A卡模型运维模块-系统架构-V0.2.png | Bin 0 -> 368784 bytes
.../A卡模型运维模块-系统架构-V0.2.svg | 204 +
.../A卡模型运维模块-系统架构-V0.2.yaml | 55 +
docs/architecture/CHANGELOG.md | 19 +
docs/architecture/render_diagrams.py | 148 +
...模型运维模块-后端架构与数据库设计-V0.1.md | 291 ++
.../历史/A卡模型运维模块-数据域关系-V0.1.png | Bin 0 -> 447963 bytes
.../历史/A卡模型运维模块-数据域关系-V0.1.svg | 249 ++
.../历史/A卡模型运维模块-数据域关系-V0.1.yaml | 56 +
.../历史/A卡模型运维模块-系统架构-V0.1.png | Bin 0 -> 306966 bytes
.../历史/A卡模型运维模块-系统架构-V0.1.svg | 206 +
.../历史/A卡模型运维模块-系统架构-V0.1.yaml | 52 +
.../A卡原始监控指标-模型方表评估清单-V0.1.md | 154 +
.../A卡运维平台-功能页面表关系-V0.1.md | 123 +
.../A卡运维数据库-DBA授权申请-V0.1.md | 46 +
docs/database/CHANGELOG.md | 26 +
docs/database/build_full_schema.py | 158 +
.../model_operations-V0.1/00_database.sql | 9 +
.../10_reference_and_models.sql | 127 +
.../20_monitoring_source.sql | 160 +
.../30_governance_and_reviews.sql | 177 +
.../40_reports_and_prompts.sql | 172 +
.../50_workflows_documents_usage.sql | 142 +
.../model_operations-V0.1/60_seed.sql | 21 +
docs/database/model_operations-V0.1/README.md | 55 +
.../model_operations-V0.1/validate_schema.py | 70 +
.../model_operations-完整建表-V0.1.sql | 40 +
.../model_platform-schema-20260831.sql | 544 +++
frontend/.env.example | 6 +
frontend/README.md | 23 +
frontend/app/app.css | 51 +-
frontend/app/components/common/Topbar.tsx | 8 +-
frontend/app/components/ui/table.tsx | 8 +-
.../features/operations/BankOverviewPage.tsx | 162 +
.../features/operations/CategoryCardRail.tsx | 87 +
.../operations/DeployedModelsPage.tsx | 213 +
.../features/operations/KnowledgeBasePage.tsx | 75 +
.../features/operations/ModelOverviewPage.tsx | 167 +
.../operations/MonitoringDetailPage.tsx | 337 ++
.../operations/MonitoringOverviewPage.tsx | 231 ++
.../operations/OperationsDataContext.tsx | 148 +
.../app/features/operations/OperationsUi.tsx | 382 ++
.../operations/OperationsWorkbenchPage.tsx | 225 ++
.../operations/PromptManagementPage.tsx | 65 +
.../app/features/operations/ReportPage.tsx | 176 +
.../features/operations/ReportSummaryPage.tsx | 142 +
.../operations/RuleManagementPage.tsx | 134 +
.../features/operations/SystemConfigPage.tsx | 92 +
.../features/operations/UsageStatsPage.tsx | 69 +
.../app/features/operations/WorkflowPage.tsx | 176 +
.../app/features/operations/governanceData.ts | 101 +
frontend/app/features/operations/modelData.ts | 385 ++
.../app/features/operations/operationsRole.ts | 85 +
.../app/features/operations/reportData.ts | 59 +
.../app/features/operations/reportStore.ts | 19 +
.../app/features/operations/workflowData.ts | 144 +
.../platform/hooks/useEditSessionLifecycle.ts | 2 +-
frontend/app/hooks/use-persistent-state.ts | 24 +
frontend/app/lib/exportExcel.ts | 35 +
frontend/app/routes.ts | 16 +
frontend/app/routes/operations.tsx | 41 +
frontend/app/routes/platform.navigation.tsx | 91 +-
frontend/app/routes/platform.tsx | 88 +-
frontend/app/services/operationsApi.ts | 199 +
frontend/package.json | 1 +
frontend/pnpm-lock.yaml | 53 +-
frontend/vite.config.ts | 49 +-
operations-alembic.ini | 41 +
operations_migrations/README.md | 20 +
operations_migrations/env.py | 93 +
operations_migrations/script.py.mako | 27 +
uv.lock | 3484 +++++++++--------
106 files changed, 12461 insertions(+), 1796 deletions(-)
create mode 100644 backend/src/backend/api/operations/__init__.py
create mode 100644 backend/src/backend/api/operations/_deps.py
create mode 100644 backend/src/backend/api/operations/health.py
create mode 100644 backend/src/backend/api/operations/models.py
create mode 100644 backend/src/backend/schemas/operations/__init__.py
create mode 100644 backend/src/backend/schemas/operations/models.py
create mode 100644 backend/src/backend/schemas/operations/monitoring.py
create mode 100644 backend/src/backend/services/operations/__init__.py
create mode 100644 backend/src/backend/services/operations/cache.py
create mode 100644 backend/src/backend/services/operations/mock_data.py
create mode 100644 backend/src/backend/services/operations/model_queries.py
create mode 100644 backend/src/backend/services/operations/streams.py
create mode 100644 backend/tests/test_operations_queries.py
create mode 100644 backend/tests/test_operations_redis.py
create mode 100644 common/src/common/db/models/operations/__init__.py
create mode 100644 common/src/common/db/models/operations/base.py
create mode 100644 common/src/common/db/models/operations/governance.py
create mode 100644 common/src/common/db/models/operations/models.py
create mode 100644 common/src/common/db/models/operations/monitoring.py
create mode 100644 common/src/common/db/models/operations/reference.py
create mode 100644 docs/architecture/A卡模型运维模块-后端架构与数据库设计-V0.2.md
create mode 100644 docs/architecture/A卡模型运维模块-数据域关系-V0.2.png
create mode 100644 docs/architecture/A卡模型运维模块-数据域关系-V0.2.svg
create mode 100644 docs/architecture/A卡模型运维模块-数据域关系-V0.2.yaml
create mode 100644 docs/architecture/A卡模型运维模块-系统架构-V0.2.png
create mode 100644 docs/architecture/A卡模型运维模块-系统架构-V0.2.svg
create mode 100644 docs/architecture/A卡模型运维模块-系统架构-V0.2.yaml
create mode 100644 docs/architecture/CHANGELOG.md
create mode 100644 docs/architecture/render_diagrams.py
create mode 100644 docs/architecture/历史/A卡模型运维模块-后端架构与数据库设计-V0.1.md
create mode 100644 docs/architecture/历史/A卡模型运维模块-数据域关系-V0.1.png
create mode 100644 docs/architecture/历史/A卡模型运维模块-数据域关系-V0.1.svg
create mode 100644 docs/architecture/历史/A卡模型运维模块-数据域关系-V0.1.yaml
create mode 100644 docs/architecture/历史/A卡模型运维模块-系统架构-V0.1.png
create mode 100644 docs/architecture/历史/A卡模型运维模块-系统架构-V0.1.svg
create mode 100644 docs/architecture/历史/A卡模型运维模块-系统架构-V0.1.yaml
create mode 100644 docs/database/A卡原始监控指标-模型方表评估清单-V0.1.md
create mode 100644 docs/database/A卡运维平台-功能页面表关系-V0.1.md
create mode 100644 docs/database/A卡运维数据库-DBA授权申请-V0.1.md
create mode 100644 docs/database/CHANGELOG.md
create mode 100644 docs/database/build_full_schema.py
create mode 100644 docs/database/model_operations-V0.1/00_database.sql
create mode 100644 docs/database/model_operations-V0.1/10_reference_and_models.sql
create mode 100644 docs/database/model_operations-V0.1/20_monitoring_source.sql
create mode 100644 docs/database/model_operations-V0.1/30_governance_and_reviews.sql
create mode 100644 docs/database/model_operations-V0.1/40_reports_and_prompts.sql
create mode 100644 docs/database/model_operations-V0.1/50_workflows_documents_usage.sql
create mode 100644 docs/database/model_operations-V0.1/60_seed.sql
create mode 100644 docs/database/model_operations-V0.1/README.md
create mode 100644 docs/database/model_operations-V0.1/validate_schema.py
create mode 100644 docs/database/model_operations-完整建表-V0.1.sql
create mode 100644 docs/database/reference/model_platform-schema-20260831.sql
create mode 100644 frontend/.env.example
create mode 100644 frontend/app/features/operations/BankOverviewPage.tsx
create mode 100644 frontend/app/features/operations/CategoryCardRail.tsx
create mode 100644 frontend/app/features/operations/DeployedModelsPage.tsx
create mode 100644 frontend/app/features/operations/KnowledgeBasePage.tsx
create mode 100644 frontend/app/features/operations/ModelOverviewPage.tsx
create mode 100644 frontend/app/features/operations/MonitoringDetailPage.tsx
create mode 100644 frontend/app/features/operations/MonitoringOverviewPage.tsx
create mode 100644 frontend/app/features/operations/OperationsDataContext.tsx
create mode 100644 frontend/app/features/operations/OperationsUi.tsx
create mode 100644 frontend/app/features/operations/OperationsWorkbenchPage.tsx
create mode 100644 frontend/app/features/operations/PromptManagementPage.tsx
create mode 100644 frontend/app/features/operations/ReportPage.tsx
create mode 100644 frontend/app/features/operations/ReportSummaryPage.tsx
create mode 100644 frontend/app/features/operations/RuleManagementPage.tsx
create mode 100644 frontend/app/features/operations/SystemConfigPage.tsx
create mode 100644 frontend/app/features/operations/UsageStatsPage.tsx
create mode 100644 frontend/app/features/operations/WorkflowPage.tsx
create mode 100644 frontend/app/features/operations/governanceData.ts
create mode 100644 frontend/app/features/operations/modelData.ts
create mode 100644 frontend/app/features/operations/operationsRole.ts
create mode 100644 frontend/app/features/operations/reportData.ts
create mode 100644 frontend/app/features/operations/reportStore.ts
create mode 100644 frontend/app/features/operations/workflowData.ts
create mode 100644 frontend/app/hooks/use-persistent-state.ts
create mode 100644 frontend/app/lib/exportExcel.ts
create mode 100644 frontend/app/routes/operations.tsx
create mode 100644 frontend/app/services/operationsApi.ts
create mode 100644 operations-alembic.ini
create mode 100644 operations_migrations/README.md
create mode 100644 operations_migrations/env.py
create mode 100644 operations_migrations/script.py.mako
diff --git a/.env.example b/.env.example
index 7ea6fae..165660e 100644
--- a/.env.example
+++ b/.env.example
@@ -13,8 +13,27 @@ MYSQL_USER=root
MYSQL_PASSWORD=change-me
MYSQL_DATABASE=model_platform
DATABASE_URL=mysql+asyncmy://root:change-me@127.0.0.1:3306/model_platform?charset=utf8mb4
+# 运维模块独立库；省略时后端自动复用 DATABASE_URL 的账号和主机，
+# 仅将数据库名切换为 model_operations。
+OPERATIONS_DATABASE_URL=mysql+asyncmy://root:change-me@127.0.0.1:3306/model_operations?charset=utf8mb4
+# 运维模块访问另外两库时使用专用只读 Session；生产建议配置 DBA
+# 创建的只读账号，不要复用 root。
+PLATFORM_READ_DATABASE_URL=mysql+asyncmy://readonly:change-me@127.0.0.1:3306/model_platform?charset=utf8mb4
+DEPLOY_DATABASE_URL=mysql+asyncmy://readonly:change-me@127.0.0.1:3306/model_deploy?charset=utf8mb4
+
+# Redis is an optional accelerator: cache + Streams only. MySQL Outbox remains
+# the reliable source of truth when Redis is unavailable.
+REDIS_URL=redis://127.0.0.1:6379/0
+OPERATIONS_CACHE_TTL_SECONDS=300
+OPERATIONS_REDIS_PREFIX=model-platform:operations
+OPERATIONS_EVENT_STREAM=model-platform:operations:events
+OPERATIONS_EVENT_STREAM_MAXLEN=10000
+OPERATIONS_DATA_MODE=database
JWT_SECRET=change-this-development-secret
+# AES-256 configuration decryption key used only when a value is wrapped in ENC(...).
+# Replace before deployment; keep the same value across all four services.
+APP_CONFIG_SECRET_KEY=change-this-config-secret-key
# Force the Secure flag on the session cookie even when the inbound request
# scheme is plain HTTP. Enable behind a TLS-terminating reverse proxy that
diff --git a/CLAUDE.md b/CLAUDE.md
index d106ebb..2b5069c 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -10,7 +10,9 @@
- `migrations` — Alembic schema + seed migrations.
- `nginx` — static frontend, `/api/` proxy, authenticated `/jupyter/` proxy.
-Redis and the former separate Storage API container are intentionally removed.
+Redis is reintroduced only for the A-card operations query cache and event
+Streams. MySQL Outbox remains authoritative, and Redis outages must not block
+core APIs. The former separate Storage API container remains removed.
## Commands
@@ -135,4 +137,4 @@ Lessons from splitting `frontend/app/features/schedules/state/schedulesStore.ts`
- **前端 — 页面 vs 路由 wrapper**:Page 组件持有 useState,route 文件只做 `` 重挂载,二者不要混在一起。
- **拆分前先列调用面**(`grep "from "`),任何外部 import 路径必须仍然可用 — 用 re-export 或 shim 兜底,不要让调用方被迫改。
- **拆分后**每个新文件 ≤ 500 行是硬约束,验证方式:`wc -l ` 或 CI 脚本。
-- 拆分本身是**纯结构调整**,endpoint 行为 / URL / 响应 schema 零变化 — 不要顺手"清理"。
\ No newline at end of file
+- 拆分本身是**纯结构调整**,endpoint 行为 / URL / 响应 schema 零变化 — 不要顺手"清理"。
diff --git a/backend/Dockerfile b/backend/Dockerfile
index 85b5977..7299145 100644
--- a/backend/Dockerfile
+++ b/backend/Dockerfile
@@ -14,6 +14,8 @@ COPY common ./common
COPY backend ./backend
COPY alembic.ini ./
COPY migrations ./migrations
+COPY operations-alembic.ini ./
+COPY operations_migrations ./operations_migrations
RUN uv sync --frozen --no-dev --package backend
diff --git a/backend/README.md b/backend/README.md
index 5e943a5..f75347c 100644
--- a/backend/README.md
+++ b/backend/README.md
@@ -5,4 +5,41 @@
模块合并，外部 REST 契约保持不变。
底层走的是 `common.storage.AsyncStorageBackend` 抽象，按
-`settings.storage_backend` 切换 s3 / local 两种实现。
\ No newline at end of file
+`settings.storage_backend` 切换 s3 / local 两种实现。
+
+## A 卡模型运维模块
+
+运维能力作为同一 FastAPI 进程内的独立 bounded context 接入：
+
+- 平台库继续使用 `DATABASE_URL`，负责登录、角色和工作空间校验。
+- 运维库使用 `OPERATIONS_DATABASE_URL`；未配置时自动复用平台库连接信息，
+ 仅将库名切换为 `model_operations`。
+- `PLATFORM_READ_DATABASE_URL` 与 `DEPLOY_DATABASE_URL` 使用独立只读
+ Session；MySQL 事务会显式执行 `SET TRANSACTION READ ONLY`。
+- 两套 SQLAlchemy engine/session factory 完全分离，运维路由只读写 `ops_*`。
+- 当前已落地 P0 ORM，以及模型列表、模型详情、指定月份监控结果三条接口。
+- `OPERATIONS_DATA_MODE=mock` 时仍走真实鉴权、Workspace校验和API响应，
+ 仅将业务查询替换为后端Mock数据；切换为 `database` 后读取运维库。
+- Redis作为可选加速层接入：缓存聚合查询并承载通知 Streams；MySQL
+ Outbox仍是可靠事实源，Redis不可用时主接口继续运行。
+
+本地启动：
+
+```bash
+uv run --package backend --env-file .env uvicorn backend.main:app \
+ --host 0.0.0.0 --port 8010 --reload
+```
+
+运维模块探针：
+
+```text
+GET /api/v1/operations/health
+```
+
+真实业务接口均需登录 Cookie 和 `workspace_id` 查询参数：
+
+```text
+GET /api/v1/operations/models?workspace_id=
+GET /api/v1/operations/models/{model_id}?workspace_id=
+GET /api/v1/operations/models/{model_id}/monitor-results?month=YYYY-MM&workspace_id=
+```
diff --git a/backend/pyproject.toml b/backend/pyproject.toml
index 7ae9d3a..482c432 100644
--- a/backend/pyproject.toml
+++ b/backend/pyproject.toml
@@ -15,6 +15,7 @@ dependencies = [
"bcrypt>=4.0,<4.1",
"loguru>=0.7.2",
"aiofiles>=25.1.0",
+ "redis[hiredis]>=6.2,<7",
]
[tool.uv.sources]
diff --git a/backend/src/backend/api/operations/__init__.py b/backend/src/backend/api/operations/__init__.py
new file mode 100644
index 0000000..b152e3f
--- /dev/null
+++ b/backend/src/backend/api/operations/__init__.py
@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+from backend.api.operations.health import router as health_router
+from backend.api.operations.models import router as models_router
+
+router = APIRouter(prefix="/api/v1/operations", tags=["operations"])
+router.include_router(health_router)
+router.include_router(models_router)
+
+__all__ = ["router"]
diff --git a/backend/src/backend/api/operations/_deps.py b/backend/src/backend/api/operations/_deps.py
new file mode 100644
index 0000000..64f42cb
--- /dev/null
+++ b/backend/src/backend/api/operations/_deps.py
@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from typing import Literal
+
+from common.config import settings
+from common.db import readonly_session_scope, session_scope
+from common.db.models import Roles
+from fastapi import Depends, HTTPException, Request, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.api.dependencies import RequestContext, request_context
+from backend.services.operations import OperationsCache, OperationsEventStream
+
+OperationsRole = Literal["admin", "model_team", "business_team"]
+
+_ROLE_ALIASES: dict[str, OperationsRole] = {
+ "admin": "admin",
+ "administrator": "admin",
+ "developer": "model_team",
+ "model_team": "model_team",
+ "model": "model_team",
+ "business": "business_team",
+ "business_team": "business_team",
+ "biz": "business_team",
+}
+
+
+@dataclass(frozen=True)
+class OperationsContext:
+ request_id: str
+ user_id: str
+ workspace_id: str
+ role: OperationsRole
+
+ @property
+ def is_admin(self) -> bool:
+ return self.role == "admin"
+
+
+async def operations_database_session(
+ request: Request,
+) -> AsyncIterator[AsyncSession]:
+ factory = getattr(request.app.state, "operations_session_factory", None)
+ if factory is None:
+ raise HTTPException(
+ status.HTTP_503_SERVICE_UNAVAILABLE,
+ {"code": "OPERATIONS_DATABASE_UNAVAILABLE", "message": "运维数据库未初始化"},
+ )
+ async with session_scope(factory) as session:
+ yield session
+
+
+async def operations_platform_database_session(
+ request: Request,
+) -> AsyncIterator[AsyncSession]:
+ factory = getattr(
+ request.app.state,
+ "operations_platform_read_session_factory",
+ None,
+ )
+ if factory is None:
+ raise HTTPException(
+ status.HTTP_503_SERVICE_UNAVAILABLE,
+ {"code": "PLATFORM_DATABASE_UNAVAILABLE", "message": "平台只读库未初始化"},
+ )
+ async with readonly_session_scope(factory) as session:
+ yield session
+
+
+async def deploy_database_session(
+ request: Request,
+) -> AsyncIterator[AsyncSession]:
+ factory = getattr(request.app.state, "deploy_read_session_factory", None)
+ if factory is None:
+ raise HTTPException(
+ status.HTTP_503_SERVICE_UNAVAILABLE,
+ {"code": "DEPLOY_DATABASE_UNAVAILABLE", "message": "部署只读库未初始化"},
+ )
+ async with readonly_session_scope(factory) as session:
+ yield session
+
+
+def operations_cache(request: Request) -> OperationsCache:
+ return OperationsCache(
+ getattr(request.app.state, "operations_redis", None),
+ prefix=settings.operations_redis_prefix,
+ default_ttl_seconds=settings.operations_cache_ttl_seconds,
+ )
+
+
+def operations_event_stream(request: Request) -> OperationsEventStream:
+ return OperationsEventStream(
+ getattr(request.app.state, "operations_redis", None),
+ stream_name=settings.operations_event_stream,
+ maxlen=settings.operations_event_stream_maxlen,
+ )
+
+
+async def operations_context(
+ context: RequestContext = Depends(request_context),
+ platform_session: AsyncSession = Depends(operations_platform_database_session),
+) -> OperationsContext:
+ """Reuse login/workspace checks and normalize the three operations roles."""
+ raw_role = context.role.role_code
+ if context.is_system_admin:
+ raw_role = "admin"
+ elif context.user.platform_role_id:
+ platform_role = await platform_session.get(Roles, context.user.platform_role_id)
+ if platform_role is not None:
+ raw_role = platform_role.role_code
+
+ normalized = _ROLE_ALIASES.get(raw_role)
+ if normalized is None:
+ raise HTTPException(
+ status.HTTP_403_FORBIDDEN,
+ {
+ "code": "OPERATIONS_ROLE_UNSUPPORTED",
+ "message": f"当前登录角色不支持运维模块：{raw_role}",
+ },
+ )
+ return OperationsContext(
+ request_id=context.request_id,
+ user_id=context.user.user_id,
+ workspace_id=context.workspace.workspace_id,
+ role=normalized,
+ )
+
+
+__all__ = [
+ "OperationsContext",
+ "deploy_database_session",
+ "operations_cache",
+ "operations_context",
+ "operations_database_session",
+ "operations_event_stream",
+ "operations_platform_database_session",
+]
diff --git a/backend/src/backend/api/operations/health.py b/backend/src/backend/api/operations/health.py
new file mode 100644
index 0000000..f149bda
--- /dev/null
+++ b/backend/src/backend/api/operations/health.py
@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Request, Response, status
+from sqlalchemy import text
+
+from common.db import readonly_session_scope, session_scope
+
+router = APIRouter()
+
+
+@router.get("/health")
+async def operations_health(
+ request: Request,
+ response: Response,
+) -> dict[str, Any]:
+ checks: dict[str, dict[str, str]] = {}
+ targets = (
+ ("model_operations", "operations_session_factory", False),
+ ("model_platform", "operations_platform_read_session_factory", True),
+ ("model_deploy", "deploy_read_session_factory", True),
+ )
+ for database_name, factory_name, read_only in targets:
+ factory = getattr(request.app.state, factory_name, None)
+ if factory is None:
+ checks[database_name] = {"status": "error", "mode": "unavailable"}
+ continue
+ scope = readonly_session_scope if read_only else session_scope
+ try:
+ async with scope(factory) as session:
+ current_database = await session.scalar(text("SELECT DATABASE()"))
+ checks[database_name] = {
+ "status": "ok" if current_database == database_name else "error",
+ "mode": "read_only" if read_only else "read_write",
+ }
+ except Exception:
+ checks[database_name] = {
+ "status": "error",
+ "mode": "read_only" if read_only else "read_write",
+ }
+ ready = all(item["status"] == "ok" for item in checks.values())
+ if not ready:
+ response.status_code = status.HTTP_503_SERVICE_UNAVAILABLE
+ redis_client = getattr(request.app.state, "operations_redis", None)
+ if redis_client is None:
+ redis_check = {"status": "disabled", "mode": "cache_and_streams"}
+ else:
+ try:
+ pong = await redis_client.ping()
+ redis_check = {
+ "status": "ok" if pong else "error",
+ "mode": "cache_and_streams",
+ }
+ except Exception:
+ redis_check = {"status": "error", "mode": "cache_and_streams"}
+ module_status = "ok" if ready and redis_check["status"] == "ok" else (
+ "degraded" if ready else "not_ready"
+ )
+ return {
+ "data": {
+ "status": module_status,
+ "module": "model_operations",
+ "databases": checks,
+ "redis": redis_check,
+ },
+ "meta": {},
+ }
+
+
+__all__ = ["router"]
diff --git a/backend/src/backend/api/operations/models.py b/backend/src/backend/api/operations/models.py
new file mode 100644
index 0000000..61a720a
--- /dev/null
+++ b/backend/src/backend/api/operations/models.py
@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.api.operations._deps import (
+ OperationsContext,
+ operations_context,
+ operations_database_session,
+)
+from backend.schemas.operations import ModelCategoryCode, ModelStatusLabel
+from backend.services.operations import (
+ get_model,
+ get_monthly_monitoring_result,
+ list_models,
+ parse_monitor_month,
+)
+from backend.services.operations.mock_data import (
+ get_mock_model,
+ get_mock_monthly_result,
+ list_mock_models,
+)
+from common.config import settings
+
+router = APIRouter()
+
+
+def _envelope(context: OperationsContext, data: Any) -> dict[str, Any]:
+ return {"request_id": context.request_id, "data": data, "meta": {}}
+
+
+@router.get("/models")
+async def list_operation_models(
+ bank: str | None = Query(default=None, max_length=150),
+ category: ModelCategoryCode | None = Query(default=None),
+ model_status: ModelStatusLabel | None = Query(default=None, alias="status"),
+ keyword: str | None = Query(default=None, max_length=200),
+ context: OperationsContext = Depends(operations_context),
+ session: AsyncSession = Depends(operations_database_session),
+) -> dict[str, Any]:
+ models = list_mock_models(
+ bank=bank,
+ category=category,
+ status=model_status,
+ keyword=keyword,
+ ) if settings.operations_data_mode == "mock" else await list_models(
+ session,
+ context.workspace_id,
+ bank=bank,
+ category=category,
+ status=model_status,
+ keyword=keyword,
+ )
+ return _envelope(context, models)
+
+
+@router.get("/models/{model_id}")
+async def get_operation_model(
+ model_id: str,
+ context: OperationsContext = Depends(operations_context),
+ session: AsyncSession = Depends(operations_database_session),
+) -> dict[str, Any]:
+ model = get_mock_model(model_id) if settings.operations_data_mode == "mock" else await get_model(session, context.workspace_id, model_id)
+ if model is None:
+ raise HTTPException(
+ status.HTTP_404_NOT_FOUND,
+ {"code": "MODEL_NOT_FOUND", "message": "模型不存在"},
+ )
+ return _envelope(context, model)
+
+
+@router.get("/models/{model_id}/monitor-results")
+async def get_operation_model_monitor_result(
+ model_id: str,
+ month: str = Query(..., pattern=r"^\d{4}-\d{2}$"),
+ context: OperationsContext = Depends(operations_context),
+ session: AsyncSession = Depends(operations_database_session),
+) -> dict[str, Any]:
+ try:
+ monitor_month = parse_monitor_month(month)
+ except ValueError as exc:
+ raise HTTPException(
+ status.HTTP_422_UNPROCESSABLE_ENTITY,
+ {"code": "INVALID_MONITOR_MONTH", "message": str(exc)},
+ ) from exc
+ result = get_mock_monthly_result(model_id, month) if settings.operations_data_mode == "mock" else await get_monthly_monitoring_result(
+ session,
+ context.workspace_id,
+ model_id,
+ monitor_month,
+ )
+ if result is None:
+ raise HTTPException(
+ status.HTTP_404_NOT_FOUND,
+ {
+ "code": "MONITOR_RESULT_NOT_FOUND",
+ "message": "该月份暂无监控结果",
+ },
+ )
+ return _envelope(context, result)
+
+
+__all__ = ["router"]
diff --git a/backend/src/backend/main.py b/backend/src/backend/main.py
index cd8eab5..9b45c2b 100644
--- a/backend/src/backend/main.py
+++ b/backend/src/backend/main.py
@@ -32,10 +32,12 @@ from common.storage import (
from fastapi import Request
from fastapi.responses import JSONResponse
from loguru import logger
+from redis.asyncio import Redis
from backend.api.admin import router as admin_router
from backend.api.auth import router as auth_router
from backend.api.jupyter import router as jupyter_router
+from backend.api.operations import router as operations_router
from backend.api.platform import router as platform_router
from backend.api.resources import router as resources_router
from backend.api.schedules.runs import router as schedule_runs_router
@@ -65,6 +67,35 @@ async def lifespan(app: Any) -> AsyncIterator[None]:
# 取得它们；这样每个请求不会重复创建数据库连接或 HTTP 客户端。
engine = create_database_engine(settings.database_url)
app.state.session_factory = create_session_factory(engine)
+ operations_database_url = settings.operations_database_url
+ if not operations_database_url:
+ raise RuntimeError("OPERATIONS_DATABASE_URL could not be resolved")
+ operations_engine = create_database_engine(operations_database_url)
+ app.state.operations_session_factory = create_session_factory(operations_engine)
+ platform_read_database_url = settings.platform_read_database_url
+ deploy_database_url = settings.deploy_database_url
+ if not platform_read_database_url or not deploy_database_url:
+ raise RuntimeError("operations read-only database URLs could not be resolved")
+ platform_read_engine = create_database_engine(platform_read_database_url)
+ deploy_read_engine = create_database_engine(deploy_database_url)
+ app.state.operations_platform_read_session_factory = create_session_factory(
+ platform_read_engine
+ )
+ app.state.deploy_read_session_factory = create_session_factory(deploy_read_engine)
+
+ # Redis only accelerates operations reads and event delivery. It is kept
+ # optional so a cache outage never prevents MySQL-backed APIs from booting.
+ operations_redis: Redis | None = None
+ if settings.redis_url:
+ operations_redis = Redis.from_url(
+ settings.redis_url,
+ decode_responses=True,
+ socket_connect_timeout=settings.redis_socket_connect_timeout_seconds,
+ socket_timeout=settings.redis_socket_timeout_seconds,
+ health_check_interval=30,
+ retry_on_timeout=True,
+ )
+ app.state.operations_redis = operations_redis
# 存储接口与业务路由运行在同一个 backend 进程中，因此直接复用存储对象，
# 不需要再通过 HTTP 调用自己。字典键使用真实桶名，便于上传会话和存储
@@ -94,8 +125,13 @@ async def lifespan(app: Any) -> AsyncIterator[None]:
try:
yield
finally:
+ if operations_redis is not None:
+ await operations_redis.aclose()
await rclone_http_client.aclose()
await runtime_http_client.aclose()
+ await deploy_read_engine.dispose()
+ await platform_read_engine.dispose()
+ await operations_engine.dispose()
await engine.dispose()
@@ -112,6 +148,7 @@ app.include_router(schedules_router)
app.include_router(scripts_router)
app.include_router(admin_router)
app.include_router(platform_router)
+app.include_router(operations_router)
# 内部存储接口额外加上 /internal 前缀，供后端服务间调用，不作为普通前端 API。
app.include_router(storage_api_router, prefix="/internal")
diff --git a/backend/src/backend/schemas/operations/__init__.py b/backend/src/backend/schemas/operations/__init__.py
new file mode 100644
index 0000000..aed7282
--- /dev/null
+++ b/backend/src/backend/schemas/operations/__init__.py
@@ -0,0 +1,15 @@
+from backend.schemas.operations.models import (
+ ModelCategoryCode,
+ ModelStatusLabel,
+ OperationsModelDto,
+ RankingStatusLabel,
+)
+from backend.schemas.operations.monitoring import MonthlyMonitoringResultDto
+
+__all__ = [
+ "ModelCategoryCode",
+ "ModelStatusLabel",
+ "MonthlyMonitoringResultDto",
+ "OperationsModelDto",
+ "RankingStatusLabel",
+]
diff --git a/backend/src/backend/schemas/operations/models.py b/backend/src/backend/schemas/operations/models.py
new file mode 100644
index 0000000..a9f33c4
--- /dev/null
+++ b/backend/src/backend/schemas/operations/models.py
@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from common.schemas import StrictModel
+
+ModelCategoryCode = Literal["std", "bai", "big", "afd"]
+ModelStatusLabel = Literal["正常", "陪跑", "陪跑结束", "下线"]
+RankingStatusLabel = Literal["相符", "不符", "—"]
+
+
+class OperationsModelDto(StrictModel):
+ model_instance_id: str
+ bank_name: str
+ model_category: ModelCategoryCode
+ model_name: str
+ model_id: str
+ model_version: str
+ model_status: ModelStatusLabel
+ last_iteration_date: str
+ ranking_result: RankingStatusLabel
+ ks: float
+ psi: float
+ ks_mom_drop: float
+ secondary_hits_6m: int
+ is_wuji_bank: bool
+ last_processed_at: str | None
+ previous_advice: str
+ common_model_name: str | None
+
+
+__all__ = [
+ "ModelCategoryCode",
+ "ModelStatusLabel",
+ "OperationsModelDto",
+ "RankingStatusLabel",
+]
diff --git a/backend/src/backend/schemas/operations/monitoring.py b/backend/src/backend/schemas/operations/monitoring.py
new file mode 100644
index 0000000..5cb5e5e
--- /dev/null
+++ b/backend/src/backend/schemas/operations/monitoring.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from common.schemas import StrictModel
+
+from backend.schemas.operations.models import RankingStatusLabel
+
+
+class MonthlyMonitoringResultDto(StrictModel):
+ model_instance_id: str
+ monitor_month: str
+ ranking_result: RankingStatusLabel
+ ks: float
+ psi: float
+ ks_mom_drop: float
+ secondary_hits_6m: int
+
+
+__all__ = ["MonthlyMonitoringResultDto"]
diff --git a/backend/src/backend/services/operations/__init__.py b/backend/src/backend/services/operations/__init__.py
new file mode 100644
index 0000000..e5338f6
--- /dev/null
+++ b/backend/src/backend/services/operations/__init__.py
@@ -0,0 +1,17 @@
+from backend.services.operations.cache import OperationsCache
+from backend.services.operations.model_queries import (
+ get_model,
+ get_monthly_monitoring_result,
+ list_models,
+ parse_monitor_month,
+)
+from backend.services.operations.streams import OperationsEventStream
+
+__all__ = [
+ "OperationsCache",
+ "OperationsEventStream",
+ "get_model",
+ "get_monthly_monitoring_result",
+ "list_models",
+ "parse_monitor_month",
+]
diff --git a/backend/src/backend/services/operations/cache.py b/backend/src/backend/services/operations/cache.py
new file mode 100644
index 0000000..33296a0
--- /dev/null
+++ b/backend/src/backend/services/operations/cache.py
@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping
+from typing import Any
+
+from loguru import logger
+from redis.asyncio import Redis
+from redis.exceptions import RedisError
+
+
+class OperationsCache:
+ """Best-effort JSON cache; every failure degrades to a cache miss."""
+
+ def __init__(
+ self,
+ client: Redis | None,
+ *,
+ prefix: str,
+ default_ttl_seconds: int,
+ ) -> None:
+ self._client = client
+ self._prefix = prefix.rstrip(":")
+ self._default_ttl_seconds = default_ttl_seconds
+
+ def build_key(
+ self,
+ workspace_id: str,
+ resource: str,
+ params: Mapping[str, Any] | None = None,
+ ) -> str:
+ canonical = json.dumps(
+ dict(params or {}),
+ ensure_ascii=False,
+ sort_keys=True,
+ separators=(",", ":"),
+ default=str,
+ )
+ digest = hashlib.sha256(canonical.encode("utf-8")).hexdigest()[:20]
+ safe_resource = resource.strip(":").replace(" ", "-")
+ return f"{self._prefix}:cache:{workspace_id}:{safe_resource}:{digest}"
+
+ async def get_json(self, key: str) -> Any | None:
+ if self._client is None:
+ return None
+ try:
+ value = await self._client.get(key)
+ return json.loads(value) if value is not None else None
+ except (RedisError, ValueError, TypeError) as exc:
+ logger.warning("operations cache get failed for {key}: {error}", key=key, error=exc)
+ return None
+
+ async def set_json(
+ self,
+ key: str,
+ value: Any,
+ *,
+ ttl_seconds: int | None = None,
+ ) -> bool:
+ if self._client is None:
+ return False
+ try:
+ payload = json.dumps(
+ value,
+ ensure_ascii=False,
+ separators=(",", ":"),
+ default=str,
+ )
+ await self._client.set(
+ key,
+ payload,
+ ex=ttl_seconds or self._default_ttl_seconds,
+ )
+ return True
+ except (RedisError, TypeError, ValueError) as exc:
+ logger.warning("operations cache set failed for {key}: {error}", key=key, error=exc)
+ return False
+
+ async def delete(self, *keys: str) -> int:
+ if self._client is None or not keys:
+ return 0
+ try:
+ return int(await self._client.unlink(*keys))
+ except RedisError as exc:
+ logger.warning("operations cache delete failed: {error}", error=exc)
+ return 0
+
+ async def invalidate_resource(self, workspace_id: str, resource: str) -> int:
+ if self._client is None:
+ return 0
+ pattern = (
+ f"{self._prefix}:cache:{workspace_id}:"
+ f"{resource.strip(':').replace(' ', '-')}:*"
+ )
+ removed = 0
+ try:
+ batch: list[str] = []
+ async for key in self._client.scan_iter(match=pattern, count=200):
+ batch.append(key)
+ if len(batch) >= 200:
+ removed += int(await self._client.unlink(*batch))
+ batch.clear()
+ if batch:
+ removed += int(await self._client.unlink(*batch))
+ return removed
+ except RedisError as exc:
+ logger.warning("operations cache invalidation failed: {error}", error=exc)
+ return removed
+
+
+__all__ = ["OperationsCache"]
diff --git a/backend/src/backend/services/operations/mock_data.py b/backend/src/backend/services/operations/mock_data.py
new file mode 100644
index 0000000..87b2ff2
--- /dev/null
+++ b/backend/src/backend/services/operations/mock_data.py
@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import datetime
+
+from backend.schemas.operations import MonthlyMonitoringResultDto, OperationsModelDto
+
+_MODEL_SPECS = [
+ ("江城银行", "std", "标准A卡", "JC-STD-001", "v2.3", "正常", "2026-06-18", "不符", 36.84, 27.40, 24.10, 3, True, "2026-06-18", "建议启动模型微调或重构评估", "标准A卡通用版 v2.3"),
+ ("滨海银行", "std", "标准A卡", "BH-STD-001", "v2.3", "陪跑", "2026-07-28", "相符", 44.10, 6.20, 3.40, 0, False, "2026-06-03", "维持现状，继续监控", "标准A卡通用版 v2.3"),
+ ("华东银行", "std", "标准A卡", "HD-STD-001", "v2.2", "正常", "2026-03-20", "相符", 43.50, 8.80, 6.10, 0, False, "2026-05-20", "维持现状，继续监控", "标准A卡通用版 v2.3"),
+ ("南岭银行", "std", "标准A卡", "NL-STD-001", "v1.6", "正常", "2025-08-22", "相符", 41.12, 13.60, 22.50, 1, False, "2026-06-12", "建议重点关注 PSI 与 KS 环比变化", "标准A卡通用版 v2.3"),
+ ("云岭银行", "std", "标准A卡", "YL-STD-001", "v2.1", "正常", "2026-01-09", "相符", 45.80, 5.10, 2.20, 0, False, "2026-04-28", "维持现状，继续监控", "标准A卡通用版 v2.3"),
+ ("通汇银行", "std", "标准A卡", "TH-STD-001", "v2.0", "正常", "2025-11-30", "不符", 38.73, 9.40, 11.80, 4, False, "2026-05-16", "建议开展模型微调可行性评估", "标准A卡通用版 v2.3"),
+ ("北岸银行", "std", "标准A卡", "BA-STD-001", "v1.9", "下线", "2024-12-11", "—", 0.00, 0.00, 0.00, 0, False, "2026-03-02", "模型已下线，不再参与月度监控", None),
+ ("江城银行", "big", "大额A卡", "JC-BIG-001", "v1.4", "正常", "2026-07-03", "相符", 46.30, 4.80, 1.50, 0, False, "2026-06-24", "维持现状，继续监控", "大额A卡通用版 v1.4"),
+ ("华东银行", "big", "大额A卡", "HD-BIG-001", "v1.3", "正常", "2026-04-16", "相符", 44.90, 7.30, 4.90, 0, False, "2026-05-30", "维持现状，继续监控", "大额A卡通用版 v1.4"),
+ ("云岭银行", "big", "大额A卡", "YL-BIG-001", "v1.2", "陪跑结束", "2026-08-05", "相符", 42.70, 9.60, 8.20, 0, False, None, "暂无历史处理建议", "大额A卡通用版 v1.4"),
+ ("滨海银行", "big", "大额A卡", "BH-BIG-001", "v1.1", "正常", "2025-09-25", "相符", 39.40, 11.20, 9.70, 2, False, "2026-04-19", "建议持续跟踪，下期复核", "大额A卡通用版 v1.4"),
+ ("南岭银行", "bai", "白户A卡", "NL-BAI-001", "v1.5", "正常", "2026-05-22", "不符", 34.20, 18.70, 15.30, 2, True, "2026-06-09", "建议启动模型微调或重构评估", None),
+ ("通汇银行", "bai", "白户A卡", "TH-BAI-001", "v1.4", "正常", "2026-02-11", "相符", 37.60, 12.10, 7.40, 1, False, "2026-05-11", "建议重点关注并持续跟踪", "白户A卡通用版 v1.4"),
+ ("江城银行", "bai", "白户A卡", "JC-BAI-001", "v1.3", "正常", "2025-12-05", "相符", 40.80, 9.90, 5.60, 0, False, "2026-03-26", "维持现状，继续监控", "白户A卡通用版 v1.4"),
+ ("华东银行", "afd", "反欺诈评分", "HD-AFD-001", "v2.0", "正常", "2026-04-10", "不符", 28.60, 31.50, 18.90, 3, False, "2026-06-21", "建议启动模型微调或重构评估", None),
+ ("滨海银行", "afd", "反欺诈评分", "BH-AFD-001", "v1.8", "正常", "2025-10-30", "相符", 36.40, 8.10, 4.20, 3, True, "2026-05-25", "建议重点关注并持续跟踪", "反欺诈评分通用版 v1.8"),
+ ("云岭银行", "afd", "反欺诈评分", "YL-AFD-001", "v1.7", "正常", "2025-08-19", "相符", 38.20, 14.60, 12.70, 2, False, "2026-04-15", "建议持续跟踪，下期复核", None),
+]
+
+
+def _model(spec: tuple[object, ...]) -> OperationsModelDto:
+ bank, category, name, model_id, version, model_status, iteration_date, ranking, ks, psi, drop, hits, wuji, processed, advice, common = spec
+ return OperationsModelDto(
+ model_instance_id=f"mock-{model_id}",
+ bank_name=str(bank),
+ model_category=category, # type: ignore[arg-type]
+ model_name=str(name),
+ model_id=str(model_id),
+ model_version=str(version),
+ model_status=model_status, # type: ignore[arg-type]
+ last_iteration_date=str(iteration_date),
+ ranking_result=ranking, # type: ignore[arg-type]
+ ks=float(ks),
+ psi=float(psi),
+ ks_mom_drop=float(drop),
+ secondary_hits_6m=int(hits),
+ is_wuji_bank=bool(wuji),
+ last_processed_at=processed,
+ previous_advice=str(advice),
+ common_model_name=common,
+ )
+
+
+MOCK_MODELS = tuple(_model(spec) for spec in _MODEL_SPECS)
+_MODEL_BY_ID = {model.model_id: model for model in MOCK_MODELS}
+
+
+def list_mock_models(
+ *,
+ bank: str | None = None,
+ category: str | None = None,
+ status: str | None = None,
+ keyword: str | None = None,
+) -> list[OperationsModelDto]:
+ term = keyword.strip().lower() if keyword else ""
+ return [
+ model.model_copy()
+ for model in MOCK_MODELS
+ if not bank or model.bank_name == bank
+ if not category or model.model_category == category
+ if not status or model.model_status == status
+ if not term or term in " ".join((model.bank_name, model.model_name, model.model_id, model.model_version)).lower()
+ ]
+
+
+def get_mock_model(model_id: str) -> OperationsModelDto | None:
+ model = _MODEL_BY_ID.get(model_id)
+ return model.model_copy() if model else None
+
+
+def get_mock_monthly_result(model_id: str, month: str) -> MonthlyMonitoringResultDto | None:
+ model = _MODEL_BY_ID.get(model_id)
+ if model is None:
+ return None
+ if model.model_status == "下线" and month != "2026-02":
+ return None
+ try:
+ index = max(0, min(5, (datetime.date.fromisoformat(f"{month}-01").year - 2026) * 12 + datetime.date.fromisoformat(f"{month}-01").month - 2))
+ except ValueError:
+ return None
+ distance = 5 - index
+ return MonthlyMonitoringResultDto(
+ model_instance_id=model.model_instance_id,
+ monitor_month=month,
+ ranking_result=model.ranking_result,
+ ks=round(max(0, model.ks - distance * 0.32), 2),
+ psi=round(max(0, model.psi - distance * 0.74), 2),
+ ks_mom_drop=round(max(0, model.ks_mom_drop - distance * 0.9), 2),
+ secondary_hits_6m=max(0, model.secondary_hits_6m - distance),
+ )
+
+
+__all__ = [
+ "MOCK_MODELS",
+ "get_mock_model",
+ "get_mock_monthly_result",
+ "list_mock_models",
+]
diff --git a/backend/src/backend/services/operations/model_queries.py b/backend/src/backend/services/operations/model_queries.py
new file mode 100644
index 0000000..2cf46cc
--- /dev/null
+++ b/backend/src/backend/services/operations/model_queries.py
@@ -0,0 +1,339 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from decimal import Decimal
+from typing import Any
+
+from common.db.models.operations import (
+ OpsBank,
+ OpsModelInstance,
+ OpsModelVersion,
+ OpsMonitorBatch,
+ OpsMonitorEvaluation,
+ OpsMonitorResult,
+ OpsMonitorReview,
+)
+from sqlalchemy import Select, and_, func, or_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.schemas.operations import (
+ MonthlyMonitoringResultDto,
+ OperationsModelDto,
+)
+
+_MODEL_STATUS_TO_API = {
+ "normal": "正常",
+ "escort": "陪跑",
+ "escort_finished": "陪跑结束",
+ "offline": "下线",
+}
+_MODEL_STATUS_TO_DB = {value: key for key, value in _MODEL_STATUS_TO_API.items()}
+_RANKING_TO_API = {
+ "matched": "相符",
+ "unmatched": "不符",
+ "not_applicable": "—",
+ None: "—",
+}
+
+
+def parse_monitor_month(value: str) -> datetime.date:
+ """Parse the API's YYYY-MM month into the DB's first-of-month date."""
+ try:
+ parsed = datetime.datetime.strptime(value, "%Y-%m")
+ except ValueError as exc:
+ raise ValueError("month must use YYYY-MM format") from exc
+ return parsed.date().replace(day=1)
+
+
+def _percent(value: Decimal | float | int | None) -> float:
+ return round(float(value or 0) * 100, 4)
+
+
+def _date_text(value: datetime.date | None) -> str:
+ return value.isoformat() if value else "—"
+
+
+def _datetime_date_text(value: datetime.datetime | None) -> str | None:
+ return value.date().isoformat() if value else None
+
+
+def _latest_result_subquery(
+ workspace_id: str,
+ monitor_month: datetime.date | None = None,
+):
+ filters = [
+ OpsMonitorBatch.workspace_id == workspace_id,
+ OpsMonitorBatch.batch_status == "published",
+ OpsMonitorBatch.is_deleted == 0,
+ OpsMonitorResult.workspace_id == workspace_id,
+ OpsMonitorResult.is_deleted == 0,
+ ]
+ if monitor_month is not None:
+ filters.append(OpsMonitorResult.monitor_month == monitor_month)
+
+ ranked = (
+ select(
+ OpsMonitorResult.monitor_result_id.label("monitor_result_id"),
+ OpsMonitorResult.model_instance_id.label("model_instance_id"),
+ OpsMonitorResult.model_version_id.label("model_version_id"),
+ OpsMonitorResult.monitor_month.label("monitor_month"),
+ OpsMonitorResult.ranking_result.label("ranking_result"),
+ OpsMonitorResult.ks_value.label("ks_value"),
+ OpsMonitorResult.psi_value.label("psi_value"),
+ func.row_number()
+ .over(
+ partition_by=OpsMonitorResult.model_instance_id,
+ order_by=(
+ OpsMonitorResult.monitor_month.desc(),
+ OpsMonitorBatch.revision_no.desc(),
+ OpsMonitorBatch.published_at.desc(),
+ ),
+ )
+ .label("row_no"),
+ )
+ .join(OpsMonitorBatch, OpsMonitorBatch.batch_id == OpsMonitorResult.batch_id)
+ .where(*filters)
+ .subquery("ranked_monitor_results")
+ )
+ return (
+ select(
+ ranked.c.monitor_result_id,
+ ranked.c.model_instance_id,
+ ranked.c.model_version_id,
+ ranked.c.monitor_month,
+ ranked.c.ranking_result,
+ ranked.c.ks_value,
+ ranked.c.psi_value,
+ )
+ .where(ranked.c.row_no == 1)
+ .subquery("latest_monitor_result")
+ )
+
+
+def _latest_review_subquery():
+ return (
+ select(
+ OpsMonitorReview.monitor_result_id.label("monitor_result_id"),
+ func.max(OpsMonitorReview.handled_at).label("handled_at"),
+ )
+ .where(
+ OpsMonitorReview.is_deleted == 0,
+ OpsMonitorReview.handled_at.is_not(None),
+ )
+ .group_by(OpsMonitorReview.monitor_result_id)
+ .subquery("latest_monitor_review")
+ )
+
+
+def _model_statement(
+ workspace_id: str,
+ *,
+ bank: str | None = None,
+ category: str | None = None,
+ status: str | None = None,
+ keyword: str | None = None,
+ model_id: str | None = None,
+) -> Select[Any]:
+ latest_result = _latest_result_subquery(workspace_id)
+ latest_review = _latest_review_subquery()
+ statement = (
+ select(
+ OpsModelInstance.model_instance_id.label("model_instance_id"),
+ OpsBank.bank_name.label("bank_name"),
+ OpsModelInstance.category_code.label("model_category"),
+ OpsModelInstance.model_name.label("model_name"),
+ OpsModelInstance.model_id.label("model_id"),
+ OpsModelVersion.version_label.label("model_version"),
+ OpsModelInstance.model_status.label("model_status"),
+ OpsModelVersion.last_iteration_date.label("last_iteration_date"),
+ latest_result.c.ranking_result.label("ranking_result"),
+ latest_result.c.ks_value.label("ks_value"),
+ latest_result.c.psi_value.label("psi_value"),
+ OpsMonitorEvaluation.ks_mom_drop_rate.label("ks_mom_drop_rate"),
+ OpsMonitorEvaluation.secondary_level2_hits_6m.label(
+ "secondary_level2_hits_6m"
+ ),
+ OpsBank.is_wuji_bank.label("is_wuji_bank"),
+ latest_review.c.handled_at.label("last_processed_at"),
+ OpsMonitorEvaluation.action_snapshot.label("previous_advice"),
+ OpsModelInstance.common_model_name.label("common_model_name"),
+ )
+ .select_from(OpsModelInstance)
+ .join(OpsBank, OpsBank.bank_id == OpsModelInstance.bank_id)
+ .outerjoin(
+ OpsModelVersion,
+ and_(
+ OpsModelVersion.model_version_id
+ == OpsModelInstance.current_version_id,
+ OpsModelVersion.is_deleted == 0,
+ ),
+ )
+ .outerjoin(
+ latest_result,
+ latest_result.c.model_instance_id
+ == OpsModelInstance.model_instance_id,
+ )
+ .outerjoin(
+ OpsMonitorEvaluation,
+ and_(
+ OpsMonitorEvaluation.monitor_result_id
+ == latest_result.c.monitor_result_id,
+ OpsMonitorEvaluation.is_current == 1,
+ OpsMonitorEvaluation.is_deleted == 0,
+ ),
+ )
+ .outerjoin(
+ latest_review,
+ latest_review.c.monitor_result_id
+ == latest_result.c.monitor_result_id,
+ )
+ .where(
+ OpsModelInstance.workspace_id == workspace_id,
+ OpsModelInstance.is_deleted == 0,
+ OpsBank.workspace_id == workspace_id,
+ OpsBank.is_deleted == 0,
+ )
+ )
+ if bank:
+ statement = statement.where(OpsBank.bank_name == bank)
+ if category:
+ statement = statement.where(OpsModelInstance.category_code == category)
+ if status:
+ statement = statement.where(
+ OpsModelInstance.model_status == _MODEL_STATUS_TO_DB.get(status, status)
+ )
+ if model_id:
+ statement = statement.where(OpsModelInstance.model_id == model_id)
+ if keyword and (term := keyword.strip()):
+ like_term = f"%{term}%"
+ statement = statement.where(
+ or_(
+ OpsBank.bank_name.ilike(like_term),
+ OpsModelInstance.model_name.ilike(like_term),
+ OpsModelInstance.model_id.ilike(like_term),
+ OpsModelVersion.version_label.ilike(like_term),
+ )
+ )
+ return statement.order_by(OpsBank.bank_name, OpsModelInstance.model_id)
+
+
+def _model_dto(row: Mapping[str, Any]) -> OperationsModelDto:
+ return OperationsModelDto(
+ model_instance_id=row["model_instance_id"],
+ bank_name=row["bank_name"],
+ model_category=row["model_category"],
+ model_name=row["model_name"],
+ model_id=row["model_id"],
+ model_version=row["model_version"] or "—",
+ model_status=_MODEL_STATUS_TO_API.get(row["model_status"], "正常"),
+ last_iteration_date=_date_text(row["last_iteration_date"]),
+ ranking_result=_RANKING_TO_API.get(row["ranking_result"], "—"),
+ ks=_percent(row["ks_value"]),
+ psi=_percent(row["psi_value"]),
+ ks_mom_drop=_percent(row["ks_mom_drop_rate"]),
+ secondary_hits_6m=int(row["secondary_level2_hits_6m"] or 0),
+ is_wuji_bank=bool(row["is_wuji_bank"]),
+ last_processed_at=_datetime_date_text(row["last_processed_at"]),
+ previous_advice=row["previous_advice"] or "暂无历史处理建议",
+ common_model_name=row["common_model_name"],
+ )
+
+
+async def list_models(
+ session: AsyncSession,
+ workspace_id: str,
+ *,
+ bank: str | None = None,
+ category: str | None = None,
+ status: str | None = None,
+ keyword: str | None = None,
+) -> list[OperationsModelDto]:
+ rows = (
+ await session.execute(
+ _model_statement(
+ workspace_id,
+ bank=bank,
+ category=category,
+ status=status,
+ keyword=keyword,
+ )
+ )
+ ).mappings()
+ return [_model_dto(row) for row in rows]
+
+
+async def get_model(
+ session: AsyncSession,
+ workspace_id: str,
+ model_id: str,
+) -> OperationsModelDto | None:
+ row = (
+ await session.execute(
+ _model_statement(workspace_id, model_id=model_id).limit(1)
+ )
+ ).mappings().first()
+ return _model_dto(row) if row else None
+
+
+async def get_monthly_monitoring_result(
+ session: AsyncSession,
+ workspace_id: str,
+ model_id: str,
+ monitor_month: datetime.date,
+) -> MonthlyMonitoringResultDto | None:
+ latest_result = _latest_result_subquery(workspace_id, monitor_month)
+ statement = (
+ select(
+ OpsModelInstance.model_instance_id.label("model_instance_id"),
+ latest_result.c.monitor_month.label("monitor_month"),
+ latest_result.c.ranking_result.label("ranking_result"),
+ latest_result.c.ks_value.label("ks_value"),
+ latest_result.c.psi_value.label("psi_value"),
+ OpsMonitorEvaluation.ks_mom_drop_rate.label("ks_mom_drop_rate"),
+ OpsMonitorEvaluation.secondary_level2_hits_6m.label(
+ "secondary_level2_hits_6m"
+ ),
+ )
+ .select_from(OpsModelInstance)
+ .join(
+ latest_result,
+ latest_result.c.model_instance_id
+ == OpsModelInstance.model_instance_id,
+ )
+ .outerjoin(
+ OpsMonitorEvaluation,
+ and_(
+ OpsMonitorEvaluation.monitor_result_id
+ == latest_result.c.monitor_result_id,
+ OpsMonitorEvaluation.is_current == 1,
+ OpsMonitorEvaluation.is_deleted == 0,
+ ),
+ )
+ .where(
+ OpsModelInstance.workspace_id == workspace_id,
+ OpsModelInstance.model_id == model_id,
+ OpsModelInstance.is_deleted == 0,
+ )
+ .limit(1)
+ )
+ row = (await session.execute(statement)).mappings().first()
+ if not row:
+ return None
+ return MonthlyMonitoringResultDto(
+ model_instance_id=row["model_instance_id"],
+ monitor_month=row["monitor_month"].strftime("%Y-%m"),
+ ranking_result=_RANKING_TO_API.get(row["ranking_result"], "—"),
+ ks=_percent(row["ks_value"]),
+ psi=_percent(row["psi_value"]),
+ ks_mom_drop=_percent(row["ks_mom_drop_rate"]),
+ secondary_hits_6m=int(row["secondary_level2_hits_6m"] or 0),
+ )
+
+
+__all__ = [
+ "get_model",
+ "get_monthly_monitoring_result",
+ "list_models",
+ "parse_monitor_month",
+]
diff --git a/backend/src/backend/services/operations/streams.py b/backend/src/backend/services/operations/streams.py
new file mode 100644
index 0000000..fb9a0fc
--- /dev/null
+++ b/backend/src/backend/services/operations/streams.py
@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from loguru import logger
+from redis.asyncio import Redis
+from redis.exceptions import RedisError, ResponseError
+
+
+class OperationsEventStream:
+ """Best-effort Redis Streams transport fed by the durable MySQL Outbox."""
+
+ def __init__(
+ self,
+ client: Redis | None,
+ *,
+ stream_name: str,
+ maxlen: int,
+ ) -> None:
+ self._client = client
+ self.stream_name = stream_name
+ self._maxlen = maxlen
+
+ async def publish(
+ self,
+ event_type: str,
+ payload: dict[str, Any],
+ *,
+ event_id: str,
+ idempotency_key: str = "",
+ trace_id: str = "",
+ schema_version: int = 1,
+ ) -> str | None:
+ if self._client is None:
+ return None
+ fields = {
+ "event_id": event_id,
+ "event_type": event_type,
+ "schema_version": str(schema_version),
+ "idempotency_key": idempotency_key,
+ "trace_id": trace_id,
+ "payload": json.dumps(
+ payload,
+ ensure_ascii=False,
+ separators=(",", ":"),
+ default=str,
+ ),
+ }
+ try:
+ return await self._client.xadd(
+ self.stream_name,
+ fields,
+ maxlen=self._maxlen,
+ approximate=True,
+ )
+ except RedisError as exc:
+ logger.warning(
+ "operations stream publish failed for {event_id}: {error}",
+ event_id=event_id,
+ error=exc,
+ )
+ return None
+
+ async def ensure_group(self, group_name: str) -> bool:
+ if self._client is None:
+ return False
+ try:
+ await self._client.xgroup_create(
+ self.stream_name,
+ group_name,
+ id="0-0",
+ mkstream=True,
+ )
+ return True
+ except ResponseError as exc:
+ if "BUSYGROUP" in str(exc):
+ return True
+ logger.warning("operations stream group creation failed: {error}", error=exc)
+ return False
+ except RedisError as exc:
+ logger.warning("operations stream group creation failed: {error}", error=exc)
+ return False
+
+ async def read_group(
+ self,
+ group_name: str,
+ consumer_name: str,
+ *,
+ count: int = 20,
+ block_ms: int = 5000,
+ ) -> list[tuple[str, dict[str, str]]]:
+ if self._client is None:
+ return []
+ try:
+ response = await self._client.xreadgroup(
+ group_name,
+ consumer_name,
+ {self.stream_name: ">"},
+ count=count,
+ block=block_ms,
+ )
+ if not response:
+ return []
+ return [(message_id, fields) for _, messages in response for message_id, fields in messages]
+ except RedisError as exc:
+ logger.warning("operations stream read failed: {error}", error=exc)
+ return []
+
+ async def acknowledge(self, group_name: str, *message_ids: str) -> int:
+ if self._client is None or not message_ids:
+ return 0
+ try:
+ return int(
+ await self._client.xack(
+ self.stream_name,
+ group_name,
+ *message_ids,
+ )
+ )
+ except RedisError as exc:
+ logger.warning("operations stream ack failed: {error}", error=exc)
+ return 0
+
+
+__all__ = ["OperationsEventStream"]
diff --git a/backend/tests/test_operations_queries.py b/backend/tests/test_operations_queries.py
new file mode 100644
index 0000000..a0086ff
--- /dev/null
+++ b/backend/tests/test_operations_queries.py
@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import datetime
+from decimal import Decimal
+
+import pytest
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlalchemy.pool import StaticPool
+
+from backend.services.operations import (
+ get_model,
+ get_monthly_monitoring_result,
+ list_models,
+ parse_monitor_month,
+)
+from common.config import Settings
+from common.db.models.operations import (
+ OperationsBase,
+ OpsBank,
+ OpsModelInstance,
+ OpsModelVersion,
+ OpsMonitorBatch,
+ OpsMonitorEvaluation,
+ OpsMonitorResult,
+ OpsMonitorReview,
+)
+
+WORKSPACE_ID = "W" * 26
+OTHER_WORKSPACE_ID = "X" * 26
+MODEL_INSTANCE_ID = "M" * 26
+MODEL_VERSION_ID = "V" * 26
+MODEL_ID = "JC-STD-001"
+
+
+@pytest.fixture
+async def session():
+ engine = create_async_engine(
+ "sqlite+aiosqlite://",
+ poolclass=StaticPool,
+ connect_args={"check_same_thread": False},
+ )
+ async with engine.begin() as connection:
+ await connection.run_sync(OperationsBase.metadata.create_all)
+ factory = async_sessionmaker(engine, expire_on_commit=False)
+ async with factory() as database_session:
+ await _seed(database_session)
+ await database_session.commit()
+ yield database_session
+ await engine.dispose()
+
+
+async def _seed(session) -> None:
+ bank = OpsBank(
+ bank_id="B" * 26,
+ workspace_id=WORKSPACE_ID,
+ bank_code="JC",
+ bank_name="江城银行",
+ is_wuji_bank=1,
+ bank_status="active",
+ source_bank_ref="bank-jc",
+ )
+ version = OpsModelVersion(
+ model_version_id=MODEL_VERSION_ID,
+ workspace_id=WORKSPACE_ID,
+ model_instance_id=MODEL_INSTANCE_ID,
+ version_label="v2.3",
+ version_status="active",
+ last_iteration_date=datetime.date(2026, 6, 18),
+ source_version_ref="version-jc-std-v23",
+ )
+ model = OpsModelInstance(
+ model_instance_id=MODEL_INSTANCE_ID,
+ workspace_id=WORKSPACE_ID,
+ bank_id=bank.bank_id,
+ category_code="std",
+ model_id=MODEL_ID,
+ model_name="标准A卡",
+ model_status="normal",
+ current_version_id=version.model_version_id,
+ common_model_name="标准A卡通用版 v2.3",
+ source_model_ref="model-jc-std",
+ )
+ old_batch = OpsMonitorBatch(
+ batch_id="1" * 26,
+ workspace_id=WORKSPACE_ID,
+ source_batch_no="2026-07-r1",
+ monitor_month=datetime.date(2026, 7, 1),
+ revision_no=1,
+ batch_status="published",
+ published_at=datetime.datetime(2026, 7, 20, 8, 0),
+ )
+ new_batch = OpsMonitorBatch(
+ batch_id="2" * 26,
+ workspace_id=WORKSPACE_ID,
+ source_batch_no="2026-07-r2",
+ monitor_month=datetime.date(2026, 7, 1),
+ revision_no=2,
+ batch_status="published",
+ published_at=datetime.datetime(2026, 7, 21, 8, 0),
+ )
+ old_result = OpsMonitorResult(
+ monitor_result_id="3" * 26,
+ workspace_id=WORKSPACE_ID,
+ batch_id=old_batch.batch_id,
+ model_instance_id=MODEL_INSTANCE_ID,
+ model_version_id=MODEL_VERSION_ID,
+ monitor_month=datetime.date(2026, 7, 1),
+ ranking_result="matched",
+ ks_value=Decimal("0.41000000"),
+ psi_value=Decimal("0.09000000"),
+ )
+ new_result = OpsMonitorResult(
+ monitor_result_id="4" * 26,
+ workspace_id=WORKSPACE_ID,
+ batch_id=new_batch.batch_id,
+ model_instance_id=MODEL_INSTANCE_ID,
+ model_version_id=MODEL_VERSION_ID,
+ monitor_month=datetime.date(2026, 7, 1),
+ ranking_result="unmatched",
+ ks_value=Decimal("0.36840000"),
+ psi_value=Decimal("0.27400000"),
+ )
+ evaluation = OpsMonitorEvaluation(
+ evaluation_id="5" * 26,
+ workspace_id=WORKSPACE_ID,
+ monitor_result_id=new_result.monitor_result_id,
+ rule_version_id="6" * 26,
+ rule_item_id="7" * 26,
+ ks_mom_drop_rate=Decimal("0.24100000"),
+ secondary_level2_hits_6m=3,
+ abnormal_level="level3",
+ monitor_grade="C",
+ reason_code="R-C-001",
+ reason_text_snapshot="排序性不符、KS低、PSI高",
+ action_snapshot="建议启动模型微调或重构评估",
+ is_current=1,
+ evaluated_at=datetime.datetime(2026, 7, 21, 9, 0),
+ )
+ review = OpsMonitorReview(
+ review_id="8" * 26,
+ workspace_id=WORKSPACE_ID,
+ monitor_result_id=new_result.monitor_result_id,
+ evaluation_id=evaluation.evaluation_id,
+ review_stage="model_initial",
+ review_status="handled",
+ decision_code="tune_or_rebuild",
+ handling_note="建议评估重构",
+ handled_by="U" * 26,
+ handled_at=datetime.datetime(2026, 7, 22, 10, 30),
+ )
+ other_bank = OpsBank(
+ bank_id="C" * 26,
+ workspace_id=OTHER_WORKSPACE_ID,
+ bank_code="OTHER",
+ bank_name="其他银行",
+ bank_status="active",
+ source_bank_ref="bank-other",
+ )
+ other_model = OpsModelInstance(
+ model_instance_id="N" * 26,
+ workspace_id=OTHER_WORKSPACE_ID,
+ bank_id=other_bank.bank_id,
+ category_code="std",
+ model_id="OTHER-STD-001",
+ model_name="其他模型",
+ model_status="normal",
+ source_model_ref="model-other",
+ )
+ session.add_all(
+ [
+ bank,
+ version,
+ model,
+ old_batch,
+ new_batch,
+ old_result,
+ new_result,
+ evaluation,
+ review,
+ other_bank,
+ other_model,
+ ]
+ )
+
+
+async def test_list_models_uses_latest_revision_and_workspace(session) -> None:
+ models = await list_models(session, WORKSPACE_ID)
+ assert len(models) == 1
+ model = models[0]
+ assert model.model_id == MODEL_ID
+ assert model.ks == 36.84
+ assert model.psi == 27.4
+ assert model.ks_mom_drop == 24.1
+ assert model.ranking_result == "不符"
+ assert model.last_processed_at == "2026-07-22"
+ assert model.is_wuji_bank is True
+
+
+async def test_list_models_filters_and_detail(session) -> None:
+ assert len(await list_models(session, WORKSPACE_ID, bank="江城银行")) == 1
+ assert len(await list_models(session, WORKSPACE_ID, category="big")) == 0
+ assert len(await list_models(session, WORKSPACE_ID, keyword="v2.3")) == 1
+ model = await get_model(session, WORKSPACE_ID, MODEL_ID)
+ assert model is not None
+ assert model.model_version == "v2.3"
+ assert model.common_model_name == "标准A卡通用版 v2.3"
+ assert await get_model(session, OTHER_WORKSPACE_ID, MODEL_ID) is None
+
+
+async def test_get_monthly_monitoring_result(session) -> None:
+ result = await get_monthly_monitoring_result(
+ session,
+ WORKSPACE_ID,
+ MODEL_ID,
+ datetime.date(2026, 7, 1),
+ )
+ assert result is not None
+ assert result.monitor_month == "2026-07"
+ assert result.ks == 36.84
+ assert result.psi == 27.4
+ assert result.secondary_hits_6m == 3
+
+
+def test_monitor_month_and_operations_url() -> None:
+ assert parse_monitor_month("2026-07") == datetime.date(2026, 7, 1)
+ with pytest.raises(ValueError):
+ parse_monitor_month("2026-13")
+ settings = Settings(
+ database_url="mysql+asyncmy://user:pass@db:3306/model_platform?charset=utf8mb4",
+ _env_file=None,
+ )
+ assert settings.operations_database_url is not None
+ assert "/model_operations?" in settings.operations_database_url
diff --git a/backend/tests/test_operations_redis.py b/backend/tests/test_operations_redis.py
new file mode 100644
index 0000000..5e8646f
--- /dev/null
+++ b/backend/tests/test_operations_redis.py
@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import fnmatch
+
+from backend.services.operations import OperationsCache, OperationsEventStream
+
+
+class FakeRedis:
+ def __init__(self) -> None:
+ self.values: dict[str, str] = {}
+ self.expirations: dict[str, int] = {}
+ self.stream_entries: list[tuple[str, dict[str, str]]] = []
+ self.groups: set[str] = set()
+
+ async def get(self, key: str):
+ return self.values.get(key)
+
+ async def set(self, key: str, value: str, *, ex: int):
+ self.values[key] = value
+ self.expirations[key] = ex
+ return True
+
+ async def unlink(self, *keys: str):
+ removed = 0
+ for key in keys:
+ if key in self.values:
+ removed += 1
+ self.values.pop(key)
+ self.expirations.pop(key, None)
+ return removed
+
+ async def scan_iter(self, *, match: str, count: int):
+ del count
+ for key in list(self.values):
+ if fnmatch.fnmatch(key, match):
+ yield key
+
+ async def xadd(self, stream: str, fields, *, maxlen: int, approximate: bool):
+ assert maxlen == 1000
+ assert approximate is True
+ message_id = f"1-{len(self.stream_entries)}"
+ self.stream_entries.append((message_id, dict(fields)))
+ return message_id
+
+ async def xgroup_create(self, stream: str, group: str, *, id: str, mkstream: bool):
+ assert stream == "ops:events"
+ assert id == "0-0"
+ assert mkstream is True
+ self.groups.add(group)
+ return True
+
+ async def xreadgroup(self, group, consumer, streams, *, count: int, block: int):
+ del group, consumer, count, block
+ stream = next(iter(streams))
+ return [(stream, list(self.stream_entries))]
+
+ async def xack(self, stream: str, group: str, *message_ids: str):
+ del stream, group
+ return len(message_ids)
+
+
+async def test_cache_round_trip_and_workspace_invalidation() -> None:
+ redis = FakeRedis()
+ cache = OperationsCache(
+ redis, # type: ignore[arg-type]
+ prefix="ops",
+ default_ttl_seconds=300,
+ )
+ key = cache.build_key("W1", "model-overview", {"month": "2026-07", "bank": "江城"})
+ same_key = cache.build_key("W1", "model-overview", {"bank": "江城", "month": "2026-07"})
+ other_key = cache.build_key("W2", "model-overview", {"bank": "江城"})
+ assert key == same_key
+ assert key != other_key
+ assert await cache.set_json(key, {"total": 3, "name": "标准A卡"}) is True
+ assert redis.expirations[key] == 300
+ assert await cache.get_json(key) == {"total": 3, "name": "标准A卡"}
+ await cache.set_json(other_key, {"total": 1})
+ assert await cache.invalidate_resource("W1", "model-overview") == 1
+ assert await cache.get_json(key) is None
+ assert await cache.get_json(other_key) == {"total": 1}
+
+
+async def test_cache_without_redis_is_a_noop() -> None:
+ cache = OperationsCache(None, prefix="ops", default_ttl_seconds=300)
+ assert await cache.get_json("missing") is None
+ assert await cache.set_json("missing", {"value": 1}) is False
+ assert await cache.delete("missing") == 0
+
+
+async def test_stream_publish_group_read_and_ack() -> None:
+ redis = FakeRedis()
+ stream = OperationsEventStream(
+ redis, # type: ignore[arg-type]
+ stream_name="ops:events",
+ maxlen=1000,
+ )
+ assert await stream.ensure_group("notifications") is True
+ message_id = await stream.publish(
+ "monitor.review.due",
+ {"review_id": "R1", "bank": "江城银行"},
+ event_id="E1",
+ idempotency_key="review:R1:due",
+ trace_id="T1",
+ )
+ assert message_id == "1-0"
+ messages = await stream.read_group("notifications", "worker-1")
+ assert messages[0][0] == "1-0"
+ assert messages[0][1]["event_type"] == "monitor.review.due"
+ assert '"review_id":"R1"' in messages[0][1]["payload"]
+ assert await stream.acknowledge("notifications", message_id) == 1
diff --git a/common/src/common/config.py b/common/src/common/config.py
index 734c410..0cfcfd5 100644
--- a/common/src/common/config.py
+++ b/common/src/common/config.py
@@ -26,6 +26,7 @@ from venv import logger
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from pydantic import Field, field_validator, model_validator
from pydantic_settings import BaseSettings, NoDecode, SettingsConfigDict
+from sqlalchemy.engine import make_url
# ── AES 解密核心函数 ────────────────────────────────────────────────────────
@@ -63,6 +64,43 @@ class Settings(BaseSettings):
),
description="SQLAlchemy async URI for the platform MySQL.",
)
+ operations_database_url: str | None = Field(
+ default=None,
+ description=(
+ "SQLAlchemy async URI for the isolated model_operations database. "
+ "When omitted it reuses DATABASE_URL credentials and switches only "
+ "the schema name to model_operations."
+ ),
+ )
+ platform_read_database_url: str | None = Field(
+ default=None,
+ description="Read-only model_platform connection used by operations APIs.",
+ )
+ deploy_database_url: str | None = Field(
+ default=None,
+ description="Read-only model_deploy connection used by operations APIs.",
+ )
+
+ # ── operations Redis accelerator ─────────────────────────────
+ redis_url: str | None = Field(
+ default=None,
+ description=(
+ "Optional Redis URL for operations query cache and event Streams. "
+ "MySQL remains the source of truth when Redis is unavailable."
+ ),
+ )
+ redis_socket_connect_timeout_seconds: float = Field(default=2.0, gt=0, le=30)
+ redis_socket_timeout_seconds: float = Field(default=2.0, gt=0, le=30)
+ operations_cache_ttl_seconds: int = Field(default=300, ge=10, le=86400)
+ operations_redis_prefix: str = Field(default="model-platform:operations")
+ operations_event_stream: str = Field(
+ default="model-platform:operations:events"
+ )
+ operations_event_stream_maxlen: int = Field(default=10000, ge=100)
+ operations_data_mode: str = Field(
+ default="database",
+ description="Operations data source: database or mock.",
+ )
# ── JWT ───────────────────────────────────────────────────────
jwt_secret: str = Field(
@@ -268,6 +306,23 @@ class Settings(BaseSettings):
# print(values[key])
return values
+ @model_validator(mode="after")
+ def _derive_operations_database_url(self) -> "Settings":
+ """Default the operations database to the platform server credentials."""
+ if not self.operations_database_url:
+ platform_url = make_url(self.database_url)
+ self.operations_database_url = platform_url.set(
+ database="model_operations"
+ ).render_as_string(hide_password=False)
+ if not self.platform_read_database_url:
+ self.platform_read_database_url = self.database_url
+ if not self.deploy_database_url:
+ platform_url = make_url(self.database_url)
+ self.deploy_database_url = platform_url.set(
+ database="model_deploy"
+ ).render_as_string(hide_password=False)
+ return self
+
model_config = SettingsConfigDict(
env_file=".env",
env_file_encoding="utf-8",
diff --git a/common/src/common/db/__init__.py b/common/src/common/db/__init__.py
index 10b0d03..21b1649 100644
--- a/common/src/common/db/__init__.py
+++ b/common/src/common/db/__init__.py
@@ -5,6 +5,7 @@ from common.db.session import (
AsyncSessionFactory,
create_database_engine,
create_session_factory,
+ readonly_session_scope,
session_scope,
)
@@ -13,5 +14,6 @@ __all__ = [
"Base",
"create_database_engine",
"create_session_factory",
+ "readonly_session_scope",
"session_scope",
]
diff --git a/common/src/common/db/models/operations/__init__.py b/common/src/common/db/models/operations/__init__.py
new file mode 100644
index 0000000..7a93d2d
--- /dev/null
+++ b/common/src/common/db/models/operations/__init__.py
@@ -0,0 +1,31 @@
+from common.db.models.operations.base import OperationsBase
+from common.db.models.operations.governance import (
+ OpsMonitorEvaluation,
+ OpsMonitorReview,
+ OpsRuleItem,
+ OpsRuleVersion,
+)
+from common.db.models.operations.models import OpsModelInstance, OpsModelVersion
+from common.db.models.operations.monitoring import (
+ OpsMonitorBatch,
+ OpsMonitorDistribution,
+ OpsMonitorFeatureMetric,
+ OpsMonitorResult,
+)
+from common.db.models.operations.reference import OpsBank, OpsModelCategory
+
+__all__ = [
+ "OperationsBase",
+ "OpsBank",
+ "OpsModelCategory",
+ "OpsModelInstance",
+ "OpsModelVersion",
+ "OpsMonitorBatch",
+ "OpsMonitorDistribution",
+ "OpsMonitorEvaluation",
+ "OpsMonitorFeatureMetric",
+ "OpsMonitorResult",
+ "OpsMonitorReview",
+ "OpsRuleItem",
+ "OpsRuleVersion",
+]
diff --git a/common/src/common/db/models/operations/base.py b/common/src/common/db/models/operations/base.py
new file mode 100644
index 0000000..931d291
--- /dev/null
+++ b/common/src/common/db/models/operations/base.py
@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import datetime
+
+from sqlalchemy import DateTime, Integer, text
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+
+class OperationsBase(DeclarativeBase):
+ """Declarative base isolated from the model_platform metadata."""
+
+
+class CreatedAtMixin:
+ created_at: Mapped[datetime.datetime] = mapped_column(
+ DateTime(), nullable=False, server_default=text("CURRENT_TIMESTAMP")
+ )
+
+
+class TimestampMixin(CreatedAtMixin):
+ updated_at: Mapped[datetime.datetime] = mapped_column(
+ DateTime(),
+ nullable=False,
+ server_default=text("CURRENT_TIMESTAMP"),
+ onupdate=datetime.datetime.utcnow,
+ )
+
+
+class SoftDeleteMixin:
+ is_deleted: Mapped[int] = mapped_column(
+ Integer, nullable=False, server_default=text("0")
+ )
+ deleted_at: Mapped[datetime.datetime | None] = mapped_column(DateTime())
+
+
+__all__ = [
+ "CreatedAtMixin",
+ "OperationsBase",
+ "SoftDeleteMixin",
+ "TimestampMixin",
+]
diff --git a/common/src/common/db/models/operations/governance.py b/common/src/common/db/models/operations/governance.py
new file mode 100644
index 0000000..e3692d2
--- /dev/null
+++ b/common/src/common/db/models/operations/governance.py
@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import datetime
+from decimal import Decimal
+from typing import Any
+
+from sqlalchemy import DateTime, Index, Integer, JSON, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from common.db.models.operations.base import (
+ CreatedAtMixin,
+ OperationsBase,
+ SoftDeleteMixin,
+ TimestampMixin,
+)
+
+
+class OpsRuleVersion(CreatedAtMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_rule_versions"
+ __table_args__ = (
+ Index(
+ "uk_ops_rule_versions_label",
+ "workspace_id",
+ "category_code",
+ "version_label",
+ unique=True,
+ ),
+ Index(
+ "idx_ops_rule_versions_status",
+ "workspace_id",
+ "category_code",
+ "rule_status",
+ "published_at",
+ ),
+ {"comment": "监控判级规则版本"},
+ )
+
+ rule_version_id: Mapped[str] = mapped_column(String(26), primary_key=True)
+ workspace_id: Mapped[str] = mapped_column(String(26), nullable=False)
+ category_code: Mapped[str] = mapped_column(String(32), nullable=False, default="*")
+ version_label: Mapped[str] = mapped_column(String(64), nullable=False)
+ rule_status: Mapped[str] = mapped_column(String(24), nullable=False, default="draft")
+ threshold_json: Mapped[dict[str, Any]] = mapped_column(JSON(), nullable=False)
+ supersedes_rule_version_id: Mapped[str | None] = mapped_column(String(26))
+ change_note: Mapped[str | None] = mapped_column(String(1000))
+ created_by: Mapped[str] = mapped_column(String(26), nullable=False)
+ published_by: Mapped[str | None] = mapped_column(String(26))
+ published_at: Mapped[datetime.datetime | None] = mapped_column(DateTime())
+
+
+class OpsRuleItem(CreatedAtMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_rule_items"
+ __table_args__ = (
+ Index("uk_ops_rule_items_order", "rule_version_id", "sort_order", unique=True),
+ Index("uk_ops_rule_items_reason", "rule_version_id", "reason_code", unique=True),
+ {"comment": "规则版本下的判级矩阵行"},
+ )
+
+ rule_item_id: Mapped[str] = mapped_column(String(26), primary_key=True)
+ rule_version_id: Mapped[str] = mapped_column(String(26), nullable=False, index=True)
+ sort_order: Mapped[int] = mapped_column(Integer, nullable=False)
+ ranking_result: Mapped[str] = mapped_column(String(24), nullable=False)
+ ks_band_code: Mapped[str] = mapped_column(String(32), nullable=False)
+ psi_band_code: Mapped[str] = mapped_column(String(32), nullable=False)
+ ks_drop_band_code: Mapped[str] = mapped_column(String(32), nullable=False)
+ conditions_json: Mapped[dict[str, Any] | None] = mapped_column(JSON())
+ abnormal_level: Mapped[str] = mapped_column(String(16), nullable=False)
+ monitor_grade: Mapped[str] = mapped_column(String(1), nullable=False)
+ secondary_upgrade_threshold: Mapped[int | None] = mapped_column(Integer)
+ reason_code: Mapped[str] = mapped_column(String(64), nullable=False)
+ reason_template: Mapped[str] = mapped_column(String(1000), nullable=False)
+ action_text: Mapped[str] = mapped_column(String(1000), nullable=False)
+
+
+class OpsMonitorEvaluation(CreatedAtMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_monitor_evaluations"
+ __table_args__ = (
+ Index(
+ "uk_ops_evaluations_result_rule",
+ "monitor_result_id",
+ "rule_version_id",
+ unique=True,
+ ),
+ Index(
+ "idx_ops_evaluations_grade",
+ "workspace_id",
+ "monitor_grade",
+ "abnormal_level",
+ "evaluated_at",
+ ),
+ {"comment": "按规则版本生成的不可变监控判级快照"},
+ )
+
+ evaluation_id: Mapped[str] = mapped_column(String(26), primary_key=True)
+ workspace_id: Mapped[str] = mapped_column(String(26), nullable=False)
+ monitor_result_id: Mapped[str] = mapped_column(String(26), nullable=False, index=True)
+ rule_version_id: Mapped[str] = mapped_column(String(26), nullable=False)
+ rule_item_id: Mapped[str] = mapped_column(String(26), nullable=False)
+ ks_mom_drop_rate: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ secondary_level2_hits_6m: Mapped[int] = mapped_column(
+ Integer, nullable=False, default=0
+ )
+ abnormal_level: Mapped[str] = mapped_column(String(16), nullable=False)
+ monitor_grade: Mapped[str] = mapped_column(String(1), nullable=False)
+ reason_code: Mapped[str] = mapped_column(String(64), nullable=False)
+ reason_text_snapshot: Mapped[str] = mapped_column(String(2000), nullable=False)
+ action_snapshot: Mapped[str] = mapped_column(String(2000), nullable=False)
+ is_current: Mapped[int] = mapped_column(Integer, nullable=False, default=1)
+ evaluated_at: Mapped[datetime.datetime] = mapped_column(
+ DateTime(), nullable=False, default=datetime.datetime.utcnow
+ )
+
+
+class OpsMonitorReview(TimestampMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_monitor_reviews"
+ __table_args__ = (
+ Index(
+ "uk_ops_reviews_result_stage",
+ "monitor_result_id",
+ "review_stage",
+ unique=True,
+ ),
+ Index(
+ "idx_ops_reviews_pending",
+ "workspace_id",
+ "review_status",
+ "review_stage",
+ "due_at",
+ ),
+ {"comment": "模型团队初审与业务团队终审"},
+ )
+
+ review_id: Mapped[str] = mapped_column(String(26), primary_key=True)
+ workspace_id: Mapped[str] = mapped_column(String(26), nullable=False)
+ monitor_result_id: Mapped[str] = mapped_column(String(26), nullable=False, index=True)
+ evaluation_id: Mapped[str] = mapped_column(String(26), nullable=False)
+ review_stage: Mapped[str] = mapped_column(String(24), nullable=False)
+ review_status: Mapped[str] = mapped_column(
+ String(24), nullable=False, default="pending"
+ )
+ decision_code: Mapped[str | None] = mapped_column(String(32))
+ handling_note: Mapped[str | None] = mapped_column(String(2000))
+ due_at: Mapped[datetime.datetime | None] = mapped_column(DateTime())
+ handled_by: Mapped[str | None] = mapped_column(String(26))
+ handled_at: Mapped[datetime.datetime | None] = mapped_column(DateTime())
+ auto_closed_at: Mapped[datetime.datetime | None] = mapped_column(DateTime())
+ state_version: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+
+
+__all__ = [
+ "OpsMonitorEvaluation",
+ "OpsMonitorReview",
+ "OpsRuleItem",
+ "OpsRuleVersion",
+]
diff --git a/common/src/common/db/models/operations/models.py b/common/src/common/db/models/operations/models.py
new file mode 100644
index 0000000..021cd82
--- /dev/null
+++ b/common/src/common/db/models/operations/models.py
@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import datetime
+from decimal import Decimal
+
+from sqlalchemy import Date, DateTime, Index, Integer, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from common.db.models.operations.base import (
+ OperationsBase,
+ SoftDeleteMixin,
+ TimestampMixin,
+)
+
+
+class OpsModelInstance(TimestampMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_model_instances"
+ __table_args__ = (
+ Index(
+ "uk_ops_models_business_id", "workspace_id", "model_id", unique=True
+ ),
+ Index(
+ "uk_ops_models_source",
+ "workspace_id",
+ "source_system",
+ "source_model_ref",
+ unique=True,
+ ),
+ Index(
+ "idx_ops_models_filters",
+ "workspace_id",
+ "category_code",
+ "model_status",
+ "is_deleted",
+ ),
+ {"comment": "业务模型实例；模型平台可受控直写"},
+ )
+
+ model_instance_id: Mapped[str] = mapped_column(String(26), primary_key=True)
+ workspace_id: Mapped[str] = mapped_column(String(26), nullable=False)
+ bank_id: Mapped[str] = mapped_column(String(26), nullable=False, index=True)
+ category_code: Mapped[str] = mapped_column(String(32), nullable=False)
+ model_id: Mapped[str] = mapped_column(String(128), nullable=False)
+ model_name: Mapped[str] = mapped_column(String(200), nullable=False)
+ model_status: Mapped[str] = mapped_column(
+ String(24), nullable=False, default="normal"
+ )
+ current_version_id: Mapped[str | None] = mapped_column(String(26), index=True)
+ is_common_model: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+ common_source_model_id: Mapped[str | None] = mapped_column(String(26), index=True)
+ common_model_name: Mapped[str | None] = mapped_column(String(200))
+ source_system: Mapped[str] = mapped_column(
+ String(64), nullable=False, default="model_platform"
+ )
+ source_model_ref: Mapped[str | None] = mapped_column(String(128))
+ source_updated_at: Mapped[datetime.datetime | None] = mapped_column(DateTime())
+
+
+class OpsModelVersion(TimestampMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_model_versions"
+ __table_args__ = (
+ Index(
+ "uk_ops_model_versions_label",
+ "model_instance_id",
+ "version_label",
+ unique=True,
+ ),
+ Index(
+ "uk_ops_model_versions_source",
+ "workspace_id",
+ "source_system",
+ "source_version_ref",
+ unique=True,
+ ),
+ Index(
+ "idx_ops_model_versions_lifecycle",
+ "workspace_id",
+ "version_status",
+ "online_date",
+ "offline_date",
+ ),
+ {"comment": "模型版本与生命周期；模型平台可受控直写"},
+ )
+
+ model_version_id: Mapped[str] = mapped_column(String(26), primary_key=True)
+ workspace_id: Mapped[str] = mapped_column(String(26), nullable=False)
+ model_instance_id: Mapped[str] = mapped_column(String(26), nullable=False, index=True)
+ version_label: Mapped[str] = mapped_column(String(64), nullable=False)
+ version_status: Mapped[str] = mapped_column(
+ String(24), nullable=False, default="active"
+ )
+ platform_versions_id: Mapped[str | None] = mapped_column(String(26))
+ developer_user_id: Mapped[str | None] = mapped_column(String(26))
+ developer_display_name: Mapped[str | None] = mapped_column(String(100))
+ development_date: Mapped[datetime.date | None] = mapped_column(Date())
+ iteration_start_date: Mapped[datetime.date | None] = mapped_column(Date())
+ last_iteration_date: Mapped[datetime.date | None] = mapped_column(Date())
+ iteration_reason: Mapped[str | None] = mapped_column(String(1000))
+ escort_start_date: Mapped[datetime.date | None] = mapped_column(Date())
+ escort_end_date: Mapped[datetime.date | None] = mapped_column(Date())
+ online_date: Mapped[datetime.date | None] = mapped_column(Date())
+ offline_date: Mapped[datetime.date | None] = mapped_column(Date())
+ development_ks: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ development_psi: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ max_lift: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ scoring_logic_storage_object_id: Mapped[str | None] = mapped_column(String(26))
+ source_system: Mapped[str] = mapped_column(
+ String(64), nullable=False, default="model_platform"
+ )
+ source_version_ref: Mapped[str | None] = mapped_column(String(128))
+ source_updated_at: Mapped[datetime.datetime | None] = mapped_column(DateTime())
+
+
+__all__ = ["OpsModelInstance", "OpsModelVersion"]
diff --git a/common/src/common/db/models/operations/monitoring.py b/common/src/common/db/models/operations/monitoring.py
new file mode 100644
index 0000000..b842cae
--- /dev/null
+++ b/common/src/common/db/models/operations/monitoring.py
@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import datetime
+from decimal import Decimal
+from typing import Any
+
+from sqlalchemy import Date, DateTime, Index, Integer, JSON, Numeric, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from common.db.models.operations.base import (
+ CreatedAtMixin,
+ OperationsBase,
+ SoftDeleteMixin,
+ TimestampMixin,
+)
+
+
+class OpsMonitorBatch(TimestampMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_monitor_batches"
+ __table_args__ = (
+ Index(
+ "uk_ops_monitor_batches_source_no",
+ "workspace_id",
+ "source_system",
+ "source_batch_no",
+ unique=True,
+ ),
+ Index(
+ "uk_ops_monitor_batches_revision",
+ "workspace_id",
+ "source_system",
+ "monitor_month",
+ "revision_no",
+ unique=True,
+ ),
+ Index(
+ "idx_ops_monitor_batches_publish",
+ "workspace_id",
+ "batch_status",
+ "monitor_month",
+ "revision_no",
+ ),
+ {"comment": "月度监控写入批次与发布门闩"},
+ )
+
+ batch_id: Mapped[str] = mapped_column(String(26), primary_key=True)
+ workspace_id: Mapped[str] = mapped_column(String(26), nullable=False)
+ source_system: Mapped[str] = mapped_column(
+ String(64), nullable=False, default="model_platform"
+ )
+ source_batch_no: Mapped[str] = mapped_column(String(128), nullable=False)
+ monitor_month: Mapped[datetime.date] = mapped_column(Date(), nullable=False)
+ revision_no: Mapped[int] = mapped_column(Integer, nullable=False, default=1)
+ supersedes_batch_id: Mapped[str | None] = mapped_column(String(26))
+ batch_status: Mapped[str] = mapped_column(
+ String(24), nullable=False, default="writing"
+ )
+ expected_model_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+ written_model_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+ feature_row_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+ distribution_row_count: Mapped[int] = mapped_column(
+ Integer, nullable=False, default=0
+ )
+ checksum_sha256: Mapped[str | None] = mapped_column(String(64))
+ generated_at: Mapped[datetime.datetime | None] = mapped_column(DateTime())
+ published_at: Mapped[datetime.datetime | None] = mapped_column(DateTime())
+ published_by: Mapped[str | None] = mapped_column(String(26))
+ failed_reason: Mapped[str | None] = mapped_column(String(2000))
+
+
+class OpsMonitorResult(CreatedAtMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_monitor_results"
+ __table_args__ = (
+ Index(
+ "uk_ops_monitor_results_batch_model",
+ "batch_id",
+ "model_instance_id",
+ unique=True,
+ ),
+ Index(
+ "idx_ops_monitor_results_month",
+ "workspace_id",
+ "monitor_month",
+ "model_instance_id",
+ ),
+ {"comment": "单模型单月原始监控结果；发布后不可更新"},
+ )
+
+ monitor_result_id: Mapped[str] = mapped_column(String(26), primary_key=True)
+ workspace_id: Mapped[str] = mapped_column(String(26), nullable=False)
+ batch_id: Mapped[str] = mapped_column(String(26), nullable=False, index=True)
+ model_instance_id: Mapped[str] = mapped_column(String(26), nullable=False, index=True)
+ model_version_id: Mapped[str] = mapped_column(String(26), nullable=False, index=True)
+ monitor_month: Mapped[datetime.date] = mapped_column(Date(), nullable=False)
+ source_result_ref: Mapped[str | None] = mapped_column(String(128))
+ ranking_result: Mapped[str | None] = mapped_column(String(24))
+ ks_value: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ psi_value: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ sample_count: Mapped[int | None] = mapped_column(Integer)
+ good_count: Mapped[int | None] = mapped_column(Integer)
+ bad_count: Mapped[int | None] = mapped_column(Integer)
+ source_result_json: Mapped[dict[str, Any] | None] = mapped_column(JSON())
+ source_calculated_at: Mapped[datetime.datetime | None] = mapped_column(DateTime())
+
+
+class OpsMonitorFeatureMetric(CreatedAtMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_monitor_feature_metrics"
+ __table_args__ = (
+ Index(
+ "uk_ops_feature_metrics_result_feature",
+ "monitor_result_id",
+ "feature_code",
+ unique=True,
+ ),
+ Index("idx_ops_feature_metrics_iv_drop", "monitor_result_id", "iv_drop_rate"),
+ Index(
+ "idx_ops_feature_metrics_csi_rise", "monitor_result_id", "csi_rise_rate"
+ ),
+ {"comment": "单月特征级 IV/CSI 与贡献变化"},
+ )
+
+ feature_metric_id: Mapped[str] = mapped_column(String(26), primary_key=True)
+ monitor_result_id: Mapped[str] = mapped_column(String(26), nullable=False, index=True)
+ feature_code: Mapped[str] = mapped_column(String(128), nullable=False)
+ feature_name: Mapped[str] = mapped_column(String(200), nullable=False)
+ iv_value: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ previous_iv_value: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ iv_drop_rate: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ csi_value: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ previous_csi_value: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ csi_rise_rate: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ ks_contribution_change: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ psi_contribution_change: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ source_metric_json: Mapped[dict[str, Any] | None] = mapped_column(JSON())
+
+
+class OpsMonitorDistribution(CreatedAtMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_monitor_distributions"
+ __table_args__ = (
+ Index(
+ "uk_ops_distributions_bin",
+ "monitor_result_id",
+ "dimension_type",
+ "feature_code",
+ "bin_order",
+ unique=True,
+ ),
+ Index(
+ "idx_ops_distributions_feature",
+ "monitor_result_id",
+ "feature_code",
+ "bin_order",
+ ),
+ {"comment": "排序性评分分箱及特征分布"},
+ )
+
+ distribution_id: Mapped[str] = mapped_column(String(26), primary_key=True)
+ monitor_result_id: Mapped[str] = mapped_column(String(26), nullable=False, index=True)
+ dimension_type: Mapped[str] = mapped_column(String(24), nullable=False)
+ feature_code: Mapped[str] = mapped_column(String(128), nullable=False, default="")
+ feature_name: Mapped[str | None] = mapped_column(String(200))
+ bin_order: Mapped[int] = mapped_column(Integer, nullable=False)
+ bin_code: Mapped[str] = mapped_column(String(128), nullable=False)
+ bin_label: Mapped[str] = mapped_column(String(255), nullable=False)
+ reference_period_label: Mapped[str | None] = mapped_column(String(64))
+ reference_count: Mapped[int | None] = mapped_column(Integer)
+ reference_share: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ current_count: Mapped[int | None] = mapped_column(Integer)
+ current_share: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ good_count: Mapped[int | None] = mapped_column(Integer)
+ bad_count: Mapped[int | None] = mapped_column(Integer)
+ bad_rate: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ psi_component: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+ csi_component: Mapped[Decimal | None] = mapped_column(Numeric(12, 8))
+
+
+__all__ = [
+ "OpsMonitorBatch",
+ "OpsMonitorDistribution",
+ "OpsMonitorFeatureMetric",
+ "OpsMonitorResult",
+]
diff --git a/common/src/common/db/models/operations/reference.py b/common/src/common/db/models/operations/reference.py
new file mode 100644
index 0000000..69d6351
--- /dev/null
+++ b/common/src/common/db/models/operations/reference.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import datetime
+
+from sqlalchemy import DateTime, Index, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column
+
+from common.db.models.operations.base import (
+ OperationsBase,
+ SoftDeleteMixin,
+ TimestampMixin,
+)
+
+
+class OpsModelCategory(TimestampMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_model_categories"
+ __table_args__ = (
+ Index("uk_ops_categories_name", "category_name", unique=True),
+ Index("idx_ops_categories_status", "status", "sort_order"),
+ {"comment": "固定模型大类字典，由运维模块维护"},
+ )
+
+ category_code: Mapped[str] = mapped_column(String(32), primary_key=True)
+ category_name: Mapped[str] = mapped_column(String(100), nullable=False)
+ sort_order: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+ status: Mapped[str] = mapped_column(String(16), nullable=False, default="active")
+
+
+class OpsBank(TimestampMixin, SoftDeleteMixin, OperationsBase):
+ __tablename__ = "ops_banks"
+ __table_args__ = (
+ Index("uk_ops_banks_code", "workspace_id", "bank_code", unique=True),
+ Index(
+ "uk_ops_banks_source",
+ "workspace_id",
+ "source_system",
+ "source_bank_ref",
+ unique=True,
+ ),
+ Index(
+ "idx_ops_banks_workspace_status",
+ "workspace_id",
+ "bank_status",
+ "is_deleted",
+ ),
+ {"comment": "银行主数据；模型平台可受控直写"},
+ )
+
+ bank_id: Mapped[str] = mapped_column(String(26), primary_key=True)
+ workspace_id: Mapped[str] = mapped_column(String(26), nullable=False)
+ bank_code: Mapped[str] = mapped_column(String(64), nullable=False)
+ bank_name: Mapped[str] = mapped_column(String(150), nullable=False)
+ is_wuji_bank: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+ bank_status: Mapped[str] = mapped_column(
+ String(16), nullable=False, default="active"
+ )
+ source_system: Mapped[str] = mapped_column(
+ String(64), nullable=False, default="model_platform"
+ )
+ source_bank_ref: Mapped[str | None] = mapped_column(String(128))
+ source_updated_at: Mapped[datetime.datetime | None] = mapped_column(DateTime())
+
+
+__all__ = ["OpsBank", "OpsModelCategory"]
diff --git a/common/src/common/db/session.py b/common/src/common/db/session.py
index 0b9836d..b17ea77 100644
--- a/common/src/common/db/session.py
+++ b/common/src/common/db/session.py
@@ -3,6 +3,7 @@ from __future__ import annotations
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
+from sqlalchemy import text
from sqlalchemy.ext.asyncio import (
AsyncEngine,
AsyncSession,
@@ -55,3 +56,18 @@ async def session_scope(
except Exception:
await session.rollback()
raise
+
+
+@asynccontextmanager
+async def readonly_session_scope(
+ factory: AsyncSessionFactory,
+) -> AsyncIterator[AsyncSession]:
+ """Yield a session whose MySQL transaction is explicitly read-only."""
+ async with factory() as session:
+ try:
+ bind = session.get_bind()
+ if bind.dialect.name == "mysql":
+ await session.execute(text("SET TRANSACTION READ ONLY"))
+ yield session
+ finally:
+ await session.rollback()
diff --git a/docker-compose.yml b/docker-compose.yml
index 5ea023e..fbf7a98 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -78,6 +78,15 @@ services:
# No local-FS volume: backend stores everything in S3 (S3_*).
environment:
DATABASE_URL: ${DATABASE_URL:?DATABASE_URL is required}
+ OPERATIONS_DATABASE_URL: ${OPERATIONS_DATABASE_URL:-}
+ PLATFORM_READ_DATABASE_URL: ${PLATFORM_READ_DATABASE_URL:-}
+ DEPLOY_DATABASE_URL: ${DEPLOY_DATABASE_URL:-}
+ REDIS_URL: ${REDIS_URL:-}
+ OPERATIONS_CACHE_TTL_SECONDS: ${OPERATIONS_CACHE_TTL_SECONDS:-300}
+ OPERATIONS_REDIS_PREFIX: ${OPERATIONS_REDIS_PREFIX:-model-platform:operations}
+ OPERATIONS_EVENT_STREAM: ${OPERATIONS_EVENT_STREAM:-model-platform:operations:events}
+ OPERATIONS_EVENT_STREAM_MAXLEN: ${OPERATIONS_EVENT_STREAM_MAXLEN:-10000}
+ OPERATIONS_DATA_MODE: ${OPERATIONS_DATA_MODE:-database}
SERVICE_NAME: model-platform-backend
SCHEDULE_EVENT_NAMESPACE: ${SCHEDULE_EVENT_NAMESPACE:-model-platform-local}
JWT_SECRET: ${JWT_SECRET:?JWT_SECRET is required}
diff --git a/docs/architecture/A卡模型运维模块-后端架构与数据库设计-V0.2.md b/docs/architecture/A卡模型运维模块-后端架构与数据库设计-V0.2.md
new file mode 100644
index 0000000..2e89a93
--- /dev/null
+++ b/docs/architecture/A卡模型运维模块-后端架构与数据库设计-V0.2.md
@@ -0,0 +1,308 @@
+# A 卡模型运维模块后端架构与数据库设计 V0.2
+
+> 状态：设计评审稿；独立库 DDL 已生成但尚未执行，ORM、迁移和接口尚未实现
+> 日期：2026-08-31
+> 依据：当前 `develop` 工程、运维前端 V1.9、现有三条 API 契约及甲方提供的 `model_platform` 18 张表 DDL
+
+## 1. 结论
+
+采用“**同一工程、两个数据库、平台库只读、运维库自有**”的方式：
+
+- 现有 `model_platform` 库保持不变，只读复用用户、角色、工作空间、对象存储、脚本版本和调度数据。
+- 新建独立 `model_operations` 库；模型平台直接写入其中 7 张受控源表，不通过运维平台复制一份数据。
+- 运维模块只读取状态为 `published` 的监控批次，未发布或失败批次对页面不可见。
+- 判级、复核、报告、流程、文档、Prompt 和配置由运维模块独立维护，模型平台不得写入。
+- 已发布监控数据不原地覆盖；勘误时新增修订批次，保留历史版本和审计链。
+- 首期不新增微服务、Redis或消息中间件；复用现有 Nginx、React、FastAPI、对象存储和 Schedule Executor，新库自带独立 Outbox/Inbox。
+
+这能满足“模型方直接写业务表”和“我方单独建库”的双重要求，同时避免取得现有平台库不必要的写权限。
+
+## 2. 模块边界
+
+### 2.1 模型平台负责
+
+- 银行、模型实例、模型版本及生命周期数据的写入。
+- 月度监控原始结果、特征指标和分箱分布数据的计算与写入。
+- 写入批次的完整性校验、计数、校验和及发布。
+- 仅获得 `model_operations` 7 张源表的受控写权限，以及发布事件所需的 Outbox 插入权限。
+- 已发布数据发生错误时，以新修订批次更正，不修改旧记录。
+
+### 2.2 运维模块负责
+
+- 按已发布原始结果和已发布规则版本计算异常等级、监控结果等级和命中原因。
+- 模型团队初审、业务团队终审、超时默认不处理及全程留痕。
+- 监控/诊断报告生成、编辑、发送、汇总和历史修订。
+- 七阶段开发评审流程、材料、知识库、规则、Prompt、报告模板和按银行配置。
+- 工作台、模型大类、细分银行、监控明细和详情等查询 API。
+
+### 2.3 明确不做
+
+- 运维模块不重复建设账号、角色、权限表；只复用登录模块返回的用户、角色和工作空间。
+- 运维模块不得读取 `model_platform.users.password_hash`，不得写现有平台任一业务表。
+- 模型平台不写判级、处理、报告、流程或配置表。
+- “手工同步”不再复制数据；其含义调整为“校验最新发布批次并重建派生判级”。
+- 报告汇总、知识库和工作台不单独建冗余汇总表，首期由业务表查询生成。
+
+## 3. 总体架构
+
+现有服务拓扑保持不变。运维能力作为 FastAPI 后端内的新 bounded context 接入，但增加第二套数据库连接：
+
+1. 浏览器继续经 Nginx 访问 React SPA 和同源 `/api/v1/*`。
+2. `DATABASE_URL` 继续连接 `model_platform`，只承担现有认证、工作空间、存储和调度能力。
+3. 新增 `OPERATIONS_DATABASE_URL` 连接 `model_operations`，承载全部运维业务数据。
+4. 模型平台模块或调度任务直接写新库的 `ops_*` 源表。
+5. 批次发布后，运维服务计算并保存规则判级快照。
+6. 运维 API 联查新库源数据、判级和处理结果；用户显示名等按需只读平台库。
+7. 报告生成、提醒等动作写新库 `ops_outbox_events`；接入异步阶段时让 Schedule Executor 增加运维库轮询连接。
+8. 报告文件、流程材料继续复用平台库 `storage_objects` 与现有对象存储服务，运维库只保存对象 ID。
+
+配套图：
+
+- `A卡模型运维模块-系统架构-V0.2.png/.svg`
+- `A卡模型运维模块-数据域关系-V0.2.png/.svg`
+
+修改 YAML 后运行 `python3 docs/architecture/render_diagrams.py` 可重新生成两种格式；脚本依赖 `diagrams`、`pyyaml` 和本机 Graphviz。
+
+配套建库建表脚本位于 `docs/database/model_operations-V0.1/`，包含 24 张表、1 个视图、四类模型大类种子数据和静态安全校验脚本；原始平台 DDL 已只读归档到 `docs/database/reference/`。
+
+## 4. 数据设计约定
+
+- 表名前缀统一为 `ops_`，与现有模型平台表隔离。
+- 全部 `ops_*` 对象均位于独立 `model_operations` 库。
+- 主键统一使用 ULID `CHAR(26)`；日期时间统一 `DATETIME(3)`。
+- 月份在库内用 `DATE` 且固定为当月 1 日，API 序列化为 `YYYY-MM`。
+- KS、PSI、IV、CSI、坏账率和降幅在数据库中统一存 **0～1 比率**，使用 `DECIMAL(12,8)`；API 转换为 0～100 的百分数。
+- 沿用当前仓库约定：不创建物理外键，使用 `fk_*` 逻辑索引并在服务层校验完整性。
+- 可修改业务状态表使用 `state_version INTEGER` 做乐观锁。
+- 需要删除的配置或流程数据采用 `is_deleted`、`deleted_at` 软删除；监控历史不允许删除。
+- 所有根业务表包含 `workspace_id`，避免未来多个项目空间数据串用。
+- `workspace_id/user_id/storage_object_id/platform_versions_id` 是对 `model_platform` 的逻辑引用，不建立跨库物理外键。
+
+## 5. 表清单与归属
+
+### 5.1 模型平台可写源表（7 张）
+
+| 表 | 用途 | 核心唯一性 |
+|---|---|---|
+| `ops_banks` | 银行主数据及无极银行标记 | `(workspace_id, bank_code)` |
+| `ops_model_instances` | 银行下的模型实例、通用模型关系、当前版本 | `(workspace_id, model_id)` |
+| `ops_model_versions` | 版本、开发指标和生命周期日期 | `(model_instance_id, version_label)` |
+| `ops_monitor_batches` | 月度写入批次、修订号、发布状态和校验和 | `(workspace_id, source_system, monitor_month, revision_no)` |
+| `ops_monitor_results` | 模型单月原始排序性、KS、PSI和样本量 | `(batch_id, model_instance_id)` |
+| `ops_monitor_feature_metrics` | 单月特征级 IV、CSI及贡献变化 | `(monitor_result_id, feature_code)` |
+| `ops_monitor_distributions` | 评分分箱或特征分箱的基准期/当期分布 | `(monitor_result_id, dimension_type, feature_code, bin_order)` |
+
+`ops_model_categories` 为运维模块维护的固定字典，模型平台只有读取权限。首期种子为 `std / bai / big / afd` 四类。
+
+### 5.2 运维模块独占业务表（15 张）
+
+| 数据域 | 表 |
+|---|---|
+| 字典 | `ops_model_categories` |
+| 判级与处理 | `ops_rule_versions`、`ops_rule_items`、`ops_monitor_evaluations`、`ops_monitor_reviews` |
+| 报告治理 | `ops_reports`、`ops_report_revisions`、`ops_report_template_versions`、`ops_prompt_versions`、`ops_prompt_regression_runs`、`ops_bank_report_configs` |
+| 流程与材料 | `ops_workflows`、`ops_workflow_stages`、`ops_documents` |
+| 使用统计 | `ops_usage_events` |
+
+不新增通知任务表；通知和后台报告任务复用新库 `ops_outbox_events`。若后续需要展示逐次送达结果，再增通知投递日志表。
+
+### 5.3 运维库技术表（2 张）
+
+- `ops_outbox_events`：与运维业务写入同事务提交的后台事件。
+- `ops_consumer_inbox`：异步消费者幂等去重。
+
+新库合计 **24 张表 + 1 个当前监控结果视图**。不直接写 `model_platform.outbox_events`，防止运维事件污染现有模型调度事件流。
+
+## 6. 核心表字段初稿
+
+### 6.1 模型与版本
+
+`ops_model_instances`
+
+- `model_instance_id`、`workspace_id`、`bank_id`、`category_id`
+- `model_id`、`model_name`、`model_status`
+- `current_version_id`
+- `is_common_model`、`common_source_model_id`、`common_model_name`
+- `source_updated_at`、`created_at`、`updated_at`
+
+`ops_model_versions`
+
+- `model_version_id`、`model_instance_id`、`version_label`、`version_status`
+- `developer_user_ref`、`developer_display_name`
+- `development_date`、`iteration_start_date`、`last_iteration_date`、`iteration_reason`
+- `escort_start_date`、`escort_end_date`、`online_date`、`offline_date`
+- `development_ks`、`development_psi`、`max_lift`
+- `scoring_logic_storage_object_id`、`source_updated_at`
+
+模型实例只保存当前版本指针，所有生命周期和开发指标按版本留存。
+
+### 6.2 监控批次和原始结果
+
+`ops_monitor_batches`
+
+- `batch_id`、`workspace_id`、`source_system`、`source_batch_no`
+- `monitor_month`、`revision_no`
+- `batch_status`：`writing / published / failed / superseded`
+- `expected_model_count`、`written_model_count`、`feature_row_count`、`distribution_row_count`
+- `checksum_sha256`、`generated_at`、`published_at`、`failed_reason`
+
+`ops_monitor_results`
+
+- `monitor_result_id`、`batch_id`、`model_instance_id`、`model_version_id`、`monitor_month`
+- `ranking_result`：`matched / unmatched / not_applicable`
+- `ks_value`、`psi_value`
+- `sample_count`、`good_count`、`bad_count`
+- `source_result_json`：仅保存尚未结构化且确有追溯价值的源字段
+- `calculated_at`、`created_at`
+
+源表不保存 A/B/C、异常等级、处理建议或报告状态，避免两个模块同时改一行。
+
+### 6.3 判级快照
+
+`ops_monitor_evaluations`
+
+- `evaluation_id`、`monitor_result_id`、`rule_version_id`、`rule_item_id`
+- `ks_mom_drop_rate`、`secondary_level2_hits_6m`
+- `abnormal_level`：`normal / level1 / level2 / level3`
+- `monitor_grade`：`A / B / C`
+- `reason_code`、`reason_text_snapshot`、`action_snapshot`
+- `is_current`、`evaluated_at`
+
+每次规则发布或源数据修订都新增判级记录；旧快照不覆盖。页面默认读取 `is_current=1` 的记录，历史报告仍绑定生成时的判级快照。
+
+### 6.4 两段处理
+
+`ops_monitor_reviews`
+
+- `review_id`、`monitor_result_id`、`evaluation_id`
+- `review_stage`：`model_initial / business_final`
+- `review_status`：`pending / handled / auto_closed`
+- `decision`：`no_action / tune_or_rebuild`
+- `handling_note`（手工处理必填）
+- `due_at`、`handled_by`、`handled_at`、`auto_closed_at`
+- `state_version`、`created_at`、`updated_at`
+
+唯一约束为 `(monitor_result_id, review_stage)`。模型团队阶段完成后才创建或激活业务团队阶段；超时任务通过 Outbox 执行默认“不处理”。
+
+### 6.5 报告
+
+`ops_reports` 保存报告主状态与绑定快照，`ops_report_revisions` 保存每次正文修改：
+
+- 报告绑定 `monitor_result_id + evaluation_id + template_version_id + prompt_version_id`。
+- `ops_report_revisions` 使用 `(report_id, revision_no)` 唯一约束，正文和结构化快照均不可变。
+- 监控报告页默认只查询最新监控月份；报告汇总页查询全部历史。数据库不删除旧月份报告。
+- PDF/Excel 等文件通过 `storage_object_id` 指向现有 `storage_objects`。
+
+### 6.6 流程、材料与知识库
+
+- `ops_workflows`：银行、模型大类、模型实例、独立开发/复用通用模型、当前阶段、状态和计划日期。
+- `ops_workflow_stages`：1～7 阶段实例、负责人角色、开始/截止/完成时间、确认状态和停滞天数。
+- `ops_documents`：同时支持 `storage_object_id` 和 `external_url`，可关联流程、阶段、模型和版本。
+- 知识库不是新表，而是对 `ops_documents` 按银行、模型、版本、环节和通用模型标记查询。
+
+## 7. 发布协议
+
+模型平台每次写入必须执行以下协议：
+
+1. 创建 `ops_monitor_batches`，状态为 `writing`，携带幂等的 `source_batch_no`。
+2. 幂等写入银行、模型实例和版本；插入本批次结果、特征指标和分布。
+3. 校验模型数、明细行数、必填字段、指标范围和 SHA-256 校验和。
+4. 在一个短事务内将批次改为 `published`；同月份上一修订改为 `superseded`。
+5. 写入 `monitor_batch.published` Outbox 事件，触发运维模块生成判级快照。
+6. 运维查询只允许关联 `published` 批次，并按最高修订号取当前结果。
+
+失败批次保留为 `failed` 供排查。任何已发布结果、特征和分布均不得执行 `UPDATE` 或物理删除。
+
+## 8. 数据库权限
+
+建议生产环境至少分四类账号：
+
+| 账号 | 权限 |
+|---|---|
+| `schema_migrator` | 仅部署时使用，可对 `model_operations` 执行 DDL；不改 `model_platform` |
+| `platform_reader` | 对平台库指定字段只读；禁止读取密码散列和权限内部表 |
+| `model_writer` | 读取字典；对新库 7 张源表执行限定 `SELECT/INSERT/UPDATE`，并插入发布事件；无 `DELETE`，不能写运维独占表 |
+| `operations_app` | 读写运维库；只读平台库必要表；服务层禁止修改已发布源结果 |
+
+若模型任务与运维 API 暂时运行在同一 FastAPI 进程，代码层仍按平台库/运维库两个 session factory 和 repository 隔离；生产批处理脚本优先使用独立 `MODEL_WRITER_DATABASE_URL`，将权限边界落实到数据库。
+
+## 9. API 设计
+
+### 9.1 首条真实纵向链路
+
+保持前端已写好的路径，不重新发明契约：
+
+| 接口 | 主要数据来源 |
+|---|---|
+| `GET /api/v1/operations/models` | 模型实例 + 当前版本 + 最新已发布结果 + 当前判级 + 最近处理 |
+| `GET /api/v1/operations/models/{model_id}` | 单模型完整元数据和最新状态 |
+| `GET /api/v1/operations/models/{model_id}/monitor-results?month=YYYY-MM` | 指定月最新已发布修订 + 当前判级 |
+
+所有接口返回现有 `{ data, meta? }` 包装。切换 `VITE_OPERATIONS_API_MODE=api` 前，前端 `operationsApi.ts` 需要统一附加当前 `workspace_id`，用于选择并校验数据空间。
+
+### 9.2 后续资源接口
+
+- 查询：`/model-categories/overview`、`/banks/overview`、`/monitor-results`、`/monitor-results/{id}/features`、`/monitor-results/{id}/distributions`
+- 处理：`/monitor-results/{id}/reviews/model-initial`、`/reviews/business-final`
+- 报告：`/reports`、`/reports/{id}`、`/reports/{id}/revisions`、`/reports/{id}/send`
+- 流程：`/workflows`、`/workflows/{id}`、`/workflows/{id}/stages/{stage}`、`/documents`
+- 治理：`/rule-versions`、`/prompt-versions`、`/report-template-versions`、`/bank-report-configs`
+
+列表统一支持分页、排序和与 V1.9 筛选框一致的查询参数；Excel/PDF 导出走独立端点，不让普通列表接口返回超大数据集。
+
+## 10. 登录与角色
+
+- 不增加运维 RBAC 表，也不接管现有权限管理模块。
+- API 复用登录 Cookie、`Users`、`Roles` 和当前工作空间，不创建新的角色或权限数据。
+- 新增轻量 `operations_context`：校验用户已登录且可访问所选工作空间；业务角色取与 `/api/v1/auth/me`、前端 `AuthUser.role_code` 相同的登录角色来源，避免前后端角色口径不一致。
+- 角色映射约定：`admin` → 管理员；`developer/model_team` → 模型团队；`business/business_team/biz` → 业务团队。
+- 前端按角色决定页面呈现，后端仍必须按角色校验写操作，不能把前端隐藏按钮当安全边界。
+- 角色代码最终值由登录/权限模块给出，运维模块只维护一处映射常量。
+
+## 11. 代码落位建议
+
+沿用现有 router / schema / service 分层，每个文件不超过 500 行：
+
+```text
+common/src/common/db/models/operations/
+ reference.py models.py monitoring.py governance.py
+ reviews.py reports.py workflows.py usage.py
+backend/src/backend/api/operations/
+ __init__.py _deps.py models.py monitoring.py reviews.py
+ reports.py workflows.py governance.py
+backend/src/backend/services/operations/
+ queries.py evaluation.py publishing.py reports.py workflows.py
+backend/src/backend/schemas/operations/
+ common.py models.py monitoring.py reports.py workflows.py governance.py
+```
+
+运维 ORM 使用独立 Alembic 版本线和 `OPERATIONS_DATABASE_URL`，不能让现有 `model_platform` 基线迁移误扫新表。`backend.main` 创建第二个 engine/session factory 并只注册一个 `operations_router`；业务规则不写进路由文件。
+
+## 12. 实施顺序
+
+### P0：首条真实链路
+
+1. DBA 审核并创建 `model_operations`；建模型/版本/批次/结果/特征/分布及规则判级 11 张核心表。
+2. 导入一组 2026-07 样例数据并走完整 `writing → published` 协议。
+3. 实现三条既有 API，前端追加 `workspace_id` 后切到 API 模式。
+4. 验证列表、模型详情、单月监控详情数值一致。
+
+### P1：业务闭环
+
+实现两段复核、报告及修订、七阶段流程、材料和知识库。
+
+### P2：治理与运营
+
+实现规则版本、Prompt 回归、模板版本、使用统计、提醒和导出优化。
+
+## 13. 开发前需共同确认的 5 项
+
+以下均给出推荐默认值；未得到反对意见时可按推荐值实施：
+
+1. **模型 ID 唯一性**：推荐 `model_id` 在工作空间内全局唯一，不只在银行内唯一。
+2. **指标单位**：推荐数据库存 0～1 比率，API 输出百分数；禁止两种单位混写。
+3. **批次粒度**：推荐一个来源系统每月一个全量批次，勘误整体升修订号。
+4. **工作空间范围**：推荐全部根表带 `workspace_id` 并逻辑引用 `model_platform.workspaces`，即使首期只有一个 A 卡项目空间。
+5. **模型开发材料**：推荐运维表同时支持对象存储文件和模型平台链接，避免重复上传。
+
+这 5 项确认后即可开始 ORM、Alembic 迁移和首条真实接口实现。
diff --git a/docs/architecture/A卡模型运维模块-数据域关系-V0.2.png b/docs/architecture/A卡模型运维模块-数据域关系-V0.2.png
new file mode 100644
index 0000000000000000000000000000000000000000..eed4eed998b980ab84cd2b2ff5a7a99e8731f04e
GIT binary patch
literal 445855
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