Merge branch 'main' of github.com:xerrors/Yuxi-Know

Author: xerrors

.env.template

@@ -41,3 +41,6 @@ NEO4J_PASSWORD=
 # Servies
 YUXI_SUPER_ADMIN_NAME=
 YUXI_SUPER_ADMIN_PASSWORD=
+
+# MinerU
+MINERU_API_KEY=

docs/changelog/roadmap.md

@@ -2,39 +2,31 @@
 
 路线图可能会经常变更，如果有强烈的建议，可以在 [issue](https://github.com/xerrors/Yuxi-Know/issues) 中提。
 
-## Version 0.3.x
+- [2025/10/13] 0.3.0 进入 beta 测试环节，不会再封装新的特性，仅作 bug 层面的修复
 
 
-🐛**BUGs**
-- [x] 部分 doc 格式的文件支持有问题
-- [x] 当出现不支持的文件类型的时候，前端没有限制
-- [x] 当消息生成的时候有报错的时候，前端无显示
-- [x] 另外一个智能体的历史对话无法显示
+**Bugs**
 - [ ] 调用统计的统计结果疑似有问题（Token 计算方法可能也不对）
 
 
----
+**Next**
 
-💭 **Features Todo**
-
-- [ ] 添加对于上传文件的支持：这里的复杂的地方就在于如何和历史记录结合在一起（v0.2.3 版本实现，放在记忆管理后面）
-- [ ] 知识图谱的上传和可视化，支持属性，标签的展示
+- [ ] 添加对于上传文件的支持
+- [ ] 知识图谱的上传和可视化，支持属性，标签的展示 <Badge type="info" text="0.4" />
 - [ ] 集成智能体评估，首先使用命令行来实现，然后考虑放在 UI 里面展示
-- [ ] 开发与生产环境隔离
-- [x] 添加统计信息
-- [ ] 支持 MinerU 2.5 的解析方法
-- [x] 移除自定义模型，同时将模型的 env 修改为单环境变量的形式，移除 models.yaml 的私有共有双配置模式，除非配置了环境变量 `OVERRIDE_DEFAULT_MODELS_CONFIG_WITH` 然后指向一个变量。
+- [ ] 开发与生产环境隔离，构建生产镜像 <Badge type="info" text="0.4" />
+- [ ] 支持 MinerU 2.5 的解析方法（含API方法）<Badge type="info" text="0.3.5" />
+- [ ] 优化全局配置的管理模型，优化配置管理
 
-📝 **Base**
+**Later**
 
-- [ ] 优化全局配置的管理模型，以及配置文件的管理，子配置的管理
-- [x] 新建 tasker 模块，用来管理所有的后台任务，UI 上使用侧边栏管理。
-- [ ] 新增 files 模块，用来管理文件上传，下载等
+下面的功能**可能**会放在后续版本实现，暂时未定
 
-## 未来可能会支持
+- [ ] 集成 LangFuse (观望) 添加用户日志与用户反馈模块，可以在 AgentView 中查看信息
+
+**Done**
 
-下面的功能**可能**会放在后续版本实现，暂时未定
 
 - [x] 添加测试脚本，覆盖最常见的功能（已覆盖API）
-- [x] 优化对文档信息的检索展示（检索结果页、详情页）
-- [ ] 集成 LangFuse (观望)添加用户日志与用户反馈模块，可以在 AgentView 中查看信息
+- [x] 新建 tasker 模块，用来管理所有的后台任务，UI 上使用侧边栏管理。
+- [x] 优化对文档信息的检索展示（检索结果页、详情页）

docs/intro/quick-start.md

@@ -14,12 +14,13 @@
 
 ```bash
 # 克隆稳定版本
-git clone --branch 0.2.2 --depth 1 https://github.com/xerrors/Yuxi-Know.git
+git clone --branch v0.2.2 --depth 1 https://github.com/xerrors/Yuxi-Know.git
 cd Yuxi-Know
 ```
 
 ::: warning 版本说明
-- `0.2.2`: 当前稳定版本（推荐）
+- `v0.2.2`: 当前稳定版本（推荐）
+- `v0.3.0-beta`：最新的 Beta 测试版
 - `main`: 最新开发版本（不稳定，新特性可能会导致新 bug）
 :::
 

server/main.py

@@ -1,6 +1,11 @@
+import asyncio
+import time
+from collections import defaultdict, deque
+
 import uvicorn
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, status
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware
 
 from server.routers import router
@@ -11,6 +16,14 @@
 # 设置日志配置
 setup_logging()
 
+RATE_LIMIT_MAX_ATTEMPTS = 10
+RATE_LIMIT_WINDOW_SECONDS = 60
+RATE_LIMIT_ENDPOINTS = {("/api/auth/token", "POST")}
+
+# In-memory login attempt tracker to reduce brute-force exposure per worker
+_login_attempts: defaultdict[str, deque[float]] = defaultdict(deque)
+_attempt_lock = asyncio.Lock()
+
 app = FastAPI()
 app.include_router(router, prefix="/api")
 
@@ -24,6 +37,51 @@
 )
 
 
+def _extract_client_ip(request: Request) -> str:
+    forwarded_for = request.headers.get("x-forwarded-for")
+    if forwarded_for:
+        return forwarded_for.split(",")[0].strip()
+    if request.client:
+        return request.client.host
+    return "unknown"
+
+
+class LoginRateLimitMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        normalized_path = request.url.path.rstrip("/") or "/"
+        request_signature = (normalized_path, request.method.upper())
+
+        if request_signature in RATE_LIMIT_ENDPOINTS:
+            client_ip = _extract_client_ip(request)
+            now = time.monotonic()
+
+            async with _attempt_lock:
+                attempt_history = _login_attempts[client_ip]
+
+                while attempt_history and now - attempt_history[0] > RATE_LIMIT_WINDOW_SECONDS:
+                    attempt_history.popleft()
+
+                if len(attempt_history) >= RATE_LIMIT_MAX_ATTEMPTS:
+                    retry_after = int(max(1, RATE_LIMIT_WINDOW_SECONDS - (now - attempt_history[0])))
+                    return JSONResponse(
+                        status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+                        content={"detail": "登录尝试过于频繁，请稍后再试"},
+                        headers={"Retry-After": str(retry_after)},
+                    )
+
+                attempt_history.append(now)
+
+            response = await call_next(request)
+
+            if response.status_code < 400:
+                async with _attempt_lock:
+                    _login_attempts.pop(client_ip, None)
+
+            return response
+
+        return await call_next(request)
+
+
 # 鉴权中间件
 class AuthMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next):
@@ -58,6 +116,7 @@ async def dispatch(self, request: Request, call_next):
 
 
 # 添加鉴权中间件
+app.add_middleware(LoginRateLimitMiddleware)
 app.add_middleware(AuthMiddleware)
 
 

server/routers/auth_router.py

@@ -1,4 +1,3 @@
-from datetime import datetime
 import re
 
 from fastapi import APIRouter, Depends, HTTPException, Request, status, UploadFile, File
@@ -13,6 +12,7 @@
 from server.utils.user_utils import generate_unique_user_id, validate_username, is_valid_phone_number
 from server.utils.common_utils import log_operation
 from src.storage.minio import upload_image_to_minio
+from src.utils.datetime_utils import utc_now
 
 # 创建路由器
 auth = APIRouter(prefix="/auth", tags=["authentication"])
@@ -151,7 +151,7 @@ async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(
 
     # 登录成功，重置失败计数器
     user.reset_failed_login()
-    user.last_login = datetime.now()
+    user.last_login = utc_now()
     db.commit()
 
     # 生成访问令牌
@@ -220,7 +220,7 @@ async def initialize_admin(admin_data: InitializeAdmin, db: Session = Depends(ge
         avatar=None,  # 初始化时头像为空
         password_hash=hashed_password,
         role="superadmin",
-        last_login=datetime.now(),
+        last_login=utc_now(),
     )
 
     db.add(new_admin)
@@ -527,7 +527,7 @@ async def delete_user(
     hash_suffix = hashlib.md5(user.user_id.encode()).hexdigest()[:4]
 
     user.is_deleted = 1
-    user.deleted_at = datetime.now()
+    user.deleted_at = utc_now()
     user.username = f"已注销用户-{hash_suffix}"
     user.phone_number = None  # 清空手机号，释放该手机号供其他用户使用
     user.password_hash = "DELETED"  # 禁止登录

server/routers/chat_router.py

@@ -306,7 +306,11 @@ async def stream_messages():
                 else:
                     yield make_chunk(msg=msg.model_dump(), metadata=metadata, status="loading")
 
-            if conf.enable_content_guard and hasattr(full_msg, "content") and await content_guard.check(full_msg.content):
+            if (
+                conf.enable_content_guard
+                and hasattr(full_msg, "content")
+                and await content_guard.check(full_msg.content)
+            ):
                 logger.warning("Sensitive content detected in final message")
                 yield make_chunk(message="检测到敏感内容，已中断输出", status="error")
                 return

server/routers/dashboard_router.py

@@ -16,6 +16,7 @@
 from server.utils.auth_middleware import get_db
 from src.storage.conversation import ConversationManager
 from src.storage.db.models import User
+from src.utils.datetime_utils import UTC, ensure_shanghai, shanghai_now, utc_now
 from src.utils.logging_config import logger
 
 
@@ -231,7 +232,7 @@ async def get_user_activity_stats(
     try:
         from src.storage.db.models import User, Conversation
 
-        now = datetime.utcnow()
+        now = utc_now()
 
         # Conversations may store either the numeric user primary key or the login user_id string.
         # Join condition accounts for both representations.
@@ -305,7 +306,7 @@ async def get_tool_call_stats(
     try:
         from src.storage.db.models import ToolCall
 
-        now = datetime.utcnow()
+        now = utc_now()
 
         # 基础工具调用统计
         total_calls = db.query(func.count(ToolCall.id)).scalar() or 0
@@ -746,26 +747,30 @@ async def get_call_timeseries_stats(
         from src.storage.db.models import Conversation, Message, ToolCall
 
         # 计算时间范围（使用北京时间 UTC+8）
-        now = datetime.utcnow()
+        now = utc_now()
+        local_now = shanghai_now()
 
         if time_range == "7hours":
             intervals = 7
             # 包含当前小时：从6小时前开始
             start_time = now - timedelta(hours=intervals - 1)
-            # SQLite compatible approach: 使用datetime函数转换UTC时间为北京时间
             group_format = func.strftime("%Y-%m-%d %H:00", func.datetime(Message.created_at, "+8 hours"))
+            base_local_time = ensure_shanghai(start_time)
         elif time_range == "7weeks":
             intervals = 7
-            # 包含当前周：从6周前开始
-            start_time = now - timedelta(weeks=intervals - 1)
-            # SQLite compatible approach: 使用datetime函数转换UTC时间为北京时间
+            # 包含当前周：从6周前开始，并对齐到当周周一 00:00
+            local_start = local_now - timedelta(weeks=intervals - 1)
+            local_start = local_start - timedelta(days=local_start.weekday())
+            local_start = local_start.replace(hour=0, minute=0, second=0, microsecond=0)
+            start_time = local_start.astimezone(UTC)
             group_format = func.strftime("%Y-%W", func.datetime(Message.created_at, "+8 hours"))
+            base_local_time = local_start
         else:  # 7days (default)
             intervals = 7
             # 包含当前天：从6天前开始
             start_time = now - timedelta(days=intervals - 1)
-            # SQLite compatible approach: 使用datetime函数转换UTC时间为北京时间
             group_format = func.strftime("%Y-%m-%d", func.datetime(Message.created_at, "+8 hours"))
+            base_local_time = ensure_shanghai(start_time)
 
         # 根据类型查询数据
         if type == "models":
@@ -783,22 +788,23 @@ async def get_call_timeseries_stats(
                 .order_by(group_format)
             )
         elif type == "agents":
-            # 智能体调用统计（基于对话数量，按智能体分组）
+            # 智能体调用统计（基于对话更新时间，按智能体分组）
             # 为对话创建独立的时间格式化器
             if time_range == "7hours":
-                conv_group_format = func.strftime("%Y-%m-%d %H:00", func.datetime(Conversation.created_at, "+8 hours"))
+                conv_group_format = func.strftime("%Y-%m-%d %H:00", func.datetime(Conversation.updated_at, "+8 hours"))
             elif time_range == "7weeks":
-                conv_group_format = func.strftime("%Y-%W", func.datetime(Conversation.created_at, "+8 hours"))
+                conv_group_format = func.strftime("%Y-%W", func.datetime(Conversation.updated_at, "+8 hours"))
             else:  # 7days
-                conv_group_format = func.strftime("%Y-%m-%d", func.datetime(Conversation.created_at, "+8 hours"))
+                conv_group_format = func.strftime("%Y-%m-%d", func.datetime(Conversation.updated_at, "+8 hours"))
 
             query = (
                 db.query(
                     conv_group_format.label("date"),
                     func.count(Conversation.id).label("count"),
                     Conversation.agent_id.label("category"),
                 )
-                .filter(Conversation.created_at >= start_time)
+                .filter(Conversation.updated_at.isnot(None))
+                .filter(Conversation.updated_at >= start_time)
                 .group_by(conv_group_format, Conversation.agent_id)
                 .order_by(conv_group_format)
             )
@@ -894,8 +900,16 @@ async def get_call_timeseries_stats(
 
         # 重新组织数据：按时间点分组每个类别的数据
         time_data = {}
+
+        def normalize_week_key(raw_key: str) -> str:
+            base_date = datetime.strptime(f"{raw_key}-1", "%Y-%W-%w")
+            iso_year, iso_week, _ = base_date.isocalendar()
+            return f"{iso_year}-{iso_week:02d}"
+
         for result in results:
             date_key = result.date
+            if time_range == "7weeks":
+                date_key = normalize_week_key(date_key)
             category = getattr(result, "category", "unknown")
             count = result.count
 
@@ -906,8 +920,8 @@ async def get_call_timeseries_stats(
 
         # 填充缺失的时间点（使用北京时间）
         data = []
-        # 从start_time开始，转换为北京时间
-        current_time = start_time + timedelta(hours=8)
+        # 从起始点开始（北京时间）
+        current_time = base_local_time
 
         if time_range == "7hours":
             delta = timedelta(hours=1)
@@ -920,9 +934,8 @@ async def get_call_timeseries_stats(
             if time_range == "7hours":
                 date_key = current_time.strftime("%Y-%m-%d %H:00")
             elif time_range == "7weeks":
-                # 计算ISO周数
-                week_num = current_time.isocalendar()[1]
-                date_key = f"{current_time.year}-{week_num:02d}"
+                iso_year, iso_week, _ = current_time.isocalendar()
+                date_key = f"{iso_year}-{iso_week:02d}"
             else:
                 date_key = current_time.strftime("%Y-%m-%d")
 

server/services/tasker.py

@@ -3,20 +3,20 @@
 import os
 import uuid
 from dataclasses import asdict, dataclass, field
-from datetime import datetime
 from pathlib import Path
 from typing import Any
 from collections.abc import Awaitable, Callable
 
 from src.config import config
 from src.utils.logging_config import logger
+from src.utils.datetime_utils import utc_isoformat
 
 TaskCoroutine = Callable[["TaskContext"], Awaitable[Any]]
 TERMINAL_STATUSES = {"success", "failed", "cancelled"}
 
 
 def _utc_timestamp() -> str:
-    return datetime.utcnow().isoformat() + "Z"
+    return utc_isoformat()
 
 
 @dataclass
@@ -142,7 +142,7 @@ async def list_tasks(self, status: str | None = None) -> list[dict[str, Any]]:
             tasks = list(self._tasks.values())
         if status:
             tasks = [task for task in tasks if task.status == status]
-        tasks.sort(key=lambda item: item.created_at, reverse=True)
+        tasks.sort(key=lambda item: item.created_at or utc_isoformat(), reverse=True)
         return [task.to_dict() for task in tasks]
 
     async def get_task(self, task_id: str) -> dict[str, Any] | None: