提交 073bfdf2 authored 作者: caifuming's avatar caifuming

修改识别PDF,下载了OCR模型

上级 ed020ab6
# Docker 恢复情况报告
## 恢复状态总结
### ✅ 已成功恢复
1. **Docker 服务** - 已重新安装并运行
- 版本: Docker 29.1.3
- 状态: Active (running)
2. **容器元数据** - 23 个容器信息保留
```
- e75819f0b6e4 (Redis)
- 77570a71a0ba, 879e649b5e19 (应用容器)
- 21accd10593c, 91870c6b2ead (测试容器)
- a90b4ec6bba6 (code-server)
- 504303ba3e2b, de6072c667f5, 4b6e3ca53085 (监控服务)
- f060ff22099d, fed7b241ae41 (MySQL)
- 4c2e7e92150c, b4edca519a12 (Milvus + etcd)
- 以及其他应用容器
```
3. **Docker 卷** - 19 个卷完整保留
```
- ai-assitant_redis_data
- compose_etcd-data
- compose_milvus-data
- compose_minio-data
- jenkins_home
- studyweb_loki_data
- studyweb_minio_data
- studyweb_mysql_data
- studyweb_redis_data
- 以及其他数据卷
```
### ❌ 无法恢复
1. **Docker 镜像** - 所有镜像数据已丢失
- 原因: 清理 `/var/lib/containerd` 时删除了镜像存储层
- 影响: 无法直接启动现有容器
2. **镜像层数据** - 底层文件系统数据被清理
- 位置: `/var/lib/docker/overlay2/` (已清空)
- 结果: 容器文件系统不可用
---
## 问题原因分析
在清理根分区空间时,执行了以下操作:
```bash
# 这一步删除了 containerd 的所有数据,包括 Docker 镜像层
sudo rm -rf /var/lib/containerd/*
# 之后又删除了整个目录
sudo rm -rf /var/lib/containerd
```
**containerd 是 Docker 的底层运行时**,它存储了:
- 镜像层 (image layers)
- 容器快照 (container snapshots)
- 镜像元数据 (image metadata)
删除这些数据后,虽然容器配置还在 `/var/lib/docker/containers/`,但实际的镜像文件已经无法恢复。
---
## 当前系统状态
### Docker 服务
```bash
$ docker --version
Docker version 29.1.3
$ sudo systemctl status docker
● docker.service - Docker Application Container Engine
Active: active (running)
```
### 容器状态
```bash
$ docker ps -a | wc -l
23 # 23 个容器(全部 Exited 状态)
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
# 空的 - 所有镜像丢失
```
### 数据卷状态
```bash
$ docker volume ls | wc -l
19 # 19 个卷完整保留
```
---
## 解决方案
### 方案 1: 重新拉取镜像并重建容器 (推荐)
由于容器配置还在,可以查看容器使用的镜像名称,然后重新拉取:
```bash
# 查看容器信息(虽然镜像 ID 存在,但无法解析名称)
docker inspect <container_id> | grep Image
# 根据你的项目重新拉取镜像
# 例如 RAGFlow 项目:
cd /datacore/ragflow
docker compose -f docker/docker-compose-base.yml pull
docker compose -f docker/docker-compose-base.yml up -d
# Redis
docker pull redis:latest
# MySQL
docker pull mysql:8.0
# Elasticsearch
docker pull elasticsearch:8.9.0
# MinIO
docker pull minio/minio:latest
# 其他常用镜像
docker pull python:3.10
docker pull node:18
```
### 方案 2: 使用备份恢复 (如果有)
如果你有 Docker 镜像备份:
```bash
# 从 tar 文件加载镜像
docker load -i backup_images.tar
# 或从备份目录恢复
# (需要有完整的 /var/lib/docker 备份)
```
### 方案 3: 清理旧容器,重新开始
```bash
# 停止并删除所有容器
docker stop $(docker ps -aq) 2>/dev/null
docker rm $(docker ps -aq) 2>/dev/null
# 清理无用的卷(可选,谨慎操作)
# docker volume prune
# 重新创建服务
cd /datacore/ragflow
docker compose -f docker/docker-compose-base.yml up -d
```
---
## RAGFlow 服务启动指南
现在 Docker 已恢复,可以启动 RAGFlow 了:
### 1. 启动 RAGFlow 基础服务
```bash
cd /datacore/ragflow
# 拉取并启动基础服务
docker compose -f docker/docker-compose-base.yml pull
docker compose -f docker/docker-compose-base.yml up -d
# 等待服务启动
sleep 30
# 检查服务状态
docker compose -f docker/docker-compose-base.yml ps
```
### 2. 安装前端依赖(首次)
```bash
cd /datacore/ragflow/web
npm install
```
### 3. 启动 RAGFlow 应用
```bash
cd /datacore/ragflow
./scripts/ragflow_service.sh start
```
### 4. 查看服务状态
```bash
./scripts/ragflow_service.sh status
./scripts/ragflow_service.sh logs
```
---
## 验证 Docker 功能
```bash
# 测试 Docker 是否正常工作
docker run hello-world
# 查看 Docker 信息
docker info
# 检查存储驱动
docker info | grep "Storage Driver"
```
---
## 数据卷说明
**好消息**: 你的数据卷都还在,这些包含重要数据:
| 卷名称 | 用途 | 状态 |
|--------|------|------|
| studyweb_mysql_data | MySQL 数据库数据 | ✅ 保留 |
| studyweb_redis_data | Redis 缓存数据 | ✅ 保留 |
| studyweb_minio_data | MinIO 对象存储 | ✅ 保留 |
| compose_milvus-data | Milvus 向量数据库 | ✅ 保留 |
| jenkins_home | Jenkins 配置和数据 | ✅ 保留 |
重新创建容器时,只要使用相同的卷名称,数据就能恢复。
---
## 预防措施
为避免将来再次发生类似问题:
### 1. 定期备份 Docker 镜像
```bash
# 导出所有镜像
docker save $(docker images -q) -o /datacore/docker-images-backup.tar
# 或导出特定镜像
docker save redis:latest -o redis.tar
```
### 2. 使用 Docker 数据根目录迁移
将 Docker 数据移到空间充足的分区:
```bash
# 停止 Docker
sudo systemctl stop docker
# 移动数据
sudo mv /var/lib/docker /datacore/docker-data
# 创建软链接
sudo ln -s /datacore/docker-data /var/lib/docker
# 启动 Docker
sudo systemctl start docker
```
### 3. 清理空间时避免删除关键目录
**永远不要删除这些目录**:
- `/var/lib/docker/` - Docker 数据
- `/var/lib/containerd/` - containerd 运行时
- `/var/lib/kubelet/` - Kubernetes 数据(如果使用)
**安全的清理方法**:
```bash
# 清理 Docker 未使用资源
docker system prune -a
# 清理旧镜像
docker image prune -a
# 清理 build 缓存
docker builder prune -a
```
---
## 当前行动建议
立即执行以下步骤启动 RAGFlow:
```bash
# 1. 进入 RAGFlow 目录
cd /datacore/ragflow
# 2. 启动基础服务(会自动拉取镜像)
docker compose -f docker/docker-compose-base.yml up -d
# 3. 等待服务启动
sleep 60
# 4. 检查服务
docker compose -f docker/docker-compose-base.yml ps
# 5. 如果前端依赖未安装
cd web && npm install
# 6. 启动 RAGFlow
cd ..
./scripts/ragflow_service.sh start
```
---
## 总结
- ✅ Docker 服务已成功恢复
- ✅ 容器配置和数据卷完整保留
- ❌ 镜像需要重新拉取(无法恢复)
- ⚠️ 需要重新部署所有服务
**预计时间**: 重新拉取镜像和启动服务约需 10-20 分钟(取决于网络速度)
**数据安全**: 你的数据卷都在,重新创建容器后数据会自动恢复
# RAGFlow OCR 模型要求和验证方案
## 一、必需的模型文件清单
需要从 HuggingFace 仓库 `InfiniFlow/deepdoc` 下载以下文件到 `/datacore/ragflow/rag/res/deepdoc/` 目录:
### 1. OCR 核心模型(必需)
- **det.onnx** - 文本检测模型(识别文本区域)
- 格式:ONNX Runtime 模型
- 功能:检测图片中的文字区域,返回四边形边界框
- 预期大小:约 2-5 MB
- **rec.onnx** - 文本识别模型(识别文字内容)
- 格式:ONNX Runtime 模型
- 功能:识别裁剪后的文字区域内容
- **关键要求**:必须是支持中文的版本(PP-OCRv4 中文模型)
- 预期大小:约 10-15 MB
- 输入shape:[batch, 3, 48, 320]
- **ocr.res** - 字符字典文件
- 格式:文本文件,每行一个字符
- 功能:定义模型可识别的字符集
- **关键要求**:必须包含完整的中文字符集(简体+繁体)
- 预期大小:约 100-200 KB
- 预期字符数:7000+ 中文字符
### 2. 版面分析模型(可选但推荐)
- **layout.onnx** - 版面识别模型
- 格式:ONNX Runtime 模型
- 功能:识别文档版面结构(标题、段落、表格等)
- 预期大小:约 5-10 MB
### 3. 表格识别模型(可选)
- **tsr.onnx** - 表格结构识别模型
- 格式:ONNX Runtime 模型
- 功能:识别表格的行列结构
- 预期大小:约 3-8 MB
### 4. XGBoost 模型(PDF解析用)
- **updown_concat_xgb.model** - 文本拼接模型
- 格式:XGBoost 模型文件
- 功能:判断文本块的上下连接关系
- 预期大小:约 50-200 KB
## 二、中文质量评估标准
### 关键指标:
1. **字符覆盖率**
- 必须支持 GB2312(6763个常用汉字)
- 推荐支持 GBK/GB18030(21000+汉字)
- 必须支持常见标点符号和数字
2. **识别准确率**(在测试图片上)
- 简体中文识别率 > 90%
- 不应该出现"贴佟撩攘尔可"这种完全错误的输出
- 相似字混淆率 < 5%(如"己"和"已")
3. **模型来源验证**
- 必须是 PP-OCRv4 或更新版本
- 来自百度 PaddleOCR 官方训练的中文模型
- 不能用纯英文模型+中文字典的组合
## 三、验证方案
### 步骤1:检查模型元数据
```python
import onnx
model = onnx.load("rec.onnx")
print("模型输入:", model.graph.input[0])
print("模型输出:", model.graph.output[0])
print("模型版本:", model.producer_name)
```
### 步骤2:检查字符字典
```bash
# 统计字符数
wc -l ocr.res
# 检查是否包含中文
head -100 ocr.res | grep -P '[\x{4e00}-\x{9fa5}]'
# 验证常用汉字
echo "的一是在不了有和人这中大为上个国" | while read -n1 c; do grep -q "$c" ocr.res && echo "✓ $c" || echo "✗ $c"; done
```
### 步骤3:实际识别测试
创建测试脚本测试中文识别质量:
```python
from deepdoc.vision.ocr import OCR
import cv2
# 初始化OCR
ocr = OCR(model_dir="rag/res/deepdoc")
# 读取测试图片(包含中文)
test_image = cv2.imread("test_chinese.png")
# 执行识别
result = ocr(test_image)
# 检查结果
for box, (text, conf) in result:
print(f"识别文本: {text}")
print(f"置信度: {conf}")
print(f"是否包含乱码: {'是' if any(c in text for c in '贴佟撩攘') else '否'}")
```
### 步骤4:与已知文本对比
准备包含以下文本的测试图片:
- "欢迎来到旌渝企业知识库平台"
- "登录旌渝企业知识库平台"
- "姓名:张伟,性别:男"
- "合同编号:2024-001"
识别后对比准确率。
## 四、HuggingFace 仓库信息
**仓库地址**: https://huggingface.co/InfiniFlow/deepdoc
**下载方式**(需要在能访问 HuggingFace 的机器上):
```bash
# 方法1:使用 git-lfs
git lfs install
git clone https://huggingface.co/InfiniFlow/deepdoc
# 方法2:使用 huggingface-cli
pip install huggingface_hub
huggingface-cli download InfiniFlow/deepdoc --local-dir ./deepdoc_models
# 方法3:使用镜像站(如果有)
export HF_ENDPOINT=https://hf-mirror.com
python -c "from huggingface_hub import snapshot_download; snapshot_download('InfiniFlow/deepdoc', local_dir='./models')"
```
## 五、安装说明
下载完成后,将以下文件复制到 `/datacore/ragflow/rag/res/deepdoc/` 目录:
```
rag/res/deepdoc/
├── det.onnx # 必需
├── rec.onnx # 必需
├── ocr.res # 必需
├── layout.onnx # 推荐
├── tsr.onnx # 可选
└── updown_concat_xgb.model # 推荐
```
## 六、常见问题
### Q1: 如何确认下载的是中文模型?
A: 检查 `ocr.res` 文件,应该包含 7000+ 行,且前100行应该有大量中文字符。
### Q2: 模型文件多大算正常?
A:
- det.onnx: 2-5 MB
- rec.onnx: 10-15 MB(中文模型会比英文模型大)
- ocr.res: 100-200 KB
### Q3: 如何验证模型能在 RAGFlow 中使用?
A: 将文件放到正确位置后,重启服务,查看日志应该有:
```
load_model /datacore/ragflow/rag/res/deepdoc/det.onnx uses CPU
load_model /datacore/ragflow/rag/res/deepdoc/rec.onnx uses CPU
```
### Q4: 识别效果差怎么办?
A: 确认:
1. rec.onnx 是 PP-OCRv4 中文模型(不是 v3 或英文模型)
2. ocr.res 包含完整中文字符集
3. 图片质量足够(分辨率 > 300 DPI,无模糊)
## 七、紧急备选方案
如果实在无法下载 HuggingFace 模型,可以考虑:
1. **使用 RAGFlow 的 PaddleOCR API 模式**
- 修改知识库配置,在"分块方法"中使用 `@paddleocr` 后缀
- 需要配置 PADDLEOCR_BASE_URL 环境变量
- 使用在线 API 服务
2. **从其他镜像站下载**
- ModelScope(魔塔)可能有镜像
- 国内其他开源镜像站
3. **联系 RAGFlow 社区**
- GitHub Issues: https://github.com/infiniflow/ragflow/issues
- 可能有国内用户分享的模型文件
# RAGFlow 启动问题解决方案
## 问题总结
RAGFlow 服务启动脚本已创建并修复,但**无法完全启动**,主要原因如下:
### ✅ 已解决的问题
1. **缺少 quart-auth 0.12.0** - 已升级安装
2. **缺少 quart-schema 0.23.0** - 已安装
3. **缺少 .env 配置文件** - 已从示例文件创建
4. **启动脚本缺少环境检查** - 已添加完善的检查逻辑
### ❌ 当前阻塞问题
**RAGFlow 依赖的基础服务未运行:**
| 服务 | 端口 | 状态 | 说明 |
|------|------|------|------|
| MySQL | 3306 | ❌ 未运行 | 数据库服务 |
| Redis | 6379 | ❌ 未运行 | 缓存服务 |
| Elasticsearch | 1200 | ❌ 未运行 | 搜索引擎 |
| MinIO | 9000 | ❌ 未运行 | 对象存储 |
**根本原因:** 系统中**没有安装 Docker**,无法使用 `docker-compose` 启动基础服务。
---
## 解决方案
你有以下几种选择:
### 方案 1: 安装 Docker 并启动基础服务 (推荐)
这是最简单和官方推荐的方式。
#### 步骤 1: 安装 Docker
```bash
# 安装 Docker
sudo apt update
sudo apt install docker.io docker-compose -y
# 启动 Docker 服务
sudo systemctl start docker
sudo systemctl enable docker
# 将当前用户添加到 docker 组(避免每次都用 sudo)
sudo usermod -aG docker $USER
# 重新登录或执行以下命令使组权限生效
newgrp docker
```
#### 步骤 2: 启动 RAGFlow 基础服务
```bash
cd /datacore/ragflow
docker compose -f docker/docker-compose-base.yml up -d
```
#### 步骤 3: 检查服务状态
```bash
docker compose -f docker/docker-compose-base.yml ps
```
#### 步骤 4: 启动 RAGFlow
```bash
cd /datacore/ragflow
./scripts/ragflow_service.sh start
```
---
### 方案 2: 手动安装并配置基础服务
如果不想使用 Docker,需要手动安装和配置所有服务。
#### 安装 MySQL
```bash
sudo apt install mysql-server -y
sudo systemctl start mysql
sudo systemctl enable mysql
# 创建 RAGFlow 数据库和用户
sudo mysql -e "CREATE DATABASE ragflow CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"
sudo mysql -e "CREATE USER 'ragflow'@'localhost' IDENTIFIED BY 'ragflow_password';"
sudo mysql -e "GRANT ALL PRIVILEGES ON ragflow.* TO 'ragflow'@'localhost';"
sudo mysql -e "FLUSH PRIVILEGES;"
```
#### 安装 Redis
```bash
sudo apt install redis-server -y
sudo systemctl start redis-server
sudo systemctl enable redis-server
```
#### 安装 Elasticsearch
```bash
# 安装 Java (Elasticsearch 依赖)
sudo apt install openjdk-11-jdk -y
# 安装 Elasticsearch
wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -
echo "deb https://artifacts.elastic.co/packages/8.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-8.x.list
sudo apt update
sudo apt install elasticsearch -y
# 配置 Elasticsearch (监听 1200 端口)
sudo nano /etc/elasticsearch/elasticsearch.yml
# 修改: http.port: 1200
sudo systemctl start elasticsearch
sudo systemctl enable elasticsearch
```
#### 安装 MinIO
```bash
# 下载 MinIO
wget https://dl.min.io/server/minio/release/linux-amd64/minio
chmod +x minio
sudo mv minio /usr/local/bin/
# 创建数据目录
sudo mkdir -p /datacore/minio/data
# 创建 MinIO 服务
sudo tee /etc/systemd/system/minio.service > /dev/null <<EOF
[Unit]
Description=MinIO
After=network.target
[Service]
Type=simple
User=admin2
Group=admin2
ExecStart=/usr/local/bin/minio server /datacore/minio/data --address :9000 --console-address :9001
Restart=always
Environment="MINIO_ROOT_USER=admin"
Environment="MINIO_ROOT_PASSWORD=minioadmin"
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl start minio
sudo systemctl enable minio
```
#### 更新 RAGFlow 配置
编辑 `/datacore/ragflow/docker/.env` 文件,配置正确的连接信息:
```bash
# 数据库配置
export MYSQL_HOST=localhost
export MYSQL_PORT=3306
export MYSQL_USER=ragflow
export MYSQL_PASSWORD=ragflow_password
export MYSQL_DB=ragflow
# Redis 配置
export REDIS_HOST=localhost
export REDIS_PORT=6379
# Elasticsearch 配置
export ES_HOST=localhost
export ES_PORT=1200
# MinIO 配置
export MINIO_HOST=localhost:9000
export MINIO_USER=admin
export MINIO_PASSWORD=minioadmin
```
---
### 方案 3: 使用已有的远程服务
如果你的环境中已经有运行的 MySQL、Redis、Elasticsearch 和 MinIO 服务(可能在其他服务器上),可以直接配置连接信息。
编辑 `/datacore/ragflow/docker/.env`:
```bash
# 远程服务配置示例
export MYSQL_HOST=192.168.1.100
export MYSQL_PORT=3306
export MYSQL_USER=ragflow
export MYSQL_PASSWORD=your_password
export MYSQL_DB=ragflow
export REDIS_HOST=192.168.1.101
export REDIS_PORT=6379
export REDIS_PASSWORD=your_redis_password
export ES_HOST=192.168.1.102
export ES_PORT=9200
export MINIO_HOST=192.168.1.103:9000
export MINIO_USER=your_access_key
export MINIO_PASSWORD=your_secret_key
```
然后运行启动脚本:
```bash
cd /datacore/ragflow
./scripts/ragflow_service.sh start
```
---
## 启动脚本功能说明
已创建的启动脚本 `/datacore/ragflow/scripts/ragflow_service.sh` 包含以下功能:
### ✅ 环境检查
- 检查 conda 虚拟环境
- 检查配置文件
- 检查前端依赖
- **检查基础服务连接** (MySQL/Redis/Elasticsearch/MinIO)
### ✅ 服务管理
```bash
./scripts/ragflow_service.sh start # 启动服务
./scripts/ragflow_service.sh stop # 停止服务
./scripts/ragflow_service.sh restart # 重启服务
./scripts/ragflow_service.sh status # 查看状态
./scripts/ragflow_service.sh logs # 查看日志
```
### ✅ 错误提示
- 当基础服务未运行时,会友好提示并询问是否继续
- 显示缺失服务和推荐的解决方法
---
## 前端服务说明
前端服务也需要单独处理:
### 安装前端依赖
```bash
cd /datacore/ragflow/web
# 首次运行需要安装 node_modules
npm install
```
### 注意事项
- 前端需要 **Node.js** 环境
- 检查是否已安装: `node --version` 和 `npm --version`
- 如果未安装,需要先安装 Node.js:
```bash
# 安装 Node.js (推荐使用 nvm)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
source ~/.bashrc
nvm install 18
nvm use 18
```
---
## 完整启动流程
假设选择**方案 1**(推荐),完整流程如下:
```bash
# 1. 安装 Docker
sudo apt update && sudo apt install docker.io docker-compose -y
sudo systemctl start docker
sudo usermod -aG docker $USER
newgrp docker
# 2. 启动基础服务
cd /datacore/ragflow
docker compose -f docker/docker-compose-base.yml up -d
# 3. 等待服务启动(约 30 秒)
sleep 30
# 4. 检查服务状态
docker compose -f docker/docker-compose-base.yml ps
# 5. 安装前端依赖(首次)
cd /datacore/ragflow/web
npm install
# 6. 启动 RAGFlow
cd /datacore/ragflow
./scripts/ragflow_service.sh start
# 7. 查看日志
./scripts/ragflow_service.sh logs
```
---
## 故障排查
### 检查基础服务是否运行
```bash
# 检查 MySQL
nc -zv localhost 3306
# 检查 Redis
nc -zv localhost 6379
# 检查 Elasticsearch
nc -zv localhost 1200
# 检查 MinIO
nc -zv localhost 9000
```
### 查看 Docker 服务日志
```bash
cd /datacore/ragflow
docker compose -f docker/docker-compose-base.yml logs -f
```
### 查看 RAGFlow 日志
```bash
# 后端日志
tail -f /datacore/ragflow/logs/backend.log
# 前端日志
tail -f /datacore/ragflow/logs/frontend.log
```
---
## 当前状态
| 项目 | 状态 | 说明 |
|------|------|------|
| Python 环境 | ✅ 正常 | conda 环境 ragflow,Python 3.13.15 |
| Python 依赖 | ✅ 已安装 | 483 个包,包括 quart-auth 0.12.0, quart-schema 0.23.0 |
| 启动脚本 | ✅ 已创建 | `/datacore/ragflow/scripts/ragflow_service.sh` |
| 配置文件 | ✅ 已创建 | `/datacore/ragflow/docker/.env` |
| MySQL | ❌ 未运行 | 需要安装或启动 |
| Redis | ❌ 未运行 | 需要安装或启动 |
| Elasticsearch | ❌ 未运行 | 需要安装或启动 |
| MinIO | ❌ 未运行 | 需要安装或启动 |
| Docker | ❌ 未安装 | 需要安装 |
| 前端依赖 | ❌ 未安装 | 需要运行 npm install |
---
## 推荐行动
**立即执行(推荐顺序):**
1. ✅ 安装 Docker: `sudo apt install docker.io docker-compose -y`
2. ✅ 启动 Docker: `sudo systemctl start docker`
3. ✅ 启动基础服务: `docker compose -f docker/docker-compose-base.yml up -d`
4. ✅ 安装前端依赖: `cd web && npm install`
5. ✅ 启动服务: `./scripts/ragflow_service.sh start`
---
## 联系支持
如遇到其他问题,请查看:
- RAGFlow 官方文档: https://github.com/infiniflow/ragflow
- 查看日志文件: `/datacore/ragflow/logs/`
- 检查配置文件: `/datacore/ragflow/docker/.env`
{ {
"factory_llm_infos": [ "factory_llm_infos": [
{ {
"name": "OpenAI-API-Compatible", "name": "OpenAI-API-Compatible",
......
...@@ -11,7 +11,7 @@ mysql: ...@@ -11,7 +11,7 @@ mysql:
name: 'rag_flow' name: 'rag_flow'
user: 'root' user: 'root'
password: 'infini_rag_flow' password: 'infini_rag_flow'
host: 'mysql' host: 'localhost'
port: 3306 port: 3306
max_connections: 900 max_connections: 900
stale_timeout: 300 stale_timeout: 300
...@@ -19,7 +19,7 @@ mysql: ...@@ -19,7 +19,7 @@ mysql:
minio: minio:
user: 'rag_flow' user: 'rag_flow'
password: 'infini_rag_flow' password: 'infini_rag_flow'
host: 'localhost:7663' host: 'localhost:9000'
bucket: '' bucket: ''
prefix_path: '' prefix_path: ''
es: es:
...@@ -46,7 +46,7 @@ redis: ...@@ -46,7 +46,7 @@ redis:
db: 0 db: 0
username: '' username: ''
password: 'infini_rag_flow' password: 'infini_rag_flow'
host: 'redis:6379' host: 'localhost:6379'
nats: nats:
host: "localhost" host: "localhost"
port: 4222 port: 4222
......
...@@ -67,6 +67,21 @@ class RAGFlowPdfParser: ...@@ -67,6 +67,21 @@ class RAGFlowPdfParser:
""" """
# 优先使用 PaddleOCR 提供更好的中文识别
use_paddleocr = os.environ.get("USE_PADDLEOCR", "1") == "1"
if use_paddleocr:
try:
from deepdoc.vision.paddleocr_wrapper import PaddleOCRRecognizer
ocr_instance = OCR()
recognizer = PaddleOCRRecognizer(use_gpu=False)
if recognizer.available:
ocr_instance.text_recognizer = [recognizer]
logging.info("✓ 使用 PaddleOCR PP-OCRv5 中文识别器")
self.ocr = ocr_instance
except Exception as e:
logging.warning(f"PaddleOCR 加载失败: {e},使用默认 ONNX OCR")
self.ocr = OCR()
else:
self.ocr = OCR() self.ocr = OCR()
self.parallel_limiter = None self.parallel_limiter = None
if settings.PARALLEL_DEVICES > 1: if settings.PARALLEL_DEVICES > 1:
......
...@@ -524,6 +524,9 @@ class OCR: ...@@ -524,6 +524,9 @@ class OCR:
^_- ^_-
""" """
# Check if PaddleOCR should be used for better Chinese recognition
use_paddleocr = os.environ.get("USE_PADDLEOCR", "1").lower() in ("1", "true", "yes")
if not model_dir: if not model_dir:
try: try:
model_dir = os.path.join(get_project_base_directory(), "rag/res/deepdoc") model_dir = os.path.join(get_project_base_directory(), "rag/res/deepdoc")
...@@ -534,9 +537,35 @@ class OCR: ...@@ -534,9 +537,35 @@ class OCR:
self.text_recognizer = [] self.text_recognizer = []
for device_id in range(settings.PARALLEL_DEVICES): for device_id in range(settings.PARALLEL_DEVICES):
self.text_detector.append(TextDetector(model_dir, device_id)) self.text_detector.append(TextDetector(model_dir, device_id))
if use_paddleocr:
try:
from .paddleocr_wrapper import PaddleOCRRecognizer
recognizer = PaddleOCRRecognizer(use_gpu=False)
if recognizer.available:
self.text_recognizer.append(recognizer)
logging.info(f"使用 PaddleOCR 识别器 (设备 {device_id})")
else:
self.text_recognizer.append(TextRecognizer(model_dir, device_id))
except Exception as e:
logging.warning(f"PaddleOCR 加载失败: {e},使用默认识别器")
self.text_recognizer.append(TextRecognizer(model_dir, device_id))
else:
self.text_recognizer.append(TextRecognizer(model_dir, device_id)) self.text_recognizer.append(TextRecognizer(model_dir, device_id))
else: else:
self.text_detector = [TextDetector(model_dir)] self.text_detector = [TextDetector(model_dir)]
if use_paddleocr:
try:
from .paddleocr_wrapper import PaddleOCRRecognizer
recognizer = PaddleOCRRecognizer(use_gpu=False)
if recognizer.available:
self.text_recognizer = [recognizer]
logging.info("✓ 使用 PaddleOCR 中文识别器")
else:
self.text_recognizer = [TextRecognizer(model_dir)]
except Exception as e:
logging.warning(f"PaddleOCR 加载失败: {e},使用默认识别器")
self.text_recognizer = [TextRecognizer(model_dir)]
else:
self.text_recognizer = [TextRecognizer(model_dir)] self.text_recognizer = [TextRecognizer(model_dir)]
except Exception: except Exception:
...@@ -550,9 +579,31 @@ class OCR: ...@@ -550,9 +579,31 @@ class OCR:
self.text_recognizer = [] self.text_recognizer = []
for device_id in range(settings.PARALLEL_DEVICES): for device_id in range(settings.PARALLEL_DEVICES):
self.text_detector.append(TextDetector(model_dir, device_id)) self.text_detector.append(TextDetector(model_dir, device_id))
if use_paddleocr:
try:
from .paddleocr_wrapper import PaddleOCRRecognizer
recognizer = PaddleOCRRecognizer(use_gpu=False)
if recognizer.available:
self.text_recognizer.append(recognizer)
else:
self.text_recognizer.append(TextRecognizer(model_dir, device_id))
except Exception as e:
self.text_recognizer.append(TextRecognizer(model_dir, device_id))
else:
self.text_recognizer.append(TextRecognizer(model_dir, device_id)) self.text_recognizer.append(TextRecognizer(model_dir, device_id))
else: else:
self.text_detector = [TextDetector(model_dir)] self.text_detector = [TextDetector(model_dir)]
if use_paddleocr:
try:
from .paddleocr_wrapper import PaddleOCRRecognizer
recognizer = PaddleOCRRecognizer(use_gpu=False)
if recognizer.available:
self.text_recognizer = [recognizer]
else:
self.text_recognizer = [TextRecognizer(model_dir)]
except Exception as e:
self.text_recognizer = [TextRecognizer(model_dir)]
else:
self.text_recognizer = [TextRecognizer(model_dir)] self.text_recognizer = [TextRecognizer(model_dir)]
self.drop_score = 0.5 self.drop_score = 0.5
......
# PaddleOCR wrapper for better Chinese OCR recognition
import os
import logging
import numpy as np
class PaddleOCRRecognizer:
"""PaddleOCR 文本识别器包装类,用于替代 ONNX TextRecognizer 提供更好的中文识别"""
def __init__(self, use_gpu=False):
try:
from paddleocr import PaddleOCR
logging.info("初始化 PaddleOCR PP-OCRv5 中文识别引擎...")
# 使用与 contract-ai-service 相同的配置
# PP-OCRv5 是最新版本,识别效果比 v4 更好
profile = os.getenv("OCR_MODEL_PROFILE", "mobile").strip().lower()
model_prefix = "server" if profile == "server" else "mobile"
options = {
"use_angle_cls": True,
"lang": "ch",
"use_gpu": use_gpu,
"show_log": False,
"text_detection_model_name": f"PP-OCRv5_{model_prefix}_det",
"text_recognition_model_name": f"PP-OCRv5_{model_prefix}_rec",
"use_doc_orientation_classify": False,
"use_doc_unwarping": False,
"use_textline_orientation": False,
"text_det_limit_type": "max",
"text_det_limit_side_len": 1200,
"text_recognition_batch_size": 64
}
logging.info(f"使用模型: PP-OCRv5_{model_prefix}_det + PP-OCRv5_{model_prefix}_rec")
try:
self.ocr = PaddleOCR(**options)
logging.info("✓ PaddleOCR PP-OCRv5 初始化成功")
except (TypeError, ValueError) as e:
# 如果 PP-OCRv5 参数不支持,回退到基础配置
logging.warning(f"PP-OCRv5 配置失败,使用默认配置: {e}")
self.ocr = PaddleOCR(use_angle_cls=True, lang='ch', use_gpu=use_gpu, show_log=False)
logging.info("✓ PaddleOCR 默认配置初始化成功")
self.available = True
except ImportError:
logging.warning("PaddleOCR 未安装,将使用默认 ONNX 识别器")
self.available = False
except Exception as e:
logging.warning(f"PaddleOCR 初始化失败: {e},将使用默认 ONNX 识别器")
self.available = False
def __call__(self, img_list):
"""
识别文本图片列表
Args:
img_list: 图片列表 (numpy arrays)
Returns:
识别结果列表 [[(text, confidence)], ...]
"""
if not self.available:
return [[("", 0.0)] for _ in img_list]
rec_res = []
for img in img_list:
try:
# PaddleOCR 识别
# 输入: numpy array 图片
# 输出: [[bbox, (text, confidence)], ...] 或 None
result = self.ocr.ocr(img, cls=True)
if result and result[0]:
# 合并所有识别到的文本
texts = []
confidences = []
for line in result[0]:
if line and len(line) >= 2:
text, conf = line[1]
texts.append(text)
confidences.append(conf)
if texts:
combined_text = " ".join(texts)
avg_confidence = sum(confidences) / len(confidences)
rec_res.append([(combined_text, avg_confidence)])
else:
rec_res.append([("", 0.0)])
else:
rec_res.append([("", 0.0)])
except Exception as e:
logging.warning(f"PaddleOCR 识别失败: {e}")
rec_res.append([("", 0.0)])
return rec_res
def close(self):
"""清理资源"""
if hasattr(self, 'ocr'):
del self.ocr
...@@ -240,17 +240,19 @@ run_mysql_migrations() { ...@@ -240,17 +240,19 @@ run_mysql_migrations() {
} }
prepare_for_go() { prepare_for_go() {
if [ -d /usr/share/infinity/resource ]; then # Use local resource directory instead of /usr/share/infinity (requires root)
RESOURCE_DIR="/datacore/ragflow/resource"
if [ -d "$RESOURCE_DIR" ]; then
echo "Resource directory already exists. Skipping preparation." echo "Resource directory already exists. Skipping preparation."
return return
fi fi
mkdir -p /usr/share/infinity/resource mkdir -p "$RESOURCE_DIR"
if [ "$NEED_MIRROR" == "1" ]; then if [ "$NEED_MIRROR" == "1" ]; then
git clone --depth 1 --single-branch https://gitee.com/infiniflow/resource /tmp/resource; git clone --depth 1 --single-branch https://gitee.com/infiniflow/resource /tmp/resource;
else else
git clone --depth 1 --single-branch https://github.com/infiniflow/resource.git /tmp/resource; git clone --depth 1 --single-branch https://github.com/infiniflow/resource.git /tmp/resource;
fi fi
cp -r /tmp/resource/* /usr/share/infinity/resource cp -r /tmp/resource/* "$RESOURCE_DIR"
rm -rf /tmp/resource rm -rf /tmp/resource
} }
......
# RAGFlow 服务管理脚本使用说明
## 脚本位置
```bash
/datacore/ragflow/ragflow_service.sh
```
## 功能特性
✅ **自动管理 conda 虚拟环境** (ragflow)
✅ **支持启动、停止、重启服务**
✅ **自动输出前端和后端日志**
✅ **进程状态监控**
✅ **优雅关闭和强制停止**
✅ **彩色日志输出**
## 基本用法
### 1. 启动服务
```bash
cd /datacore/ragflow
./ragflow_service.sh start
```
**启动流程:**
- 自动激活 conda 虚拟环境 `ragflow`
- 启动后端服务 (Python API)
- 启动前端服务 (npm dev server)
- 日志输出到 `logs/` 目录
**启动后输出示例:**
```
[INFO] ==========================================
[INFO] 启动 RAGFlow 服务
[INFO] ==========================================
[INFO] 启动后端服务...
[INFO] 后端服务启动成功 (PID: 12345)
[INFO] 后端日志: /datacore/ragflow/logs/backend.log
[INFO] 启动前端服务...
[INFO] 前端服务启动成功 (PID: 12346)
[INFO] 前端日志: /datacore/ragflow/logs/frontend.log
[INFO] 前端访问地址: http://localhost:8888
[INFO] ==========================================
[INFO] RAGFlow 服务启动完成
[INFO] ==========================================
```
### 2. 停止服务
```bash
./ragflow_service.sh stop
```
**停止流程:**
- 优雅关闭前端服务 (等待 10 秒)
- 优雅关闭后端服务 (等待 10 秒)
- 如果进程未响应,自动强制停止
- 清理 PID 文件
### 3. 重启服务
```bash
./ragflow_service.sh restart
```
**重启流程:**
- 先执行 stop 操作
- 等待 2 秒
- 执行 start 操作
### 4. 查看状态
```bash
./ragflow_service.sh status
```
**状态输出示例:**
```
[INFO] ==========================================
[INFO] RAGFlow 服务状态
[INFO] ==========================================
[INFO] 后端服务: 运行中 (PID: 12345)
[INFO] 前端服务: 运行中 (PID: 12346)
[INFO] ==========================================
```
### 5. 查看日志
```bash
# 查看所有日志 (前端+后端)
./ragflow_service.sh logs
# 只查看后端日志
./ragflow_service.sh logs backend
# 只查看前端日志
./ragflow_service.sh logs frontend
```
**按 Ctrl+C 退出日志查看**
## 日志文件位置
| 服务 | 日志路径 | 说明 |
|------|---------|------|
| 后端 | `/datacore/ragflow/logs/backend.log` | Python API 服务日志 |
| 前端 | `/datacore/ragflow/logs/frontend.log` | npm dev server 日志 |
| PID 文件 | `/datacore/ragflow/logs/*.pid` | 进程 ID 文件 |
## 手动查看日志
```bash
# 实时查看后端日志
tail -f /datacore/ragflow/logs/backend.log
# 实时查看前端日志
tail -f /datacore/ragflow/logs/frontend.log
# 同时查看所有日志
tail -f /datacore/ragflow/logs/*.log
```
## 配置说明
脚本中的配置项 (如需修改,编辑脚本顶部):
```bash
CONDA_ENV="ragflow" # conda 环境名
CONDA_PATH="/datacore/home/admin2/miniconda3" # conda 安装路径
PROJECT_ROOT="/datacore/ragflow" # 项目根目录
WEB_DIR="$PROJECT_ROOT/web" # 前端目录
LOGS_DIR="$PROJECT_ROOT/logs" # 日志目录
```
## 前置要求
### 后端服务
- ✅ Python 3.13+ (已在 conda 环境中安装)
- ✅ 所有 Python 依赖已安装
- ⚠️ Docker 基础服务需要运行 (MySQL/Redis/MinIO/Elasticsearch)
启动 Docker 基础服务:
```bash
cd /datacore/ragflow
docker compose -f docker/docker-compose-base.yml up -d
```
### 前端服务
- ⚠️ Node.js 和 npm 已安装
- ⚠️ 前端依赖需要安装
首次使用前安装前端依赖:
```bash
cd /datacore/ragflow/web
npm install
```
## 故障排查
### 1. 后端启动失败
**检查日志:**
```bash
cat /datacore/ragflow/logs/backend.log
```
**常见原因:**
- Docker 基础服务未启动
- Python 依赖缺失
- 端口被占用
### 2. 前端启动失败
**检查日志:**
```bash
cat /datacore/ragflow/logs/frontend.log
```
**常见原因:**
- `node_modules` 未安装 (运行 `cd web && npm install`)
- 端口 8888 被占用
- npm 版本不兼容
### 3. 进程无法停止
如果脚本无法停止服务,可以手动强制停止:
```bash
# 查看进程
ps aux | grep ragflow
ps aux | grep node
# 强制杀死进程
kill -9 <PID>
# 或者使用脚本的 PID 文件
kill -9 $(cat /datacore/ragflow/logs/backend.pid)
kill -9 $(cat /datacore/ragflow/logs/frontend.pid)
# 清理 PID 文件
rm -f /datacore/ragflow/logs/*.pid
```
### 4. 权限问题
如果遇到权限错误:
```bash
chmod +x /datacore/ragflow/ragflow_service.sh
chmod -R 755 /datacore/ragflow/logs
```
## 访问服务
启动成功后:
- **前端界面:** http://localhost:8888
- **后端 API:** 默认运行在配置的端口 (查看 `docker/.env` 文件)
## 开机自启动 (可选)
如果需要开机自启动,可以添加到 systemd:
```bash
sudo nano /etc/systemd/system/ragflow.service
```
内容:
```ini
[Unit]
Description=RAGFlow Service
After=network.target docker.service
[Service]
Type=forking
User=admin2
WorkingDirectory=/datacore/ragflow
ExecStart=/datacore/ragflow/ragflow_service.sh start
ExecStop=/datacore/ragflow/ragflow_service.sh stop
ExecReload=/datacore/ragflow/ragflow_service.sh restart
Restart=on-failure
[Install]
WantedBy=multi-user.target
```
启用服务:
```bash
sudo systemctl daemon-reload
sudo systemctl enable ragflow
sudo systemctl start ragflow
```
## 快速命令参考
| 命令 | 说明 |
|------|------|
| `./ragflow_service.sh start` | 启动所有服务 |
| `./ragflow_service.sh stop` | 停止所有服务 |
| `./ragflow_service.sh restart` | 重启所有服务 |
| `./ragflow_service.sh status` | 查看服务状态 |
| `./ragflow_service.sh logs` | 查看所有日志 |
| `./ragflow_service.sh logs backend` | 查看后端日志 |
| `./ragflow_service.sh logs frontend` | 查看前端日志 |
## 技术支持
如遇问题,请检查:
1. 日志文件 (`logs/*.log`)
2. Docker 基础服务状态 (`docker compose ps`)
3. conda 环境是否正确 (`conda env list`)
4. 端口占用情况 (`netstat -tulpn | grep 8888`)
...@@ -27,8 +27,8 @@ ...@@ -27,8 +27,8 @@
|-----|---------|---------| |-----|---------|---------|
| G1 | 实现部门间知识资产隔离 | 部门间知识库互不可见率100% | | G1 | 实现部门间知识资产隔离 | 部门间知识库互不可见率100% |
| G2 | 实现管理员统一管控 | 模型配置页面仅管理员可见 | | G2 | 实现管理员统一管控 | 模型配置页面仅管理员可见 |
| G3 | 实现内容去重 | 重复上传拦截率100% | | G3 | 实现同部门内容去重 | 同部门重复上传拦截率100% |
| G4 | 实现总知识库自动汇聚 | 各部门上传自动同步成功率99% | | G4 | 实现文档引用关系管理 | 跨部门文档引用准确率100% |
| G5 | 保证系统稳定性 | 7×24可用性,可用率99.5% | | G5 | 保证系统稳定性 | 7×24可用性,可用率99.5% |
| G6 | 支持企业级扩展 | 支持千级用户、万级文档 | | G6 | 支持企业级扩展 | 支持千级用户、万级文档 |
...@@ -49,8 +49,8 @@ ...@@ -49,8 +49,8 @@
**场景三:普通部门成员** **场景三:普通部门成员**
- 上传文档到本部门知识库 - 上传文档到本部门知识库
- 使用聊天功能查询本部门知识 - 使用聊天功能查询本部门知识
- 使用聊天功能查询总知识库 - 仅可见本部门知识库,不可见其他部门知识库
- 不能访问其他部门知识 - 不可见总知识库(总知识库为管理员专用逻辑视图)
--- ---
...@@ -137,19 +137,23 @@ ...@@ -137,19 +137,23 @@
**实体5:知识库(Knowledgebase)— 扩展** **实体5:知识库(Knowledgebase)— 扩展**
- 现有:已存在 - 现有:已存在
- 新增:department_id 字段,标识归属部门 - 新增:department_id 字段,标识归属部门
- 新增:is_global_kb 字段,标识是否为总知识库内容 - 新增:is_global_kb 字段,标识是否为总知识库(仅管理员可见的逻辑视图)
- 权限:部门知识库仅本部门可见,总知识库所有部门可见 - 权限:部门知识库仅本部门可见,总知识库仅管理员可见
**实体6:文档(Document)— 扩展** **实体6:文档(Document)— 扩展**
- 现有:已存在 - 现有:已存在
- 复用:content_hash 已存在(xxhash128) - 复用:content_hash 已存在(xxhash128)
- 改造:与总知识库自动同步逻辑关联 - 改造:文档物理存储唯一,通过引用关系表管理多部门归属
**实体7:文件哈希(ContentHash)— 新增** **实体7:文档引用关系(DocumentReference)— 新增**
- 含义:去重依据 - 含义:管理文档与部门/知识库的引用关系,支持一份文档被多个部门引用
- 属性:tenant_id、filename_hash、content_hash、kb_id、doc_id - 属性:id、tenant_id、doc_id、department_id、kb_id、reference_type
- 索引:tenant_id+filename_hash、tenant_id+content_hash 唯一索引 - 索引:tenant_id+department_id+content_hash 唯一索引(同部门去重)
- 作用:实现文件名和内容双重去重 - 核心逻辑:
- 文档上传时,先检查文档是否已存在(通过content_hash)
- 若已存在,仅创建引用关系,不重复存储文档
- 若不存在,创建文档后再创建引用关系
- 删除时,仅删除引用关系,当所有引用都删除后才物理删除文档
### 3.2 角色权限矩阵 ### 3.2 角色权限矩阵
...@@ -171,12 +175,14 @@ ...@@ -171,12 +175,14 @@
| 查看本部门知识库 | ✓ | ✓ | ✓ | ✓ | | 查看本部门知识库 | ✓ | ✓ | ✓ | ✓ |
| 上传本部门文档 | ✓ | ✓ | ✓ | ✓ | | 上传本部门文档 | ✓ | ✓ | ✓ | ✓ |
| 使用聊天功能 | ✓ | ✓ | ✓ | ✓ | | 使用聊天功能 | ✓ | ✓ | ✓ | ✓ |
| 查询总知识库 | ✓ | ✓ | ✓ | ✓ | | 查看总知识库(管理视图) | ✓ | ✓ | ✗ | ✗ |
| 创建知识库 | ✓ | ✓ | ✓ | ✗ | | 创建知识库 | ✓ | ✓ | ✓ | ✗ |
| 删除知识库 | ✓ | ✓ | ✓ | ✗ | | 删除知识库 | ✓ | ✓ | ✓ | ✗ |
| 修改知识库设置 | ✓ | ✓ | ✓ | ✗ | | 修改知识库设置 | ✓ | ✓ | ✓ | ✗ |
| 模型配置(编辑) | ✓ | ✓ | ✗ | ✗ | | 模型配置(编辑) | ✓ | ✓ | ✗ | ✗ |
| 模型配置(查看) | ✓ | ✓ | ✓ | ✓ | | 模型配置(查看) | ✓ | ✓ | ✓(只读模式) | ✗(重定向首页) |
| 向量检索配置(查看) | ✓ | ✓ | ✓(只读模式) | ✗ |
| 向量检索配置(修改) | ✓ | ✓ | ✗ | ✗ |
| 用户管理 | ✓ | ✓ | ✗ | ✗ | | 用户管理 | ✓ | ✓ | ✗ | ✗ |
| 部门管理 | ✓ | ✓ | ✗ | ✗ | | 部门管理 | ✓ | ✓ | ✗ | ✗ |
| 团队设置 | ✓ | ✓ | ✗ | ✗ | | 团队设置 | ✓ | ✓ | ✗ | ✗ |
...@@ -279,17 +285,48 @@ ...@@ -279,17 +285,48 @@
└─ 超级管理员为每个公司创建租户 └─ 超级管理员为每个公司创建租户
└─ 指定租户管理员 └─ 指定租户管理员
阶段4:部门初始化(每个租户首次登录时触发) 阶段4:部门初始化(租户管理员首次登录时触发)
└─ 自动创建默认5个部门 └─ 系统检测租户是否已有部门
├─ 研发部 (RD) ├─ 若无部门 → 自动创建默认5个部门
├─ 综合部 (ADMIN) │ ├─ 研发部 (code: RD)
├─ 市场部 (MARKET) │ ├─ 综合部 (code: ADMIN)
├─ 交付部 (DELIVERY) │ ├─ 市场部 (code: MARKET)
└─ 总知识库 (GLOBAL, is_global=true) │ ├─ 交付部 (code: DELIVERY)
│ └─ 总知识库 (code: GLOBAL, is_global=true, 标记为不可删除)
阶段5:用户与部门关联 └─ 若已有部门 → 跳过初始化
└─ 租户管理员导入用户
└─ 为每个用户指定所属部门 管理员后续可进行部门管理:
├─ 新增部门:在"部门管理"页面创建新部门(如:财务部、人事部)
├─ 修改部门:可修改部门名称、描述信息
├─ 删除部门:需满足条件(该部门无成员、无知识库,且非总知识库部门)
└─ 总知识库部门(is_global=true)特殊规则:
├─ 不可删除
├─ 不可修改 is_global 标志
└─ 仅作为管理员查看全量文档的逻辑视图
阶段5:员工自主注册与部门关联
└─ 员工访问注册页面
├─ 填写注册信息
│ ├─ 邮箱(必填,作为登录账号)
│ ├─ 密码(必填,需符合强度要求)
│ ├─ 姓名(必填)
│ └─ 所属部门(必选,下拉框选择)
│ ├─ 显示所有启用状态的部门
│ ├─ 包含总知识库部门(但提示:通常不选此项)
│ └─ 默认无预选值,员工必须主动选择
├─ 提交注册
│ ├─ 后端验证邮箱唯一性
│ ├─ 创建 User 记录
│ ├─ 创建 UserTenant 记录,写入 department_id
│ ├─ 默认角色设置为 member(普通成员)
│ └─ 发送验证邮件(可选功能)
└─ 注册成功后跳转到登录页面
管理员后续可调整:
└─ 在"团队管理"页面
├─ 修改员工所属部门
├─ 提升员工为部门管理员(dept_admin)
└─ 提升员工为租户管理员(tenant_admin)
``` ```
### 5.2 用户登录流程 ### 5.2 用户登录流程
...@@ -364,39 +401,73 @@ ...@@ -364,39 +401,73 @@
↓ ↓
后端接收文件 后端接收文件
↓ ↓
【关键步骤】去重检查 【关键步骤】去重检查(基于引用关系)
├─ 计算文件名 SHA256 哈希 ├─ 计算文件名 SHA256 哈希(filename_hash)
├─ 计算文件内容 SHA256 哈希 ├─ 计算文件内容 SHA256 哈希(content_hash)
├─ 查询 content_hash 表 ├─ 查询 document_reference 表(文档引用关系表)
│ ├─ 同租户内 filename_hash 唯一 │ ├─ 查询条件1:tenant_id + department_id + filename_hash
│ └─ 同租户内 content_hash 唯一 │ │ └─ 若命中 → 返回错误「同部门已存在同名文件」
├─ 如有命中 → 返回错误(包含已有文档位置) │ ├─ 查询条件2:tenant_id + department_id + content_hash
└─ 如无命中 → 继续 │ │ └─ 若命中 → 返回错误「同部门已存在相同内容的文件」
↓ │ └─ 都未命中 → 继续上传流程
存储文件到 MinIO/S3 ├─ 注意:仅检查本部门内的重复,不检查其他部门
└─ 不同部门可以引用同一份物理文档
↓
检查文档是否已物理存储(跨部门复用)
├─ 通过 content_hash 查询 document 表
├─ 若已存在物理文档 → 跳过文件存储,直接复用 doc_id
└─ 若不存在物理文档 → 继续存储流程
↓
存储文件到 MinIO/S3(仅当文档首次上传)
├─ 原始文件存储 ├─ 原始文件存储
└─ 缩略图存储(如适用) └─ 缩略图存储(如适用)
↓ ↓
创建 Document 记录 创建或复用 Document 记录
├─ 关联 kb_id ├─ 若文档已存在(content_hash 相同)→ 复用现有 doc_id
├─ 关联 created_by (用户ID) ├─ 若文档不存在 → 创建新 Document 记录
├─ 设置 content_hash(已有 xxhash128) │ ├─ 设置 content_hash(xxhash128)
└─ 创建解析任务 │ └─ 创建解析任务
↓ └─ 记录原始上传人信息
创建 ContentHash 记录 ↓
创建 DocumentReference 引用记录
├─ 记录 doc_id(文档物理ID)
├─ 记录 department_id(引用部门)
├─ 记录 kb_id(引用知识库)
├─ 记录 filename_hash ├─ 记录 filename_hash
├─ 记录 content_hash ├─ 记录 content_hash
├─ 记录 source_kb_id ├─ 记录 reference_type(normal/global)
└─ 记录 first_doc_id └─ 记录 created_by(上传人)
↓ ↓
【异步触发】总知识库同步任务 【异步触发】总知识库引用创建
├─ 获取总知识库部门 ├─ 获取总知识库部门ID
├─ 检查总知识库内是否已有此内容 ├─ 获取总知识库 KB ID
│ └─ 查询 content_hash(is_global_record=true) ├─ 检查是否已有总知识库引用
├─ 如已存在 → 跳过同步 │ └─ 查询 document_reference(kb_id=总知识库ID, doc_id=当前doc_id)
└─ 如不存在 → 加入同步队列 ├─ 若已存在 → 任务结束(总知识库已有此文档引用)
└─ 若不存在 → 创建总知识库的引用记录
├─ doc_id:复用同一个文档ID
├─ department_id:总知识库部门ID
├─ kb_id:总知识库ID
├─ reference_type:global
└─ 向量数据复用(无需重新向量化)
↓ ↓
返回上传结果(成功/失败/重复) 返回上传结果(成功/失败/重复)
【示例场景】:
- 研发部上传"需求文档.pdf"(content_hash=abc123)✓ 成功
└─ 创建 Document(id=doc001, content_hash=abc123)
└─ 创建 DocumentReference(doc_id=doc001, dept_id=研发部, kb_id=研发库)
└─ 异步创建 DocumentReference(doc_id=doc001, dept_id=总知识库, kb_id=总库)
- 研发部再次上传"需求文档.pdf" ✗ 拒绝(同部门同文件名)
- 市场部上传"需求文档.pdf"(content_hash=abc123)✓ 成功
└─ 复用 Document(id=doc001),不重复存储文件
└─ 创建 DocumentReference(doc_id=doc001, dept_id=市场部, kb_id=市场库)
└─ 总知识库引用已存在,无需重复创建
- 此时物理存储:1份文件
- 引用关系:研发部1条、市场部1条、总知识库1条(共3条引用)
``` ```
### 5.5 总知识库同步流程 ### 5.5 总知识库同步流程
...@@ -406,7 +477,7 @@ ...@@ -406,7 +477,7 @@
↓ ↓
将同步任务推入 Redis 队列 将同步任务推入 Redis 队列
├─ 任务类型:kb_sync ├─ 任务类型:kb_sync
└─ 任务数据:{tenant_id, source_kb_id, doc_id, ...} └─ 任务数据:{tenant_id, source_dept_id, source_kb_id, doc_id, ...}
↓ ↓
异步 Worker 消费任务 异步 Worker 消费任务
↓ ↓
...@@ -414,27 +485,41 @@ ...@@ -414,27 +485,41 @@
├─ 获取总知识库部门ID ├─ 获取总知识库部门ID
└─ 获取总知识库 KB ID └─ 获取总知识库 KB ID
↓ ↓
检查全局去重 检查总知识库是否已有此文档引用
├─ 通过 content_hash 查询 ├─ 查询 document_reference 表
└─ 如已存在 → 任务结束 │ └─ 条件:kb_id=总知识库ID AND doc_id=当前doc_id
↓ └─ 若已存在 → 任务结束(避免重复创建引用)
从源知识库复制文档到总知识库 ↓
├─ 复制原始文件 创建总知识库引用记录
├─ 复制解析后的 chunks ├─ 复用同一个 doc_id(文档物理存储)
├─ 复用向量数据(或重新向量化) ├─ 创建 DocumentReference 记录
└─ 创建新 Document 记录 │ ├─ doc_id:源文档ID
↓ │ ├─ department_id:总知识库部门ID
创建 ContentHash 全局记录 │ ├─ kb_id:总知识库ID
├─ is_global_record=true │ ├─ reference_type:global
├─ filename_hash=源hash │ ├─ content_hash:复用源文档hash
├─ content_hash=源hash │ └─ source_dept_id:记录来源部门(用于溯源)
└─ source_kb_id=源kb_id └─ 向量数据复用(ElasticSearch/Infinity中已存在,无需重新向量化)
↓ ↓
更新任务状态 更新任务状态
├─ 成功 → 记录日志 ├─ 成功 → 记录日志
└─ 失败 → 加入重试队列(最多3次) └─ 失败 → 加入重试队列(最多3次)
↓ ↓
返回同步结果 返回同步结果
【核心原则】:
- 文档物理存储唯一:多个部门引用同一份文档,仅存储一次
- 引用关系灵活:通过 document_reference 表管理多对多关系
- 总知识库定位:仅为管理员提供的逻辑视图,聚合所有部门文档的引用
- 删除安全:删除引用不影响其他部门,所有引用删除后才物理删除文档
【多部门上传相同文件的处理】:
- 研发部上传"手册.pdf"(doc_id=doc001)
└─ 引用:研发部 → doc001、总知识库 → doc001
- 市场部上传"手册.pdf"(相同content_hash)
└─ 复用 doc001,新增引用:市场部 → doc001
└─ 总知识库引用已存在,无需重复创建
- 最终:1份物理文档,3条引用记录(研发部、市场部、总知识库)
``` ```
### 5.6 聊天查询流程(部门成员) ### 5.6 聊天查询流程(部门成员)
...@@ -445,10 +530,10 @@ ...@@ -445,10 +530,10 @@
前端获取可访问的知识库列表 前端获取可访问的知识库列表
├─ 调用后端 API ├─ 调用后端 API
└─ 后端根据用户角色过滤 └─ 后端根据用户角色过滤
├─ member:本部门知识库 + 总知识库 ├─ member:仅本部门知识库(不包含总知识库)
├─ dept_admin:本部门知识库 + 总知识库 ├─ dept_admin:仅本部门知识库(不包含总知识库)
├─ tenant_admin:所有知识库 ├─ tenant_admin:所有知识库(包含总知识库)
└─ super_admin:所有知识库 └─ super_admin:所有知识库(包含总知识库)
↓ ↓
前端展示知识库选择器(已过滤) 前端展示知识库选择器(已过滤)
↓ ↓
...@@ -465,13 +550,163 @@ ...@@ -465,13 +550,163 @@
↓ ↓
检索相关文档 检索相关文档
├─ 在允许的知识库内检索 ├─ 在允许的知识库内检索
├─ 通过 document_reference 表关联文档
│ └─ 查询条件:kb_id IN (允许的知识库列表)
├─ 向量检索 + 关键词检索 ├─ 向量检索 + 关键词检索
└─ Rerank重排序 └─ Rerank重排序
↓ ↓
调用 LLM 生成回答 调用 LLM 生成回答
↓ ↓
流式返回结果 流式返回结果
└─ 包含引用来源(文档名、知识库名) └─ 包含引用来源(文档名、知识库名、所属部门)
【权限说明】:
- 普通成员(member):只能看到自己部门的知识库,看不到其他部门,也看不到总知识库
- 部门管理员(dept_admin):与普通成员权限相同,仅本部门知识库
- 租户管理员(tenant_admin):可以访问所有部门知识库 + 总知识库
- 超级管理员(super_admin):可以访问所有知识库
- 总知识库作为管理员的逻辑视图,聚合展示所有部门文档,普通成员不可见
```
#### 5.6.1 向量检索部门过滤详细机制【P0核心安全】
**设计目标**:确保向量检索时严格遵循部门权限,防止跨部门数据泄露
**核心挑战**:
- 向量检索通常只支持相似度计算,不直接支持复杂权限过滤
- 需要在检索前或检索时注入部门过滤条件
- 必须保证性能,避免先检索再过滤导致的性能问题
**实现方案:两阶段过滤机制**
```
阶段1:获取允许访问的文档ID集合(权限预过滤)
↓
用户发起聊天请求(携带 kb_id 列表)
↓
后端接收请求
↓
【关键步骤1】权限验证与知识库过滤
├─ 验证用户是否有权访问这些 kb_id
├─ 过滤掉无权访问的知识库
├─ 若所有 kb_id 都无权 → 返回 403 错误
└─ 获取有效的 kb_id 列表:valid_kb_ids
↓
【关键步骤2】查询允许的文档ID集合
├─ 查询 document_reference 表
│ └─ SQL: SELECT DISTINCT doc_id
│ FROM document_reference
│ WHERE kb_id IN (valid_kb_ids)
│ AND status = '1'
│ LIMIT 10000; -- 防止数据量过大
├─ 结果:allowed_doc_ids = [doc001, doc002, doc003, ...]
└─ 若结果为空 → 返回「当前知识库暂无文档」
↓
【性能优化】Redis缓存策略
├─ 缓存Key:kb_doc_ids:{kb_id1}_{kb_id2}_...
├─ 缓存内容:allowed_doc_ids 列表
├─ TTL:5分钟(文档上传/删除时主动失效)
├─ 首次查询:从数据库查询 → 写入Redis
└─ 后续查询:直接从Redis获取 → 性能提升10倍
↓
阶段2:向量检索(注入文档ID过滤条件)
↓
【关键步骤3】构建Elasticsearch查询
├─ 使用 filter context(不计算分数,速度快)
├─ 查询DSL结构:
│ {
│ "query": {
│ "bool": {
│ "must": [
│ {
│ "script_score": { // 向量相似度计算
│ "query": {"match_all": {}},
│ "script": {
│ "source": "cosineSimilarity(params.query_vector, 'embedding') + 1.0",
│ "params": {"query_vector": [0.1, 0.2, ...]}
│ }
│ }
│ }
│ ],
│ "filter": [ // 【核心】权限过滤,不计算分数
│ {
│ "terms": {
│ "doc_id.keyword": allowed_doc_ids // 严格限制文档范围
│ }
│ }
│ ]
│ }
│ },
│ "size": 20 // Top-K结果
│ }
└─ 向量检索 + 文档ID过滤同时执行,ES内部优化
↓
【关键步骤4】Elasticsearch执行查询
├─ ES首先应用 filter context(快速过滤出允许的文档)
├─ 然后在过滤后的文档中进行向量相似度计算
├─ 返回 Top-K 最相关的文档片段
└─ 所有返回的文档都已通过部门权限验证
↓
【关键步骤5】结果后处理与验证
├─ 再次验证返回的 doc_id 是否在 allowed_doc_ids 中(双重防护)
├─ 关联查询 document 表获取文档元信息
├─ 通过 document_reference 表获取部门信息(用于展示来源)
└─ 构建返回结果(包含:文档片段、相似度分数、来源部门)
↓
返回给LLM进行回答生成
↓
流式返回结果给前端
【设计要点】:
1. **权限预过滤**:在向量检索前先确定允许的文档ID集合,避免检索后再过滤
2. **ES filter context**:使用filter而非query,不计算分数,性能更好
3. **缓存优化**:高频查询的kb文档ID列表缓存到Redis,减少数据库压力
4. **双重验证**:数据库查询 + ES结果验证,确保绝对安全
5. **性能平衡**:allowed_doc_ids限制最大10000个,避免ES terms查询性能问题
【边界情况处理】:
- 情况1:知识库文档数超过10000个
└─ 方案:分批查询 + 合并结果,或使用ES scroll API
- 情况2:allowed_doc_ids为空
└─ 方案:跳过ES查询,直接返回「当前知识库暂无文档」
- 情况3:用户同时选择多个知识库(跨部门,管理员)
└─ 方案:合并所有kb的allowed_doc_ids,统一过滤
- 情况4:文档被删除但ES索引未及时更新
└─ 方案:结果后处理阶段再次验证doc_id有效性
【性能对比】:
- 传统方案(先检索再过滤):ES检索100ms + 应用层过滤50ms = 150ms
- 本方案(预过滤+ES内置过滤):Redis缓存5ms + ES带过滤检索80ms = 85ms
- 性能提升:约45%,且随文档数量增加优势更明显
【安全保障】:
- 第一层:API权限校验(验证用户角色)
- 第二层:知识库权限验证(验证kb_id访问权限)
- 第三层:文档ID预过滤(查询document_reference表)
- 第四层:ES查询注入过滤条件(terms filter)
- 第五层:结果二次验证(确保返回的doc_id合法)
- 五层防护,确保跨部门数据泄露风险为零
```
**【Infinity向量库适配方案】**
如果使用Infinity替代Elasticsearch,过滤机制需要调整:
```
Infinity查询改造:
├─ Infinity支持WHERE子句过滤
├─ SQL风格查询:
│ SELECT doc_id, score
│ FROM vector_index
│ WHERE doc_id IN (allowed_doc_ids)
│ ORDER BY vector_distance(embedding, query_vector)
│ LIMIT 20;
└─ 同样实现部门级过滤,语法不同但逻辑相同
性能优化:
├─ Infinity的WHERE过滤在索引层实现
├─ 避免传递超大doc_id列表(同样限制10000个)
└─ 必要时使用临时表存储allowed_doc_ids
``` ```
### 5.7 知识库列表查询流程 ### 5.7 知识库列表查询流程
...@@ -487,16 +722,24 @@ ...@@ -487,16 +722,24 @@
└─ department_id └─ department_id
↓ ↓
构建查询条件 构建查询条件
├─ super_admin:所有可见知识库 ├─ super_admin:所有可见知识库(包含总知识库)
├─ tenant_admin:本租户所有知识库 ├─ tenant_admin:本租户所有知识库(包含总知识库)
├─ dept_admin:本部门 + 总知识库 ├─ dept_admin:仅本部门知识库(不含总知识库)
└─ member:本部门 + 总知识库 └─ member:仅本部门知识库(不含总知识库)
↓ ↓
分页查询数据库 分页查询数据库
├─ 查询 knowledgebase 表
└─ 根据角色过滤 department_id 和 is_global_kb 字段
↓ ↓
返回知识库列表(已过滤) 返回知识库列表(已过滤)
↓ ↓
前端展示 前端展示
【查询逻辑说明】:
- 普通成员和部门管理员:WHERE department_id = 用户部门ID AND is_global_kb = false
- 租户管理员:WHERE tenant_id = 用户租户ID(包含所有部门 + 总知识库)
- 超级管理员:无过滤条件(查询所有)
- 总知识库标识:is_global_kb = true,仅管理员可见
``` ```
### 5.8 模型配置权限流程 ### 5.8 模型配置权限流程
...@@ -506,21 +749,39 @@ ...@@ -506,21 +749,39 @@
↓ ↓
路由守卫检查权限 路由守卫检查权限
├─ 检查用户角色 ├─ 检查用户角色
└─ member 角色 → 重定向到首页(或提示无权限) └─ member 角色 → 重定向到首页 + Toast提示「您没有权限访问此页面」
↓
部门管理员(dept_admin)访问 /user-setting/model
↓
允许进入页面(不重定向)
↓ ↓
管理员访问 页面展示只读模式
├─ 所有表单字段变灰、禁用编辑
├─ 所有"添加"、"删除"、"保存"按钮隐藏
├─ 页面顶部显示提示信息:「当前为只读模式,如需修改请联系管理员」
└─ 可查看 Provider 列表、模型配置、向量检索配置
↓ ↓
进入模型设置页面 租户管理员(tenant_admin)访问
↓
进入模型设置页面(完整编辑权限)
├─ 显示 provider 列表 ├─ 显示 provider 列表
├─ 显示模型实例配置 ├─ 显示模型实例配置
├─ 可添加/编辑/删除 provider ├─ 可添加/编辑/删除 provider
└─ 可配置默认模型 ├─ 可配置默认模型
└─ 可修改向量检索配置
↓ ↓
普通成员尝试直接访问 API 普通成员尝试直接访问 API
↓ ↓
后端装饰器拦截 后端装饰器拦截
├─ 验证用户角色 ├─ 验证用户角色
└─ 非管理员 → 返回 403 └─ 非管理员 → 返回 403
【权限细化说明】:
- 模型配置查看权限:tenant_admin(可编辑)、dept_admin(只读)、member(不可见)
- 向量检索配置查看权限:tenant_admin(可编辑)、dept_admin(只读)、member(不可见)
- 所有编辑操作(添加/修改/删除Provider):仅 tenant_admin 和 super_admin
- 前端UI层:根据角色显示不同界面(完整编辑 / 只读模式 / 重定向)
- 后端API层:所有编辑接口强制校验角色,双重防护
``` ```
### 5.9 文档删除流程 ### 5.9 文档删除流程
...@@ -536,46 +797,336 @@ ...@@ -536,46 +797,336 @@
├─ 检查用户是否属于文档所属部门 ├─ 检查用户是否属于文档所属部门
└─ 或用户是否为管理员 └─ 或用户是否为管理员
↓ ↓
执行删除操作 【关键步骤】删除引用关系
├─ 查询 document_reference 表
│ └─ 条件:doc_id = 当前文档ID AND department_id = 当前部门ID
├─ 删除该部门的引用记录
└─ 记录删除日志
↓
【关键步骤】检查是否还有其他引用
├─ 查询 document_reference 表
│ └─ 条件:doc_id = 当前文档ID
├─ 统计剩余引用数量(包含总知识库引用)
└─ 判断后续操作
↓
若还有其他引用(引用数 > 0)
├─ 仅删除当前部门的引用记录
├─ 保留 Document 物理记录
├─ 保留 MinIO 存储文件
├─ 保留向量索引数据
└─ 返回删除成功(提示:文档引用已移除,物理文件保留)
↓
若无任何引用(引用数 = 0)
├─ 删除所有相关引用记录
├─ 删除 Document 记录 ├─ 删除 Document 记录
├─ 删除 File 记录 ├─ 删除 MinIO 物理存储
├─ 删除 MinIO 存储 ├─ 删除向量索引(Elasticsearch/Infinity)
├─ 删除向量索引 └─ 返回删除成功(提示:文档已完全删除)
└─ 【关键】删除 ContentHash 记录
↓
【同步处理】总知识库关联内容
├─ 查询 ContentHash(is_global_record=true)关联此 doc_id
├─ 如有 → 删除总知识库对应文档
└─ 删除全局 ContentHash 记录
↓ ↓
返回删除结果 返回删除结果
【删除场景示例】:
场景1:单部门文档
- 研发部有文档"报告.pdf"(doc001)
- 引用关系:研发部 → doc001、总知识库 → doc001
- 研发部删除:删除研发部引用
- 检查剩余引用:还有总知识库引用
- 结果:删除研发部引用,保留物理文档和总知识库引用
- 后续处理:总知识库引用也需清理(异步任务)
场景2:多部门共享文档
- 研发部和市场部都有"手册.pdf"(doc002)
- 引用关系:研发部 → doc002、市场部 → doc002、总知识库 → doc002
- 研发部删除:删除研发部引用
- 检查剩余引用:还有市场部和总知识库引用
- 结果:仅删除研发部引用,物理文档保留
- 市场部也删除:删除市场部引用
- 检查剩余引用:仅剩总知识库引用
- 结果:删除市场部引用,物理文档保留
- 异步清理任务:检测到所有业务部门引用都已删除
- 自动删除总知识库引用
- 检查剩余引用:引用数 = 0
- 结果:物理删除文档、MinIO文件、向量索引
【总知识库引用清理策略】:
- 总知识库引用不直接暴露给用户删除
- 当所有业务部门(非总知识库部门)的引用都删除后
- 异步任务自动清理总知识库的孤立引用
- 确保总知识库始终是业务部门文档的逻辑镜像
```
#### 5.9.1 孤立引用清理任务详细设计【P0数据一致性】
**设计目标**:自动清理总知识库中的孤立引用,确保总知识库始终反映业务部门的真实文档状态
**核心挑战**:
- 业务部门删除文档时,总知识库引用不会同步删除
- 需要定期扫描并清理无业务部门引用的孤立记录
- 必须确保清理逻辑安全,避免误删除
**实现方案:定时清理任务**
```
【任务配置】
任务名称:GlobalKBOrphanCleanupTask
执行频率:每天凌晨 2:00 执行(业务低峰期)
执行方式:Celery定时任务 或 APScheduler
任务超时:30分钟(超时则告警)
任务优先级:低优先级(不影响业务)
【执行流程】
步骤1:扫描总知识库引用
↓
查询所有总知识库引用记录
├─ SQL: SELECT id, doc_id, tenant_id
│ FROM document_reference
│ WHERE reference_type = 'global'
│ AND status = '1';
├─ 结果:global_refs = [{id: ref001, doc_id: doc001, tenant_id: t1}, ...]
└─ 若结果为空 → 任务结束(无需清理)
↓
步骤2:逐个检查是否为孤立引用
↓
FOR EACH global_ref IN global_refs:
↓
【关键检查】查询是否还有业务部门引用
├─ SQL: SELECT COUNT(*) as ref_count
│ FROM document_reference
│ WHERE doc_id = global_ref.doc_id
│ AND tenant_id = global_ref.tenant_id
│ AND reference_type = 'normal' -- 仅统计业务部门引用
│ AND status = '1';
├─ 结果:ref_count
└─ 判断是否为孤立引用
↓
IF ref_count == 0: -- 无任何业务部门引用
├─ 标记为孤立引用
├─ 记录到待删除列表:orphan_refs.append(global_ref)
└─ 记录日志:「发现孤立引用 ref_id={id}, doc_id={doc_id}」
ELSE:
└─ 跳过(仍有业务部门引用,保留总知识库引用)
↓
步骤3:批量删除孤立引用
↓
IF orphan_refs 为空:
└─ 任务结束(本次无需清理)
↓
ELSE:
↓
开启数据库事务
↓
FOR EACH orphan_ref IN orphan_refs:
↓
删除总知识库引用记录
├─ SQL: UPDATE document_reference
│ SET status = '0', updated_at = NOW()
│ WHERE id = orphan_ref.id;
└─ 记录删除日志
↓
【关键检查】再次验证文档是否还有任何引用
├─ SQL: SELECT COUNT(*) as total_ref_count
│ FROM document_reference
│ WHERE doc_id = orphan_ref.doc_id
│ AND status = '1';
├─ 结果:total_ref_count
└─ 判断是否需要物理删除文档
↓
IF total_ref_count == 0: -- 文档无任何引用
├─ 【物理删除】删除 Document 记录
│ └─ SQL: DELETE FROM document WHERE id = orphan_ref.doc_id;
├─ 【物理删除】删除 MinIO 存储文件
│ └─ minio_client.remove_object(bucket, file_path)
├─ 【物理删除】删除 Elasticsearch 向量索引
│ └─ es_client.delete(index=vector_index, id=orphan_ref.doc_id)
└─ 记录日志:「物理删除文档 doc_id={doc_id}」
ELSE:
└─ 跳过(仍有其他引用,仅删除总知识库引用)
↓
提交事务
↓
记录清理汇总:「本次清理孤立引用 {count} 条,物理删除文档 {delete_count} 个」
↓
IF 清理数量 > 100: -- 异常情况,可能是数据问题
└─ 发送告警邮件给管理员
↓
步骤4:清理失败文档的向量索引【可选】
↓
扫描 Elasticsearch 中是否有孤立的向量数据
├─ 查询 ES 中存在但 document 表中不存在的 doc_id
├─ SQL: SELECT es_doc_id
│ FROM es_index
│ WHERE es_doc_id NOT IN (SELECT id FROM document);
└─ 批量删除孤立的向量索引
↓
任务结束
↓
更新任务执行记录
├─ 记录执行时间
├─ 记录清理数量
└─ 记录执行状态(成功/失败)
【错误处理与重试机制】
错误类型1:数据库连接失败
└─ 重试策略:最多重试3次,间隔5分钟
└─ 失败后:发送告警,任务标记为失败
错误类型2:MinIO删除失败
└─ 处理策略:记录失败的file_path到失败队列
└─ 下次任务执行时优先处理失败队列
└─ 连续失败3次后告警
错误类型3:Elasticsearch删除失败
└─ 处理策略:记录失败的doc_id到失败队列
└─ 独立的ES清理任务定期处理
└─ 不阻塞主清理流程
错误类型4:事务回滚
└─ 处理策略:记录回滚原因,不删除任何数据
└─ 下次任务重新执行
└─ 连续失败3次后告警
【安全保障机制】
保障1:双重确认机制
├─ 第一次检查:查询是否有业务部门引用(决定是否删除总知识库引用)
└─ 第二次检查:删除总知识库引用后,再次确认是否还有任何引用(决定是否物理删除)
保障2:数据库事务
├─ 所有删除操作在同一个事务中
└─ 任何步骤失败都会回滚,确保数据一致性
保障3:软删除优先
├─ document_reference 表使用软删除(status='0')
├─ Document、MinIO、ES使用硬删除
└─ 软删除可以回溯,硬删除需要二次确认
保障4:清理阈值告警
├─ 单次清理超过100个文档 → 告警(可能是批量删除bug)
├─ 单次清理超过1000个文档 → 暂停任务,人工介入
└─ 防止误删除大量数据
保障5:审计日志完整
├─ 记录每一个被删除的引用ID
├─ 记录每一个被物理删除的文档ID
├─ 记录每一个删除失败的文件路径
└─ 日志保留90天,可追溯
【监控指标】
指标1:任务执行状态
├─ 每日执行时间:预期 2:00,实际执行时间
├─ 任务执行时长:平均耗时、最大耗时
└─ 任务成功率:成功次数 / 总执行次数
指标2:清理数据量
├─ 孤立引用数量:每次清理的引用条数
├─ 物理删除文档数:每次删除的文档数
└─ 释放存储空间:累计释放的磁盘空间(GB)
指标3:异常情况
├─ MinIO删除失败次数
├─ ES删除失败次数
├─ 数据库事务回滚次数
└─ 告警触发次数
【配置参数】
可配置项:
├─ 执行时间:默认 2:00,可配置为其他时间
├─ 批量大小:每次处理的引用数量上限,默认10000
├─ 告警阈值:单次清理数量超过此值则告警,默认100
├─ 重试次数:失败后重试次数,默认3次
├─ 重试间隔:重试间隔时间,默认5分钟
└─ 是否启用:开关控制,默认启用
【手动触发接口】
管理员可通过API手动触发清理任务(用于紧急情况):
├─ POST /api/v1/admin/cleanup/orphan-references
├─ 权限:仅 tenant_admin 和 super_admin
├─ 参数:
│ ├─ force: boolean(是否强制执行,忽略时间限制)
│ └─ dry_run: boolean(仅扫描不删除,返回待清理列表)
└─ 返回:
├─ 扫描到的孤立引用数量
├─ 预计删除的文档数量
└─ 预计释放的存储空间
【日志示例】
正常执行日志:
```
[2026-09-18 02:00:00] GlobalKBOrphanCleanupTask started
[2026-09-18 02:00:05] Scanned 1523 global references
[2026-09-18 02:01:30] Found 12 orphan references
[2026-09-18 02:02:00] Deleted 12 orphan references, 5 documents physically deleted
[2026-09-18 02:02:05] Released 125.3 MB storage space
[2026-09-18 02:02:05] GlobalKBOrphanCleanupTask completed successfully
```
异常执行日志:
```
[2026-09-18 02:00:00] GlobalKBOrphanCleanupTask started
[2026-09-18 02:00:05] Scanned 1523 global references
[2026-09-18 02:01:30] Found 250 orphan references (exceeds threshold 100)
[2026-09-18 02:01:31] ALERT: High orphan count detected, sending notification
[2026-09-18 02:01:35] Processing orphan references with caution
[2026-09-18 02:05:20] MinIO delete failed for doc_id=doc12345, retry 1/3
[2026-09-18 02:05:25] MinIO delete success for doc_id=doc12345
[2026-09-18 02:10:00] Deleted 250 orphan references, 120 documents physically deleted
[2026-09-18 02:10:00] GlobalKBOrphanCleanupTask completed with warnings
```
``` ```
### 5.10 用户与部门关联流程 ### 5.10 用户与部门关联流程
### 5.10 用户与部门关联流程
``` ```
租户管理员进入团队管理 方式一:员工自主注册(推荐)
└─ 详见 5.1 系统初始化流程 - 阶段5
方式二:管理员添加用户
└─ 租户管理员进入团队管理
↓ ↓
查看部门列表 └─ 查看部门列表
↓ ↓
新增/编辑用户时 └─ 新增/编辑用户时
├─ 输入用户邮箱 ├─ 输入用户邮箱
├─ 设置初始密码 ├─ 设置初始密码
├─ 选择所属部门(必选) ├─ 选择所属部门(必选)
└─ 设置系统角色(member/dept_admin) └─ 设置系统角色(member/dept_admin)
↓ ↓
提交后端 API └─ 提交后端 API
↓ ↓
后端处理 └─ 后端处理
├─ 创建 User 记录(如果不存在) ├─ 创建 User 记录(如果不存在)
├─ 创建/更新 UserTenant 记录 ├─ 创建/更新 UserTenant 记录
│ ├─ 设置 department_id │ ├─ 设置 department_id
│ └─ 设置 role │ └─ 设置 role
└─ 发送邀请邮件(可选) └─ 发送邀请邮件(可选)
↓ ↓
用户接收邀请 └─ 用户接收邀请
├─ 点击邮件链接 ├─ 点击邮件链接
└─ 激活账号 └─ 激活账号
【部门变更流程】:
管理员在"团队管理"页面
↓
选择需要调整的用户
↓
修改所属部门
├─ 更新 UserTenant.department_id
├─ 记录变更日志(操作人、时间、原部门、新部门)
└─ 该用户下次登录时生效
↓
用户访问权限自动切换
├─ 原部门知识库不可见
└─ 新部门知识库可见
``` ```
--- ---
...@@ -604,28 +1155,38 @@ ...@@ -604,28 +1155,38 @@
- 普通索引:tenant_id - 普通索引:tenant_id
- 唯一索引:tenant_id + code - 唯一索引:tenant_id + code
#### 6.1.2 内容哈希表 (content_hash) #### 6.1.2 文档引用关系表 (document_reference)
| 字段 | 类型 | 约束 | 说明 | | 字段 | 类型 | 约束 | 说明 |
|-----|------|------|------| |-----|------|------|------|
| id | VARCHAR(32) | PRIMARY KEY | 哈希记录ID | | id | VARCHAR(32) | PRIMARY KEY | 引用记录唯一标识 |
| tenant_id | VARCHAR(32) | NOT NULL, INDEX | 所属租户 | | tenant_id | VARCHAR(32) | NOT NULL, INDEX | 所属租户 |
| department_id | VARCHAR(32) | NULL, INDEX | 来源部门 | | doc_id | VARCHAR(32) | NOT NULL, INDEX | 关联的文档ID(物理文档) |
| kb_id | VARCHAR(32) | NULL, INDEX | 来源知识库 | | department_id | VARCHAR(32) | NOT NULL, INDEX | 引用此文档的部门ID |
| doc_id | VARCHAR(32) | NULL, INDEX | 关联文档ID | | kb_id | VARCHAR(32) | NOT NULL, INDEX | 引用此文档的知识库ID |
| filename_hash | VARCHAR(64) | NOT NULL | 文件名SHA256哈希 | | filename_hash | VARCHAR(64) | NOT NULL | 文件名SHA256哈希(用于同部门去重) |
| content_hash | VARCHAR(64) | NOT NULL | 文件内容SHA256哈希 | | content_hash | VARCHAR(64) | NOT NULL | 文件内容SHA256哈希(用于同部门去重) |
| source_kb_id | VARCHAR(32) | NULL | 首次出现的知识库 | | reference_type | VARCHAR(16) | DEFAULT 'normal' | 引用类型:normal-业务部门引用,global-总知识库引用 |
| first_doc_id | VARCHAR(32) | NULL | 首次出现的文档ID | | source_dept_id | VARCHAR(32) | NULL | 来源部门ID(用于总知识库溯源) |
| is_global_record | BOOLEAN | DEFAULT FALSE | 是否为全局记录 | | created_by | VARCHAR(32) | NOT NULL | 创建人用户ID |
| create_time | BIGINT | NULL | 创建时间 | | created_at | BIGINT | NULL | 创建时间戳 |
| status | CHAR(1) | DEFAULT '1' | 状态 | | updated_at | BIGINT | NULL | 更新时间戳 |
| status | CHAR(1) | DEFAULT '1' | 状态:0-已删除,1-正常 |
**索引**: **索引**:
- 主键索引:id - 主键索引:id
- 普通索引:tenant_id, department_id, kb_id, doc_id - 普通索引:tenant_id, doc_id, department_id, kb_id
- 唯一索引:tenant_id + filename_hash - 唯一索引:tenant_id + department_id + filename_hash(同部门文件名唯一)
- 唯一索引:tenant_id + content_hash - 唯一索引:tenant_id + department_id + content_hash(同部门内容唯一)
- 联合索引:doc_id + department_id(快速查询文档的部门引用)
**核心设计理念**:
- 文档物理存储与引用关系分离:Document 表存储物理文档,document_reference 表存储引用关系
- 支持一对多关系:一份物理文档可以被多个部门引用
- 同部门去重:通过 tenant_id + department_id + content_hash 唯一索引实现
- 跨部门复用:不同部门可以引用同一份物理文档,节省存储空间
- 删除安全:删除引用不影响物理文档,只有所有引用都删除后才物理删除
- 总知识库视图:通过 reference_type='global' 标识总知识库引用
### 6.2 修改表设计 ### 6.2 修改表设计
...@@ -669,8 +1230,488 @@ ...@@ -669,8 +1230,488 @@
- 所有 UserTenant.department_id 默认指向"综合部" - 所有 UserTenant.department_id 默认指向"综合部"
- 所有 Knowledgebase.department_id 默认指向"综合部" - 所有 Knowledgebase.department_id 默认指向"综合部"
- 所有 is_global_kb=false - 所有 is_global_kb=false
4. **业务验证**:管理员手动调整归属 4. **引用关系初始化**:
5. **正式启用**:切换到新的权限逻辑 - 为所有现有文档创建 document_reference 记录
- 每个 Document 创建一条对应部门的引用记录
- 同时为总知识库创建引用记录(reference_type='global')
5. **业务验证**:管理员手动调整归属
6. **正式启用**:切换到新的权限逻辑
#### 6.3.3 迁移验证与回滚
**迁移后验证检查点:**
1. 数据完整性检查:
├─ 检查所有用户是否都已关联部门
│ SQL: SELECT COUNT(*) FROM user_tenant WHERE department_id IS NULL;
│ 期望结果:0
├─ 检查所有知识库是否都已关联部门
│ SQL: SELECT COUNT(*) FROM knowledgebase WHERE department_id IS NULL;
│ 期望结果:0
├─ 检查每个租户是否都有总知识库部门
│ SQL: SELECT tenant_id, COUNT(*) FROM department WHERE is_global=true GROUP BY tenant_id;
│ 期望结果:每个租户都有1条记录
└─ 检查所有文档是否都有引用记录
SQL: SELECT COUNT(*) FROM document WHERE id NOT IN (SELECT DISTINCT doc_id FROM document_reference);
期望结果:0
2. 功能验证:
├─ 管理员登录,检查是否能看到所有知识库(包含总知识库)
├─ 普通成员登录,检查是否只能看到自己部门的知识库(不含总知识库)
├─ 上传文件,检查同部门去重是否生效
├─ 不同部门上传相同文件,检查是否能成功(引用机制)
└─ 删除文件,检查引用计数是否正确,物理删除是否安全
3. 性能验证:
├─ 查询知识库列表,响应时间应 < 500ms
├─ 上传文件(不含解析),响应时间应 < 3s
└─ 删除文件,响应时间应 < 1s
**回滚方案:**
如果验证失败,执行以下回滚步骤:
1. 立即停止应用服务(防止数据继续写入)
2. 恢复数据库快照(迁移前必须做快照)
├─ MySQL: 恢复mysqldump备份
└─ PostgreSQL: 恢复pg_dump备份
3. 或者手动回滚DDL(如果没有快照)
├─ DROP TABLE document_reference;
├─ DROP TABLE department;
├─ ALTER TABLE user_tenant DROP COLUMN department_id;
├─ ALTER TABLE knowledgebase DROP COLUMN department_id;
├─ ALTER TABLE knowledgebase DROP COLUMN is_global_kb;
└─ ALTER TABLE user DROP COLUMN system_role;
4. 重新部署旧版本代码
5. 重启应用服务
6. 验证系统恢复正常
**迁移失败常见原因:**
- 部门初始化脚本执行失败
- 数据回填脚本超时(数据量太大)
- 引用关系初始化失败(文档数量过多)
- 索引创建失败(磁盘空间不足)
- 应用代码bug导致查询异常
**建议迁移窗口:**
- 选择业务低峰期(如:周末凌晨)
- 预留4小时窗口(2小时迁移 + 2小时验证/回滚)
- 提前通知用户系统维护
#### 6.3.4 完整SQL迁移脚本【P0执行脚本】
**脚本说明**:
- 适用数据库:MySQL 5.7+、PostgreSQL 12+
- 执行前置条件:必须先备份数据库
- 执行顺序:严格按照阶段1→阶段2→阶段3→阶段4执行
- 执行方式:建议使用数据库管理工具逐段执行,不要一次性执行全部
- 预计耗时:小型数据库(<1万文档)约10分钟,大型数据库(>10万文档)约1-2小时
---
**【阶段1:DDL变更 - 新增表】**
```sql
-- =====================================================
-- 迁移脚本阶段1:创建新表
-- 执行时间:预计1-2分钟
-- =====================================================
-- 1.1 创建部门表
CREATE TABLE IF NOT EXISTS `department` (
`id` VARCHAR(32) NOT NULL COMMENT '部门唯一标识',
`tenant_id` VARCHAR(32) NOT NULL COMMENT '所属租户ID',
`name` VARCHAR(64) NOT NULL COMMENT '部门名称',
`code` VARCHAR(32) NOT NULL COMMENT '部门代码',
`description` TEXT DEFAULT NULL COMMENT '部门描述',
`is_global` TINYINT(1) DEFAULT 0 COMMENT '是否为总知识库部门',
`created_by` VARCHAR(32) NOT NULL COMMENT '创建人用户ID',
`created_at` BIGINT DEFAULT NULL COMMENT '创建时间戳',
`updated_at` BIGINT DEFAULT NULL COMMENT '更新时间戳',
`status` CHAR(1) DEFAULT '1' COMMENT '状态:0-禁用,1-启用',
PRIMARY KEY (`id`),
KEY `idx_tenant_id` (`tenant_id`),
UNIQUE KEY `uk_tenant_code` (`tenant_id`, `code`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='部门表';
-- 1.2 创建文档引用关系表
CREATE TABLE IF NOT EXISTS `document_reference` (
`id` VARCHAR(32) NOT NULL COMMENT '引用记录唯一标识',
`tenant_id` VARCHAR(32) NOT NULL COMMENT '所属租户ID',
`doc_id` VARCHAR(32) NOT NULL COMMENT '关联的文档ID',
`department_id` VARCHAR(32) NOT NULL COMMENT '引用此文档的部门ID',
`kb_id` VARCHAR(32) NOT NULL COMMENT '引用此文档的知识库ID',
`filename_hash` VARCHAR(64) NOT NULL COMMENT '文件名SHA256哈希',
`content_hash` VARCHAR(64) NOT NULL COMMENT '文件内容SHA256哈希',
`reference_type` VARCHAR(16) DEFAULT 'normal' COMMENT '引用类型:normal/global',
`source_dept_id` VARCHAR(32) DEFAULT NULL COMMENT '来源部门ID(总知识库溯源用)',
`created_by` VARCHAR(32) NOT NULL COMMENT '创建人用户ID',
`created_at` BIGINT DEFAULT NULL COMMENT '创建时间戳',
`updated_at` BIGINT DEFAULT NULL COMMENT '更新时间戳',
`status` CHAR(1) DEFAULT '1' COMMENT '状态:0-已删除,1-正常',
PRIMARY KEY (`id`),
KEY `idx_tenant_id` (`tenant_id`),
KEY `idx_doc_id` (`doc_id`),
KEY `idx_department_id` (`department_id`),
KEY `idx_kb_id` (`kb_id`),
KEY `idx_doc_dept` (`doc_id`, `department_id`),
UNIQUE KEY `uk_tenant_dept_filename` (`tenant_id`, `department_id`, `filename_hash`),
UNIQUE KEY `uk_tenant_dept_content` (`tenant_id`, `department_id`, `content_hash`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='文档引用关系表';
-- 验证表创建成功
SELECT '阶段1完成:新表创建成功' AS status;
```
---
**【阶段2:DDL变更 - 修改现有表】**
```sql
-- =====================================================
-- 迁移脚本阶段2:修改现有表结构
-- 执行时间:预计2-5分钟
-- =====================================================
-- 2.1 修改 user_tenant 表,增加 department_id 字段
ALTER TABLE `user_tenant`
ADD COLUMN `department_id` VARCHAR(32) DEFAULT NULL COMMENT '所属部门ID' AFTER `role`;
-- 2.2 为 department_id 创建索引
ALTER TABLE `user_tenant`
ADD KEY `idx_department_id` (`department_id`);
-- 2.3 修改 knowledgebase 表,增加 department_id 字段
ALTER TABLE `knowledgebase`
ADD COLUMN `department_id` VARCHAR(32) DEFAULT NULL COMMENT '所属部门ID' AFTER `tenant_id`;
-- 2.4 修改 knowledgebase 表,增加 is_global_kb 字段
ALTER TABLE `knowledgebase`
ADD COLUMN `is_global_kb` TINYINT(1) DEFAULT 0 COMMENT '是否为总知识库' AFTER `department_id`;
-- 2.5 为 knowledgebase 表创建索引
ALTER TABLE `knowledgebase`
ADD KEY `idx_department_id` (`department_id`);
-- 2.6 修改 user 表,增加系统级角色字段(可选)
ALTER TABLE `user`
ADD COLUMN `system_role` VARCHAR(32) DEFAULT NULL COMMENT '系统级角色' AFTER `nickname`;
-- 2.7 修改 user 表,增加部门变更时间字段(可选)
ALTER TABLE `user`
ADD COLUMN `last_dept_change_time` BIGINT DEFAULT NULL COMMENT '最后部门变更时间' AFTER `system_role`;
-- 验证字段添加成功
SELECT '阶段2完成:表结构修改成功' AS status;
```
---
**【阶段3:数据初始化 - 部门创建与数据回填】**
```sql
-- =====================================================
-- 迁移脚本阶段3:数据初始化
-- 执行时间:预计5-10分钟(取决于租户数量)
-- 注意:此脚本需要根据实际租户数量调整
-- =====================================================
-- 3.1 为每个租户创建默认5个部门
-- 注意:此处使用存储过程批量创建,需要根据实际租户执行
DELIMITER $$
CREATE PROCEDURE CreateDefaultDepartments()
BEGIN
DECLARE done INT DEFAULT FALSE;
DECLARE v_tenant_id VARCHAR(32);
DECLARE v_admin_user_id VARCHAR(32);
DECLARE v_timestamp BIGINT;
DECLARE cur CURSOR FOR SELECT id FROM tenant WHERE status='1';
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
OPEN cur;
read_loop: LOOP
FETCH cur INTO v_tenant_id;
IF done THEN
LEAVE read_loop;
END IF;
-- 获取当前时间戳(毫秒)
SET v_timestamp = UNIX_TIMESTAMP(NOW()) * 1000;
-- 获取租户管理员ID(取第一个管理员)
SELECT user_id INTO v_admin_user_id
FROM user_tenant
WHERE tenant_id = v_tenant_id AND role IN ('OWNER', 'ADMIN')
LIMIT 1;
-- 如果没有管理员,使用系统默认ID
IF v_admin_user_id IS NULL THEN
SET v_admin_user_id = 'system';
END IF;
-- 创建5个默认部门(如果不存在)
INSERT INTO department (id, tenant_id, name, code, description, is_global, created_by, created_at, updated_at, status)
VALUES
(CONCAT(v_tenant_id, '_dept_rd'), v_tenant_id, '研发部', 'RD', '研发部门', 0, v_admin_user_id, v_timestamp, v_timestamp, '1'),
(CONCAT(v_tenant_id, '_dept_admin'), v_tenant_id, '综合部', 'ADMIN', '综合管理部门', 0, v_admin_user_id, v_timestamp, v_timestamp, '1'),
(CONCAT(v_tenant_id, '_dept_market'), v_tenant_id, '市场部', 'MARKET', '市场部门', 0, v_admin_user_id, v_timestamp, v_timestamp, '1'),
(CONCAT(v_tenant_id, '_dept_delivery'), v_tenant_id, '交付部', 'DELIVERY', '交付部门', 0, v_admin_user_id, v_timestamp, v_timestamp, '1'),
(CONCAT(v_tenant_id, '_dept_global'), v_tenant_id, '总知识库', 'GLOBAL', '总知识库(管理员逻辑视图)', 1, v_admin_user_id, v_timestamp, v_timestamp, '1')
ON DUPLICATE KEY UPDATE updated_at = v_timestamp;
END LOOP;
CLOSE cur;
SELECT '所有租户默认部门创建完成' AS result;
END$$
DELIMITER ;
-- 执行存储过程
CALL CreateDefaultDepartments();
-- 删除存储过程
DROP PROCEDURE IF EXISTS CreateDefaultDepartments;
-- 3.2 数据回填:将所有用户分配到"综合部"
UPDATE user_tenant ut
INNER JOIN department d ON ut.tenant_id = d.tenant_id AND d.code = 'ADMIN'
SET ut.department_id = d.id
WHERE ut.department_id IS NULL;
-- 3.3 数据回填:将所有知识库分配到"综合部"
UPDATE knowledgebase kb
INNER JOIN department d ON kb.tenant_id = d.tenant_id AND d.code = 'ADMIN'
SET kb.department_id = d.id, kb.is_global_kb = 0
WHERE kb.department_id IS NULL;
-- 验证数据回填成功
SELECT
(SELECT COUNT(*) FROM user_tenant WHERE department_id IS NULL) AS user_without_dept,
(SELECT COUNT(*) FROM knowledgebase WHERE department_id IS NULL) AS kb_without_dept,
(SELECT COUNT(*) FROM department WHERE is_global = 1) AS global_dept_count;
SELECT '阶段3完成:数据回填成功' AS status;
```
---
**【阶段4:引用关系初始化】**
```sql
-- =====================================================
-- 迁移脚本阶段4:初始化文档引用关系
-- 执行时间:预计10-60分钟(取决于文档数量)
-- 注意:此阶段数据量大,建议分批执行
-- =====================================================
-- 4.1 为所有现有文档创建引用关系(业务部门引用)
-- 根据 document 表和 knowledgebase 表的关系创建引用记录
INSERT INTO document_reference (
id,
tenant_id,
doc_id,
department_id,
kb_id,
filename_hash,
content_hash,
reference_type,
source_dept_id,
created_by,
created_at,
updated_at,
status
)
SELECT
CONCAT('ref_', d.id, '_', kb.id) AS id,
d.tenant_id,
d.id AS doc_id,
kb.department_id,
d.kb_id,
SHA2(d.name, 256) AS filename_hash,
COALESCE(d.content_hash, SHA2(CONCAT(d.id, d.name), 256)) AS content_hash,
'normal' AS reference_type,
NULL AS source_dept_id,
d.created_by,
d.create_time AS created_at,
d.update_time AS updated_at,
'1' AS status
FROM document d
INNER JOIN knowledgebase kb ON d.kb_id = kb.id
WHERE NOT EXISTS (
SELECT 1 FROM document_reference dr
WHERE dr.doc_id = d.id AND dr.kb_id = d.kb_id
);
-- 4.2 为所有文档创建总知识库引用
-- 每个文档在总知识库中都有一个镜像引用
INSERT INTO document_reference (
id,
tenant_id,
doc_id,
department_id,
kb_id,
filename_hash,
content_hash,
reference_type,
source_dept_id,
created_by,
created_at,
updated_at,
status
)
SELECT
CONCAT('ref_global_', d.id) AS id,
d.tenant_id,
d.id AS doc_id,
dept_global.id AS department_id,
kb_global.id AS kb_id,
SHA2(d.name, 256) AS filename_hash,
COALESCE(d.content_hash, SHA2(CONCAT(d.id, d.name), 256)) AS content_hash,
'global' AS reference_type,
kb_source.department_id AS source_dept_id,
d.created_by,
d.create_time AS created_at,
d.update_time AS updated_at,
'1' AS status
FROM document d
INNER JOIN knowledgebase kb_source ON d.kb_id = kb_source.id
INNER JOIN department dept_global ON d.tenant_id = dept_global.tenant_id AND dept_global.is_global = 1
LEFT JOIN knowledgebase kb_global ON dept_global.id = kb_global.department_id AND kb_global.is_global_kb = 1
WHERE NOT EXISTS (
SELECT 1 FROM document_reference dr
WHERE dr.doc_id = d.id AND dr.reference_type = 'global'
);
-- 注意:如果总知识库的 knowledgebase 记录不存在,需要先创建
-- 以下脚本创建总知识库的 KB 记录(如果不存在)
INSERT INTO knowledgebase (
id,
tenant_id,
name,
description,
department_id,
is_global_kb,
created_by,
create_time,
update_time,
status
)
SELECT
CONCAT(d.tenant_id, '_kb_global') AS id,
d.tenant_id,
'总知识库' AS name,
'管理员专用:聚合所有部门文档的逻辑视图' AS description,
d.id AS department_id,
1 AS is_global_kb,
d.created_by,
UNIX_TIMESTAMP(NOW()) * 1000 AS create_time,
UNIX_TIMESTAMP(NOW()) * 1000 AS update_time,
'1' AS status
FROM department d
WHERE d.is_global = 1
AND NOT EXISTS (
SELECT 1 FROM knowledgebase kb
WHERE kb.department_id = d.id AND kb.is_global_kb = 1
);
-- 验证引用关系创建成功
SELECT
(SELECT COUNT(*) FROM document_reference WHERE reference_type = 'normal') AS normal_refs,
(SELECT COUNT(*) FROM document_reference WHERE reference_type = 'global') AS global_refs,
(SELECT COUNT(*) FROM document) AS total_docs;
SELECT '阶段4完成:引用关系初始化成功' AS status;
```
---
**【阶段5:数据完整性验证】**
```sql
-- =====================================================
-- 迁移脚本阶段5:数据完整性验证
-- 执行时间:预计1-2分钟
-- =====================================================
-- 5.1 验证所有用户都有部门
SELECT 'User without department check' AS check_name,
COUNT(*) AS count,
CASE WHEN COUNT(*) = 0 THEN 'PASS' ELSE 'FAIL' END AS result
FROM user_tenant
WHERE department_id IS NULL;
-- 5.2 验证所有知识库都有部门
SELECT 'KB without department check' AS check_name,
COUNT(*) AS count,
CASE WHEN COUNT(*) = 0 THEN 'PASS' ELSE 'FAIL' END AS result
FROM knowledgebase
WHERE department_id IS NULL;
-- 5.3 验证每个租户都有总知识库部门
SELECT 'Global department check' AS check_name,
t.id AS tenant_id,
t.name AS tenant_name,
COUNT(d.id) AS global_dept_count,
CASE WHEN COUNT(d.id) = 1 THEN 'PASS' ELSE 'FAIL' END AS result
FROM tenant t
LEFT JOIN department d ON t.id = d.tenant_id AND d.is_global = 1
WHERE t.status = '1'
GROUP BY t.id, t.name;
-- 5.4 验证所有文档都有引用记录
SELECT 'Document reference check' AS check_name,
COUNT(*) AS docs_without_refs,
CASE WHEN COUNT(*) = 0 THEN 'PASS' ELSE 'FAIL' END AS result
FROM document
WHERE id NOT IN (SELECT DISTINCT doc_id FROM document_reference);
-- 5.5 验证引用关系的数据一致性
SELECT 'Reference consistency check' AS check_name,
COUNT(*) AS orphan_refs,
CASE WHEN COUNT(*) = 0 THEN 'PASS' ELSE 'FAIL' END AS result
FROM document_reference dr
LEFT JOIN document d ON dr.doc_id = d.id
WHERE d.id IS NULL;
SELECT '阶段5完成:数据验证完成,请检查上述结果' AS status;
```
---
**【PostgreSQL适配版本】**
如果使用PostgreSQL数据库,主要差异:
```sql
-- PostgreSQL字段类型差异
-- TINYINT(1) → BOOLEAN
-- BIGINT → BIGINT(相同)
-- VARCHAR(32) → VARCHAR(32)(相同)
-- CHAR(1) → CHAR(1)(相同)
-- 时间戳获取差异
-- MySQL: UNIX_TIMESTAMP(NOW()) * 1000
-- PostgreSQL: EXTRACT(EPOCH FROM NOW()) * 1000
-- 唯一键冲突处理差异
-- MySQL: ON DUPLICATE KEY UPDATE
-- PostgreSQL: ON CONFLICT DO UPDATE
-- 具体调整见完整PostgreSQL脚本(略)
```
--- ---
...@@ -691,6 +1732,13 @@ ...@@ -691,6 +1732,13 @@
| POST | /api/v1/departments/{id}/members | dept_admin+ | 添加部门成员 | | POST | /api/v1/departments/{id}/members | dept_admin+ | 添加部门成员 |
| DELETE | /api/v1/departments/{id}/members/{user_id} | dept_admin+ | 移除部门成员 | | DELETE | /api/v1/departments/{id}/members/{user_id} | dept_admin+ | 移除部门成员 |
**部门删除校验规则**:
- 必须满足:该部门无成员(user_tenant.department_id 无记录)
- 必须满足:该部门无知识库(knowledgebase.department_id 无记录)
- 必须满足:该部门无文档引用(document_reference.department_id 无记录)
- 必须满足:非总知识库部门(is_global != true)
- 如不满足任一条件,返回 400 错误并说明原因
#### 7.1.2 知识库接口(增强) #### 7.1.2 知识库接口(增强)
| 方法 | 路径 | 修改内容 | | 方法 | 路径 | 修改内容 |
...@@ -704,8 +1752,9 @@ ...@@ -704,8 +1752,9 @@
| 方法 | 路径 | 说明 | | 方法 | 路径 | 说明 |
|-----|------|------| |-----|------|------|
| POST | /api/v1/deduplication/check | 检查文件是否重复(预校验) | | POST | /api/v1/deduplication/check | 检查文件是否在当前部门重复(预校验) |
| GET | /api/v1/deduplication/stats | 获取去重统计 | | GET | /api/v1/deduplication/stats | 获取去重统计(管理员可见) |
| GET | /api/v1/documents/{doc_id}/references | 查询文档的引用关系(管理员可见) |
#### 7.1.4 用户角色接口 #### 7.1.4 用户角色接口
...@@ -783,16 +1832,394 @@ JWT Token 解析 ...@@ -783,16 +1832,394 @@ JWT Token 解析
#### 8.1.2 路由守卫设计 #### 8.1.2 路由守卫设计
**实现方式**: **实现方式**:
- 在路由配置中声明所需权限
- 高阶组件包裹需要权限控制的页面 1. 创建权限控制高阶组件(ProtectedRoute)
- 路由加载前进行权限检查 - 包裹所有需要权限控制的页面组件
- 不满足权限时重定向或提示 - 在组件渲染前进行权限检查
2. 在路由配置中声明所需权限
- 每个路由添加 requiredRole 字段
- 示例:{ path: '/user-setting/model', requiredRole: ['super_admin', 'tenant_admin'] }
3. 权限检查逻辑
- 从 UserRoleContext 获取当前用户的 role
- 判断用户的 role 是否在 requiredRole 数组中
- 权限满足 → 正常渲染页面
- 权限不足 → 重定向到 /unauthorized 页面并显示提示信息
4. 加载状态处理
- 权限信息加载中(loading=true)→ 显示页面加载动画
- 加载完成(loading=false)→ 执行权限判断
- 避免权限未加载完就跳转,导致闪屏问题
5. 实现思路(伪代码)
```
ProtectedRoute 组件逻辑:
- 从 Context 获取用户角色信息
- 检查加载状态
└─ 若 loading=true,显示 <PageLoading />
- 检查权限
└─ 若角色在 requiredRole 中,渲染 {children}
└─ 若角色不在,重定向到 /unauthorized + Toast提示
```
**路由权限配置表**:
| 路由路径 | 所需角色 | 无权限行为 |
|---------|---------|----------|
| /chat | 所有角色 | - |
| /knowledge-base | 所有角色 | - |
| /knowledge-base/create | dept_admin, tenant_admin, super_admin | 重定向到知识库列表 + 提示 |
| /user-setting/profile | 所有角色 | - |
| /user-setting/model | tenant_admin, super_admin | 重定向到首页 + 提示「您没有权限访问此页面」 |
| /user-setting/team | tenant_admin, super_admin | 重定向到首页 + 提示 |
| /user-setting/departments | tenant_admin, super_admin | 重定向到首页 + 提示 |
**路由权限分类**: **路由权限分类**:
- 公开路由:登录用户均可访问 - 公开路由:登录用户均可访问(个人资料、聊天、知识库查看)
- 部门权限路由:需要特定部门成员身份 - 部门管理路由:需要部门管理员及以上权限(创建知识库)
- 管理员权限路由:仅管理员可见 - 租户管理路由:仅租户管理员可见(模型配置、用户管理、部门管理)
- 超级管理员路由:仅超级管理员可见 - 超级管理员路由:仅超级管理员可见(跨租户管理)
**注意事项**:
- 前端路由守卫只是第一层防护(用户体验层)
- 后端API必须再次校验权限(安全层)
- 不要在前端做复杂的权限计算,权限数据从后端获取
- 权限信息需要在用户登录后立即加载并缓存到 Context
#### 8.1.3 路由守卫详细实现设计【P0前端安全】
**设计目标**:在路由级别实现权限控制,确保用户只能访问有权限的页面
**核心实现:ProtectedRoute 高阶组件**
```typescript
// 设计模式:高阶组件(HOC)包裹路由组件
// 文件位置:src/components/ProtectedRoute.tsx
/**
* 路由权限配置类型定义
*/
interface RouteConfig {
path: string;
requiredRoles: UserRole[]; // 允许访问的角色列表
redirectTo?: string; // 无权限时重定向路径,默认 /unauthorized
fallbackMessage?: string; // 无权限提示信息
}
/**
* 用户角色枚举
*/
enum UserRole {
SUPER_ADMIN = 'super_admin',
TENANT_ADMIN = 'tenant_admin',
DEPT_ADMIN = 'dept_admin',
MEMBER = 'member'
}
/**
* 用户角色上下文数据结构
*/
interface UserRoleContext {
user: {
id: string;
email: string;
nickname: string;
};
role: UserRole;
department: {
id: string;
name: string;
code: string;
};
permissions: {
canManageKB: boolean;
canManageModel: boolean;
canManageTeam: boolean;
canManageDept: boolean;
};
loading: boolean;
error: Error | null;
}
/**
* ProtectedRoute 组件实现思路
*/
function ProtectedRoute(props: {
children: ReactNode;
requiredRoles: UserRole[];
redirectTo?: string;
fallbackMessage?: string;
}) {
// 步骤1:从Context获取用户角色信息
const { role, loading, error } = useUserRole();
const navigate = useNavigate();
const toast = useToast();
// 步骤2:处理加载状态
if (loading) {
return <PageLoading />; // 显示全屏加载动画
}
// 步骤3:处理错误状态
if (error) {
return <ErrorPage message="无法获取用户权限信息" />;
}
// 步骤4:检查用户角色是否满足要求
const hasPermission = props.requiredRoles.includes(role);
// 步骤5:无权限处理
if (!hasPermission) {
// 显示提示消息
toast.error(props.fallbackMessage || '您没有权限访问此页面');
// 重定向到指定页面
const redirectPath = props.redirectTo || '/unauthorized';
navigate(redirectPath, { replace: true });
return null; // 不渲染任何内容
}
// 步骤6:有权限,正常渲染子组件
return <>{props.children}</>;
}
/**
* 路由配置示例(在路由文件中使用)
*/
const routes = [
{
path: '/chat',
element: <ChatPage />,
// 所有角色都可访问,不需要ProtectedRoute
},
{
path: '/knowledge-base',
element: <KnowledgeBasePage />,
// 所有角色都可访问
},
{
path: '/knowledge-base/create',
element: (
<ProtectedRoute
requiredRoles={[UserRole.DEPT_ADMIN, UserRole.TENANT_ADMIN, UserRole.SUPER_ADMIN]}
redirectTo="/knowledge-base"
fallbackMessage="仅管理员可以创建知识库"
>
<CreateKnowledgeBasePage />
</ProtectedRoute>
),
},
{
path: '/user-setting/model',
element: (
<ProtectedRoute
requiredRoles={[UserRole.TENANT_ADMIN, UserRole.SUPER_ADMIN]}
redirectTo="/"
fallbackMessage="您没有权限访问模型配置"
>
<ModelSettingPage />
</ProtectedRoute>
),
},
{
path: '/user-setting/team',
element: (
<ProtectedRoute
requiredRoles={[UserRole.TENANT_ADMIN, UserRole.SUPER_ADMIN]}
redirectTo="/"
fallbackMessage="您没有权限访问团队管理"
>
<TeamManagementPage />
</ProtectedRoute>
),
},
{
path: '/user-setting/departments',
element: (
<ProtectedRoute
requiredRoles={[UserRole.TENANT_ADMIN, UserRole.SUPER_ADMIN]}
redirectTo="/"
fallbackMessage="您没有权限访问部门管理"
>
<DepartmentManagementPage />
</ProtectedRoute>
),
},
];
/**
* UserRoleProvider 实现思路(提供全局角色上下文)
*/
function UserRoleProvider({ children }: { children: ReactNode }) {
const [roleData, setRoleData] = useState<UserRoleContext>({
user: null,
role: null,
department: null,
permissions: null,
loading: true,
error: null,
});
useEffect(() => {
// 用户登录后,立即加载角色信息
async function loadUserRole() {
try {
// 调用后端API获取用户角色
const response = await fetch('/api/v1/users/me/role', {
headers: {
'Authorization': `Bearer ${getToken()}`,
},
});
if (!response.ok) {
throw new Error('Failed to load user role');
}
const data = await response.json();
// 更新Context
setRoleData({
user: data.user,
role: data.role,
department: data.department,
permissions: {
canManageKB: ['dept_admin', 'tenant_admin', 'super_admin'].includes(data.role),
canManageModel: ['tenant_admin', 'super_admin'].includes(data.role),
canManageTeam: ['tenant_admin', 'super_admin'].includes(data.role),
canManageDept: ['tenant_admin', 'super_admin'].includes(data.role),
},
loading: false,
error: null,
});
// 缓存到localStorage(可选,减少重复请求)
localStorage.setItem('userRole', JSON.stringify(data));
} catch (error) {
setRoleData(prev => ({
...prev,
loading: false,
error: error as Error,
}));
}
}
loadUserRole();
}, []);
return (
<UserRoleContext.Provider value={roleData}>
{children}
</UserRoleContext.Provider>
);
}
/**
* 导航菜单动态渲染示例
*/
function NavigationMenu() {
const { role, permissions } = useUserRole();
// 根据角色和权限动态构建菜单
const menuItems = [
{
label: '聊天',
path: '/chat',
visible: true, // 所有角色可见
},
{
label: '知识库',
path: '/knowledge-base',
visible: true,
},
{
label: '模型配置',
path: '/user-setting/model',
visible: permissions.canManageModel, // 仅管理员可见
},
{
label: '团队管理',
path: '/user-setting/team',
visible: permissions.canManageTeam,
},
{
label: '部门管理',
path: '/user-setting/departments',
visible: permissions.canManageDept,
},
];
return (
<nav>
{menuItems
.filter(item => item.visible) // 仅渲染可见菜单
.map(item => (
<Link key={item.path} to={item.path}>
{item.label}
</Link>
))}
</nav>
);
}
```
**关键设计点**:
1. **加载状态处理**:
- 权限信息加载中显示 <PageLoading />,避免闪屏
- 加载完成后才进行权限判断
- 错误状态显示友好的错误页面
2. **权限判断逻辑**:
- 使用 requiredRoles 数组判断当前用户角色是否在允许列表中
- 不满足权限立即重定向,不渲染受保护的组件
- 显示友好的提示信息,告知用户无权限原因
3. **性能优化**:
- 角色信息加载一次后缓存到Context,避免重复请求
- 可选:缓存到localStorage,刷新页面后快速恢复
- 菜单仅渲染可见项,减少DOM节点
4. **安全防护**:
- 前端路由守卫是第一层防护(用户体验)
- 后端API必须再次校验权限(真正的安全层)
- 不在前端存储敏感权限逻辑,仅存储角色标识
5. **用户体验**:
- 无权限时自动重定向,不显示空白页
- Toast提示清晰说明原因
- 菜单自动隐藏无权限项,避免用户点击后被拒绝
**集成到应用入口**:
```typescript
// App.tsx 或 main.tsx
function App() {
return (
<UserRoleProvider> {/* 提供全局角色上下文 */}
<BrowserRouter>
<Routes>
{routes.map(route => (
<Route key={route.path} path={route.path} element={route.element} />
))}
</Routes>
</BrowserRouter>
</UserRoleProvider>
);
}
```
**测试场景**:
| 测试场景 | 用户角色 | 访问路径 | 期望行为 |
|---------|---------|---------|---------|
| 场景1 | member | /user-setting/model | 重定向到 / + Toast提示 |
| 场景2 | dept_admin | /knowledge-base/create | 正常访问 |
| 场景3 | tenant_admin | /user-setting/model | 正常访问 |
| 场景4 | member | /chat | 正常访问 |
| 场景5 | 未登录 | /knowledge-base | 重定向到 /login |
| 场景6 | 权限加载中 | 任意路径 | 显示加载动画 |
### 8.2 页面改造清单 ### 8.2 页面改造清单
...@@ -819,14 +2246,21 @@ JWT Token 解析 ...@@ -819,14 +2246,21 @@ JWT Token 解析
- 顶部展示所属部门信息 - 顶部展示所属部门信息
- 管理员可看到完整的设置菜单 - 管理员可看到完整的设置菜单
- 普通成员只能看到文件列表和聊天入口 - 普通成员只能看到文件列表和聊天入口
- 上传文件功能:所有部门成员可用(受去重约束) - 上传文件功能:所有部门成员可用(受同部门去重约束)
- 文件列表显示:
- 普通知识库:仅显示本知识库的文档
- 总知识库(管理员视图):显示所有部门的文档,带部门标签
- 文档来源标识:显示"来源部门"信息(如:研发部、市场部)
#### 8.2.4 聊天页面 #### 8.2.4 聊天页面
**改造要点**: **改造要点**:
- 知识库选择器只显示用户可访问的知识库 - 知识库选择器只显示用户可访问的知识库
- 普通成员和部门管理员:仅显示本部门知识库
- 租户管理员:显示所有部门知识库 + 总知识库
- 后端二次校验用户提交的知识库ID - 后端二次校验用户提交的知识库ID
- 不可访问的知识库不会出现在选择列表 - 不可访问的知识库不会出现在选择列表
- 聊天结果展示引用来源时,显示部门标识(如:研发部 > 技术文档库 > xxx.pdf)
#### 8.2.5 模型设置页面 #### 8.2.5 模型设置页面
...@@ -941,6 +2375,267 @@ JWT Token 解析 ...@@ -941,6 +2375,267 @@ JWT Token 解析
- 权限提升尝试 - 权限提升尝试
- 系统异常 - 系统异常
#### 9.3.3 监控与告警详细设计【P1运维保障】
**设计目标**:建立全方位的监控和告警机制,确保系统安全稳定运行,及时发现和处理异常情况
**监控架构**:
```
┌─────────────────────────────────────────────────────────┐
│ 监控数据收集层 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │应用日志 │ │数据库日志│ │系统指标 │ │业务指标 │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
└────────────────────┬────────────────────────────────────┘
│
┌────────────────────▼────────────────────────────────────┐
│ 监控分析处理层 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │日志聚合 │ │指标计算 │ │异常检测 │ │规则匹配 │ │
│ │(ELK) │ │(Prometheus)│ │(自定义) │ │(告警) │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
└────────────────────┬────────────────────────────────────┘
│
┌────────────────────▼────────────────────────────────────┐
│ 告警通知层 │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │邮件通知 │ │短信通知 │ │企业微信 │ │Webhook │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
└─────────────────────────────────────────────────────────┘
```
---
**【监控指标体系】**
**1. 安全监控指标**
| 指标名称 | 指标说明 | 监控方式 | 告警阈值 | 告警级别 |
|---------|---------|---------|---------|---------|
| 跨部门访问尝试 | 用户尝试访问非本部门知识库 | 日志统计 | 单用户5分钟内>10次 | P1-高 |
| 权限校验失败 | API权限检查返回403 | 日志统计 | 单用户5分钟内>20次 | P1-高 |
| 异常登录尝试 | 登录失败次数 | 认证日志 | 单IP 5分钟内>5次 | P0-紧急 |
| 大批量数据下载 | 单次下载文档数量 | API日志 | 单次>100个文档 | P1-高 |
| 数据导出操作 | 知识库导出操作 | 审计日志 | 管理员导出>1000文档 | P2-中 |
| 部门变更频繁 | 用户部门调整次数 | 数据库日志 | 单用户24小时内>3次 | P2-中 |
| 文档批量删除 | 单次删除文档数量 | 业务日志 | 单次>50个文档 | P1-高 |
| 敏感操作时间异常 | 非工作时间的敏感操作 | 审计日志 | 凌晨2-6点有管理操作 | P2-中 |
**2. 数据完整性监控指标**
| 指标名称 | 指标说明 | 监控方式 | 告警阈值 | 告警级别 |
|---------|---------|---------|---------|---------|
| 孤立文档数量 | Document无引用记录 | 定时SQL查询 | >10个 | P2-中 |
| 孤立引用数量 | 引用记录指向不存在的文档 | 定时SQL查询 | >5个 | P1-高 |
| 总知识库同步延迟 | 文档上传到总知识库引用创建的延迟 | 业务日志 | >10分钟 | P2-中 |
| 引用计数不一致 | 文档实际引用数与统计数不符 | 定时校验 | 差异>5% | P1-高 |
| 用户无部门数量 | user_tenant.department_id为空 | SQL查询 | >0个 | P0-紧急 |
| 知识库无部门数量 | knowledgebase.department_id为空 | SQL查询 | >0个 | P0-紧急 |
**3. 性能监控指标**
| 指标名称 | 指标说明 | 监控方式 | 告警阈值 | 告警级别 |
|---------|---------|---------|---------|---------|
| API响应时间 | 知识库列表查询耗时 | APM工具 | P95 > 1秒 | P2-中 |
| 向量检索耗时 | 向量检索平均耗时 | 业务日志 | 平均 > 2秒 | P2-中 |
| 去重检查耗时 | 文件上传去重检查耗时 | 业务日志 | > 500ms | P2-中 |
| 数据库慢查询 | 超过1秒的SQL查询 | 数据库日志 | 5分钟内>10次 | P1-高 |
| Redis缓存命中率 | 用户角色缓存命中率 | Redis监控 | < 80% | P2-中 |
| MinIO存储空间 | 对象存储使用率 | 系统监控 | > 85% | P1-高 |
| 数据库连接数 | 数据库连接池使用率 | 数据库监控 | > 80% | P1-高 |
**4. 业务监控指标**
| 指标名称 | 指标说明 | 监控方式 | 告警阈值 | 告警级别 |
|---------|---------|---------|---------|---------|
| 文档上传失败率 | 上传失败次数/总上传次数 | 业务日志 | > 5% | P2-中 |
| 聊天查询失败率 | 查询失败次数/总查询次数 | 业务日志 | > 2% | P1-高 |
| 清理任务执行状态 | 孤立引用清理任务是否执行 | 任务日志 | 连续2天未执行 | P1-高 |
| 同步任务积压 | 总知识库同步任务队列长度 | Redis队列 | > 1000个 | P2-中 |
| 活跃用户数 | 每日活跃用户数 | 业务统计 | 环比下降>30% | P3-低 |
| 文档上传量 | 每日文档上传数量 | 业务统计 | 连续3天<10个 | P3-低 |
---
**【告警规则配置】**
**告警级别定义**:
- **P0-紧急**:影响系统安全或核心功能,需立即处理
- 响应时间:5分钟内
- 通知方式:电话 + 短信 + 邮件 + 企业微信
- 接收人:值班工程师 + 技术负责人
- **P1-高**:影响用户体验或数据一致性,需尽快处理
- 响应时间:30分钟内
- 通知方式:短信 + 邮件 + 企业微信
- 接收人:值班工程师
- **P2-中**:需要关注但不紧急的问题
- 响应时间:2小时内
- 通知方式:邮件 + 企业微信
- 接收人:运维团队
- **P3-低**:信息性通知,定期处理
- 响应时间:1工作日内
- 通知方式:邮件
- 接收人:运维团队
**告警抑制规则**:
- 同一告警5分钟内仅发送1次(防止告警风暴)
- 非工作时间(22:00-8:00)P3级别告警不发送
- 告警恢复后发送恢复通知
- 告警升级机制:P1告警30分钟未处理自动升级为P0
---
**【审计日志详细设计】**
**审计日志字段定义**:
```
audit_log 表结构:
├─ id: VARCHAR(32) - 日志唯一标识
├─ tenant_id: VARCHAR(32) - 租户ID
├─ user_id: VARCHAR(32) - 操作用户ID
├─ username: VARCHAR(64) - 用户名
├─ role: VARCHAR(32) - 用户角色
├─ department_id: VARCHAR(32) - 用户所属部门
├─ action: VARCHAR(64) - 操作类型(见下表)
├─ resource_type: VARCHAR(32) - 资源类型(kb/document/user/dept)
├─ resource_id: VARCHAR(32) - 资源ID
├─ resource_name: VARCHAR(256) - 资源名称
├─ details: JSON - 操作详情(变更前后数据)
├─ ip_address: VARCHAR(45) - 操作IP地址
├─ user_agent: VARCHAR(256) - 用户代理
├─ result: VARCHAR(16) - 操作结果(success/fail)
├─ error_message: TEXT - 错误信息(如有)
├─ created_at: BIGINT - 操作时间戳
└─ INDEX(tenant_id, user_id, action, created_at)
```
**审计操作类型定义**:
| 操作类型 | 说明 | 是否审计 |
|---------|------|---------|
| dept.create | 创建部门 | 是 |
| dept.update | 修改部门 | 是 |
| dept.delete | 删除部门 | 是 |
| kb.create | 创建知识库 | 是 |
| kb.update | 修改知识库 | 是 |
| kb.delete | 删除知识库 | 是 |
| doc.upload | 上传文档 | 是 |
| doc.delete | 删除文档 | 是 |
| doc.download | 下载文档 | 是(管理员) |
| user.create | 创建用户 | 是 |
| user.update | 修改用户 | 是 |
| user.delete | 删除用户 | 是 |
| user.dept_change | 用户部门变更 | 是 |
| user.role_change | 用户角色变更 | 是 |
| model.update | 修改模型配置 | 是 |
| permission.denied | 权限拒绝 | 是(403错误) |
| cross_dept.attempt | 跨部门访问尝试 | 是 |
| login.success | 登录成功 | 否(仅记录失败) |
| login.fail | 登录失败 | 是 |
| chat.query | 聊天查询 | 否(日志量太大) |
**审计日志查询接口**:
```
GET /api/v1/admin/audit-logs
查询参数:
├─ tenant_id: 租户ID(可选,super_admin使用)
├─ user_id: 用户ID(可选)
├─ action: 操作类型(可选,支持多选)
├─ resource_type: 资源类型(可选)
├─ start_time: 开始时间(必填)
├─ end_time: 结束时间(必填)
├─ page: 页码(默认1)
└─ page_size: 每页数量(默认20,最大100)
返回示例:
{
"code": 0,
"data": {
"total": 1523,
"page": 1,
"page_size": 20,
"items": [
{
"id": "log_xxx",
"user_id": "user_123",
"username": "张三",
"role": "tenant_admin",
"action": "kb.delete",
"resource_type": "kb",
"resource_id": "kb_456",
"resource_name": "研发知识库",
"details": {
"department": "研发部",
"document_count": 25
},
"ip_address": "192.168.1.100",
"result": "success",
"created_at": 1726617600000
}
]
}
}
```
**审计日志保留策略**:
- 热数据(30天内):存储在MySQL,支持快速查询
- 温数据(31-90天):归档到对象存储,按需查询
- 冷数据(>90天):压缩存储,仅在合规审计时查询
- 永久保留:关键操作(删除、权限变更)永久保留
---
**【监控告警实施方案】**
**阶段1:基础监控(MVP)**
- 使用Python logging模块记录关键操作
- 使用简单的邮件告警(SMTP)
- 手动定期检查日志文件
- 预计开发时间:1周
**阶段2:完善监控(生产级)**
- 集成ELK Stack(Elasticsearch + Logstash + Kibana)
- 集成Prometheus + Grafana监控系统指标
- 配置企业微信/钉钉告警
- 建立审计日志表和查询接口
- 预计开发时间:2-3周
**阶段3:智能告警(优化)**
- 基于机器学习的异常检测
- 告警聚合和智能降噪
- 自动化告警处理(自愈)
- 告警趋势分析和报表
- 预计开发时间:持续优化
**监控Dashboard示例(Grafana)**:
```
Dashboard: RAGFlow企业版监控大盘
├─ 面板1:实时QPS(按接口分类)
├─ 面板2:API响应时间分布(P50/P95/P99)
├─ 面板3:权限拒绝次数趋势(按部门)
├─ 面板4:跨部门访问尝试热力图
├─ 面板5:数据完整性指标(孤立文档、引用数)
├─ 面板6:清理任务执行状态
├─ 面板7:数据库连接池使用率
├─ 面板8:Redis缓存命中率
├─ 面板9:MinIO存储空间使用
└─ 面板10:活跃用户数趋势
```
--- ---
## 第十章 部署架构 ## 第十章 部署架构
...@@ -1054,24 +2749,118 @@ JWT Token 解析 ...@@ -1054,24 +2749,118 @@ JWT Token 解析
#### 11.3.1 数据库优化 #### 11.3.1 数据库优化
- 索引优化:基于查询热点建立索引 **索引优化**:
- 查询优化:避免全表扫描 - 必须建立索引:knowledgebase(department_id)
- 连接池:合理配置数据库连接 - 必须建立索引:knowledgebase(tenant_id, department_id)
- 必须建立索引:document_reference(doc_id, department_id)
- 必须建立索引:document_reference(tenant_id, department_id, content_hash)
- 分页查询:前端默认每页20条,避免一次性加载所有
**去重查询优化**:
- document_reference 表的唯一索引必须建立:
- UNIQUE(tenant_id, department_id, filename_hash)
- UNIQUE(tenant_id, department_id, content_hash)
- 查询时使用索引提示:FORCE INDEX 强制走索引
- 上传前预检查:前端先调用检查接口,减少无效上传
**向量检索部门过滤**:
- 在 Elasticsearch 查询时,使用 filter context(不计算分数,速度快)
- 查询策略:先通过 document_reference 表获取允许的 doc_id 列表
- 再到向量库中检索这些 doc_id 对应的向量
- 避免在应用层进行二次过滤
**查询优化**:
- 避免全表扫描
- 合理配置数据库连接池
- 读写分离:读多写少场景 - 读写分离:读多写少场景
- 慢查询监控:记录超过1秒的查询
#### 11.3.2 缓存策略 #### 11.3.2 缓存策略
- 用户角色缓存:Redis 30分钟 **用户角色信息缓存**:
- 部门信息缓存:Redis 1小时 - 缓存位置:Redis
- 权限列表缓存:Redis 30分钟 - Key格式:user_role:{user_id}
- 知识库列表缓存:Redis 5分钟 - 数据内容:{role, department_id, department_name, permissions}
- 过期时间:30分钟
- 更新时机:管理员修改用户角色/部门时,主动删除缓存
**知识库列表缓存**:
- 按部门维度缓存知识库列表
- Key格式:kb_list:dept:{dept_id}
- 过期时间:5分钟
- 更新时机:创建/删除知识库时,主动删除缓存
**部门信息缓存**:
- Key格式:dept_info:{dept_id}
- 过期时间:1小时
- 更新时机:修改部门信息时,主动删除缓存
**文档引用关系缓存**(可选):
- Key格式:doc_refs:{doc_id}
- 数据内容:引用此文档的部门列表
- 过期时间:10分钟
- 用途:快速判断文档是否可删除
#### 11.3.3 异步处理 #### 11.3.3 异步处理
- 文档解析:异步任务 **文档解析**:
- 向量化:异步任务 - 异步任务队列处理
- 总知识库同步:异步任务 - 优先级:普通任务
- 邮件发送:异步任务 - 失败重试:最多3次
**向量化**:
- 异步任务队列处理
- 优先级:高优先级
- 批量处理:多个文档合并向量化
**总知识库引用同步优化**:
- 不要每上传一个文件就立即同步
- 策略:文件上传成功后,标记 need_sync=true
- 定时任务:每5分钟跑一次,批量处理所有 need_sync=true 的文档
- 好处:避免短时间大量上传导致同步任务堆积
**批量同步限流**:
- 同步任务每次最多处理100个文档
- 如果超过100个,分批处理,避免单次任务时间过长
- 失败重试:同步失败的文档加入重试队列
- 重试策略:最多重试3次,重试间隔 1分钟、5分钟、15分钟
- 告警机制:3次都失败后,发送告警给管理员
**孤立引用清理任务**:
- 定时任务:每天凌晨2点执行
- 清理逻辑:
- 查询总知识库的所有引用(reference_type='global')
- 检查每个引用的 doc_id 是否还有业务部门引用
- 若无业务部门引用,删除总知识库引用
- 若文档无任何引用,物理删除文档和MinIO文件
#### 11.3.4 前端性能优化
**知识库列表虚拟滚动**:
- 场景:当知识库数量超过100个时
- 方案:使用虚拟滚动(仅渲染可见区域的DOM节点)
- 推荐库:react-window 或 react-virtualized
- 效果:即使有1000个知识库,页面也流畅不卡顿
**权限检查前置**:
- 前端路由守卫尽早检查权限,避免加载不必要的资源
- 在路由配置中直接标记所需角色,路由加载前就拦截
- 减少无权限用户的网络请求和组件渲染开销
**组件懒加载**:
- 非首屏组件使用 React.lazy() 懒加载
- 管理员专用页面(部门管理、模型配置)仅管理员访问时才加载
- 减少初始包体积,加快首屏渲染
**请求合并与防抖**:
- 用户快速输入时,使用防抖(debounce)延迟搜索请求
- 多个接口数据可合并时,使用批量查询接口
- 减少网络请求次数
**图片懒加载**:
- 文档缩略图使用懒加载,滚动到可视区域才加载
- 使用 Intersection Observer API
- 减少初始页面加载时间
--- ---
......
#!/bin/bash
# RAGFlow 依赖安装脚本 - 分阶段安装避免依赖冲突
# 使用 conda 虚拟环境
set -e
echo "==================== RAGFlow 依赖安装计划 ===================="
echo "Python 版本要求: 3.13"
echo "安装目标: ragflow conda 虚拟环境"
echo ""
# 激活虚拟环境
echo "步骤 0: 激活虚拟环境"
source /datacore/ragflow/.venv/bin/activate
echo ""
echo "==================== 阶段 1: 核心基础包 ===================="
echo "安装 Python 核心工具和基础依赖"
pip install --no-deps \
setuptools==80.1.0 \
wheel \
pip==25.2
echo ""
echo "==================== 阶段 2: 底层依赖 ===================="
echo "安装底层 C 扩展和加密库"
pip install \
cffi==2.0.0 \
pycparser==2.23 \
cryptography==46.0.3 \
bcrypt==4.2.1 \
argon2-cffi==25.1.0 \
pycryptodomex==3.20.0
echo ""
echo "==================== 阶段 3: 数据处理核心 ===================="
echo "安装 numpy, pandas 等数据处理库"
pip install \
numpy==1.26.4 \
pandas==2.2.3 \
pillow==12.3.0 \
opencv-python==4.10.0.84 \
opencv-python-headless==4.10.0.84
echo ""
echo "==================== 阶段 4: 网络和异步库 ===================="
echo "安装 HTTP 客户端和异步框架"
pip install \
urllib3==2.7.0 \
certifi \
requests==2.32.3 \
aiohttp==3.14.3 \
httpx \
anyio \
sniffio
echo ""
echo "==================== 阶段 5: Web 框架 - Quart 优先 ===================="
echo "先安装 Quart 及其扩展(不要同时安装 Flask)"
pip install \
werkzeug==3.1.7 \
quart==0.20.0 \
quart-auth==0.11.0 \
quart-cors==0.8.0 \
quart-schema==0.23.0 \
hypercorn
echo ""
echo "==================== 阶段 6: Flask 扩展(兼容模式)===================="
echo "安装 Flask 扩展组件(不覆盖 Quart)"
pip install --no-deps \
flask-cors==6.0.2 \
flask-login==0.6.3 \
flask-mail==0.10.0 \
flask-session==0.8.0 \
flasgger==0.9.7.1
# 单独安装 Flask(如果需要)
pip install flask==3.0.3
echo ""
echo "==================== 阶段 7: 数据库驱动 ===================="
echo "安装数据库连接器"
pip install \
peewee==3.17.8 \
pymysql==1.1.1 \
mysql-connector-python==9.0.0 \
psycopg2-binary==2.9.11 \
redis==5.2.1 \
valkey==6.0.2
echo ""
echo "==================== 阶段 8: 搜索引擎客户端 ===================="
echo "安装 Elasticsearch 和 OpenSearch"
pip install \
elastic-transport==8.19.0 \
elasticsearch==8.12.0 \
elasticsearch-dsl==8.12.0 \
opensearch-py==2.7.1
echo ""
echo "==================== 阶段 9: 对象存储 ===================="
echo "安装 MinIO, S3, OSS 等"
pip install \
minio==7.2.4 \
boto3==1.28.0 \
oss2 \
cos-python-sdk-v5
echo ""
echo "==================== 阶段 10: 文件格式处理 ===================="
echo "安装文档和媒体文件处理库"
pip install \
python-docx==1.1.2 \
python-pptx==1.0.2 \
openpyxl==3.1.5 \
pypdf==6.16.1 \
pdfplumber==0.11.10 \
python-calamine==0.4.0 \
extract-msg==0.39.0 \
mammoth==1.11.0 \
reportlab==4.4.1
echo ""
echo "==================== 阶段 11: NLP 和文本处理 ===================="
echo "安装自然语言处理库"
pip install \
chardet==5.2.0 \
langdetect==1.0.9 \
nltk==3.10.0 \
jieba \
cn2an==0.5.22 \
roman-numbers==1.0.2 \
word2number==1.1 \
xpinyin==0.7.6
echo ""
echo "==================== 阶段 12: Spacy 和模型 ===================="
echo "安装 Spacy(不安装模型,避免 GitHub 超时)"
pip install spacy==3.8.14
echo ""
echo "==================== 阶段 13: AI/ML 库 ===================="
echo "安装机器学习和 AI 相关库"
pip install \
scikit-learn==1.5.0 \
xgboost==1.6.0 \
umap-learn==0.5.6 \
tiktoken==0.7.0 \
onnxruntime==1.23.2
echo ""
echo "==================== 阶段 14: LLM SDK ===================="
echo "安装各种 LLM 提供商的 SDK"
pip install \
openai \
anthropic==0.76.0 \
dashscope==1.25.11 \
cohere==5.6.2 \
groq==0.30.0 \
ollama==0.5.1 \
mistralai==2.7.2 \
replicate==0.31.0 \
voyageai==0.2.3 \
qianfan==0.4.6 \
litellm==1.84.0
echo ""
echo "==================== 阶段 15: 云服务 SDK ===================="
echo "安装云平台 SDK"
pip install \
azure-identity==1.25.3 \
azure-storage-file-datalake==12.16.0 \
google-api-python-client==2.190.0 \
google-auth-oauthlib==1.2.0 \
google-cloud-bigquery==3.25.0 \
google-cloud-storage==2.19.0 \
google-genai==1.41.0 \
tencentcloud-sdk-python==3.0.1478 \
volcengine==1.0.194
echo ""
echo "==================== 阶段 16: 协作工具 SDK ===================="
echo "安装 Slack, Discord, Telegram 等"
pip install \
slack-sdk==3.37.0 \
discord-py==2.3.2 \
python-telegram-bot==21.0 \
line-bot-sdk==3.0.0 \
wechatpy==1.8.18 \
atlassian-python-api==4.0.7 \
jira==3.10.5 \
pyairtable==3.3.0 \
pygithub==2.8.1 \
asana==5.2.2 \
python-gitlab==7.0.0 \
alibabacloud-dingtalk==2.0.0 \
lark-oapi==1.2.0
echo ""
echo "==================== 阶段 17: Web 爬虫和浏览器自动化 ===================="
echo "安装 Selenium, Playwright 等"
pip install \
selenium==4.22.0 \
selenium-wire==5.1.0 \
webdriver-manager==4.0.1 \
playwright \
beautifulsoup4 \
lxml==6.1.1 \
lxml-html-clean==0.4.5 \
html-text==0.6.2 \
trafilatura==2.0.0 \
readability-lxml==0.8.4 \
crawl4ai==0.9.2 \
duckduckgo-search==7.2.0
echo ""
echo "==================== 阶段 18: 数据源集成 ===================="
echo "安装各种数据源的客户端"
pip install \
dropbox==12.0.2 \
boxsdk==10.1.0 \
Office365-REST-Python-Client==2.6.2 \
webdav4==0.10.0 \
paramiko==3.5.1
echo ""
echo "==================== 阶段 19: 工具库 ===================="
echo "安装工具和辅助库"
pip install \
pyyaml \
ruamel-yaml==0.18.6 \
filelock \
loguru \
tenacity \
ormsgpack==1.6.0 \
xxhash==3.5.0 \
click==8.1.8 \
pyjwt \
python-dotenv==1.0.1 \
tabulate==0.9.0 \
tqdm \
regex==2025.11.3 \
rapidfuzz==3.14.5 \
demjson3==3.0.6 \
json-repair==0.60.1
echo ""
echo "==================== 阶段 20: 专用库 ===================="
echo "安装 RAGFlow 特定功能库"
pip install \
infinity-sdk==0.7.3 \
infinity-emb==0.0.66 \
langfuse==4.0.1 \
langgraph==1.2.0 \
mcp==1.28.1 \
agentrun-sdk==0.0.51 \
nest-asyncio==1.6.0 \
browser-use==0.11.1 \
ucloud-sandbox==1.4.2 \
zai-sdk==0.2.3 \
pyobvector==0.2.22 \
opendal==0.45.0 \
sqlglotrs==0.9.0 \
ranx==0.3.20 \
tavily-python==0.5.1 \
feedparser==6.0.11 \
arxiv==2.1.3 \
scholarly==1.7.11 \
wikipedia==1.4.0 \
yfinance==0.2.65 \
akshare==1.15.78 \
google-search-results==2.4.2 \
deepl==1.18.0 \
captcha==0.7.1 \
tika==2.6.0 \
pypandoc==1.16 \
markdown==3.8.1 \
markdown-to-json==2.1.1 \
markdownify==1.2.0 \
ffmpeg-python==0.2.0 \
mini-racer==0.12.4 \
pyclipper==1.4.0 \
pyodbc==5.2.0 \
pluginlib==0.10.0 \
exceptiongroup==1.3.0 \
beartype==0.20.0 \
bio==1.7.1 \
socksio==1.0.0 \
debugpy==1.8.13 \
aiosmtplib==5.1.1 \
moodlepy==0.23.0 \
mypy-boto3-s3==1.40.26 \
audioop-lts==0.2.1 \
protobuf==5.29.6 \
grpcio-status==1.67.1 \
trio==0.26.0
echo ""
echo "==================== 完成 ===================="
echo "依赖安装完成!"
echo ""
echo "注意事项:"
echo "1. Spacy 语言模型需要单独下载(避免 GitHub 超时):"
echo " python -m spacy download zh_core_web_sm"
echo " python -m spacy download en_core_web_sm"
echo ""
echo "2. 如果遇到包冲突,可以使用 pip install --force-reinstall 重装"
echo ""
echo "3. 验证安装:"
echo " cd /datacore/ragflow"
echo " python -c 'from api.db.db_models import init_database_tables; print(\"Success\")'"
echo ""
#!/bin/bash
# RAGFlow 快捷命令
# 将以下内容添加到 ~/.bashrc 或 ~/.zshrc 中,然后执行 source ~/.bashrc
# RAGFlow 服务管理别名
alias ragflow='/datacore/ragflow/ragflow_service.sh'
alias ragflow-start='/datacore/ragflow/ragflow_service.sh start'
alias ragflow-stop='/datacore/ragflow/ragflow_service.sh stop'
alias ragflow-restart='/datacore/ragflow/ragflow_service.sh restart'
alias ragflow-status='/datacore/ragflow/ragflow_service.sh status'
alias ragflow-logs='/datacore/ragflow/ragflow_service.sh logs'
alias ragflow-logs-backend='/datacore/ragflow/ragflow_service.sh logs backend'
alias ragflow-logs-frontend='/datacore/ragflow/ragflow_service.sh logs frontend'
# RAGFlow 快捷目录
alias cdragflow='cd /datacore/ragflow'
alias cdragflow-web='cd /datacore/ragflow/web'
alias cdragflow-api='cd /datacore/ragflow/api'
alias cdragflow-logs='cd /datacore/ragflow/logs'
echo "RAGFlow 快捷命令已加载!"
echo "使用 'ragflow' 查看帮助"
# RAGFlow 依赖清单 - 兼容版本
# 基于 pyproject.toml 生成,已解决循环依赖问题
# Python 版本: 3.13
# ==================== 核心基础 ====================
setuptools==80.1.0
wheel
pip==25.2
# ==================== 底层加密和安全 ====================
cffi==2.0.0
pycparser==2.23
cryptography==46.0.3
bcrypt==4.2.1
argon2-cffi==25.1.0
pycryptodomex==3.20.0
# ==================== 数据处理核心 ====================
numpy>=1.26.0,<2.0.0
pandas>=2.2.0,<3.0.0
pillow>=12.3.0,<13.0.0
opencv-python==4.10.0.84
opencv-python-headless==4.10.0.84
scikit-learn==1.5.0
xgboost==1.6.0
umap-learn==0.5.6
# ==================== 网络和 HTTP ====================
urllib3>=2.7.0
certifi
requests>=2.32.3,<3.0.0
aiohttp>=3.14.3
httpx
anyio
sniffio
socksio==1.0.0
# ==================== Web 框架(关键:顺序很重要!)====================
# 先安装 Quart 栈
werkzeug>=3.1.7,<4
quart==0.20.0
quart-auth==0.11.0
quart-cors==0.8.0
quart-schema==0.23.0
hypercorn
# Flask 扩展(不冲突)
flask-cors==6.0.2
flask-login==0.6.3
flask-mail>=0.10.0
flask-session==0.8.0
flasgger>=0.9.7.1,<0.10.0
# ==================== 数据库 ====================
peewee>=3.17.1,<4.0.0
pymysql>=1.1.1,<2.0.0
mysql-connector-python>=9.0.0,<10.0.0
psycopg2-binary>=2.9.11,<3.0.0
redis
valkey==6.0.2
# ==================== 搜索引擎 ====================
elastic-transport>=8.19.0
elasticsearch>=8.12.0
elasticsearch-dsl==8.12.0
opensearch-py==2.7.1
# ==================== 对象存储 ====================
minio==7.2.4
boto3>=1.28.0
oss2
cos-python-sdk-v5
mypy-boto3-s3==1.40.26
opendal>=0.45.0,<0.46.0
# ==================== 文档处理 ====================
python-docx>=1.1.2,<2.0.0
python-pptx>=1.0.2,<2.0.0
openpyxl>=3.1.0,<4.0.0
pypdf>=6.16.1
pdfplumber==0.11.10
python-calamine>=0.4.0
extract-msg>=0.39.0
mammoth>=1.11.0
reportlab>=4.4.1
tika==2.6.0
pypandoc>=1.16
# ==================== 网页解析 ====================
beautifulsoup4
lxml>=6.1.1
lxml-html-clean>=0.4.5
html-text==0.6.2
trafilatura>=2.0.0
readability-lxml>=0.8.4,<1.0.0
markdown>=3.8.1,<4.0.0
markdown-to-json==2.1.1
markdownify>=1.2.0
# ==================== NLP 核心 ====================
chardet>=5.2.0,<6.0.0
langdetect==1.0.9
nltk>=3.10.0
jieba
cn2an==0.5.22
roman-numbers==1.0.2
word2number==1.1
xpinyin==0.7.6
spacy==3.8.14
# Spacy 模型需要单独下载,避免 GitHub 超时
# ==================== AI/ML 框架 ====================
tiktoken==0.7.0
onnxruntime==1.23.2
# transformers # 可选,如果需要
# sentence-transformers # 可选,如果需要
# ==================== LLM SDK ====================
openai>=1.45.0
anthropic==0.76.0
dashscope==1.25.11
cohere==5.6.2
groq>=0.30.0,<1.0.0
ollama>=0.5.1
mistralai>=2.7.2,<3.0.0
replicate==0.31.0
voyageai==0.2.3
qianfan==0.4.6
litellm==1.84.0
google-genai>=1.41.0,<2.0.0
# ==================== 云服务 SDK ====================
azure-identity>=1.25.3
azure-storage-file-datalake==12.16.0
google-api-python-client>=2.190.0,<3.0.0
google-auth-oauthlib>=1.2.0,<2.0.0
google-cloud-bigquery>=3.25.0,<4.0.0
google-cloud-storage>=2.19.0,<3.0.0
tencentcloud-sdk-python==3.0.1478
volcengine==1.0.194
# ==================== 浏览器自动化 ====================
selenium==4.22.0
selenium-wire==5.1.0
webdriver-manager==4.0.1
playwright
crawl4ai>=0.9.2,<0.9.3
duckduckgo-search>=7.2.0,<8.0.0
browser-use>=0.11.1,<0.12.0
# ==================== 协作工具 SDK ====================
slack-sdk==3.37.0
discord-py==2.3.2
python-telegram-bot>=21.0
line-bot-sdk>=3.0.0
wechatpy>=1.8.18
atlassian-python-api==4.0.7
jira==3.10.5
pyairtable>=3.3.0
pygithub>=2.8.1
asana>=5.2.2
python-gitlab>=7.0.0
alibabacloud-dingtalk>=2.0.0
lark-oapi>=1.2.0
# ==================== 文件存储服务 ====================
dropbox==12.0.2
boxsdk>=10.1.0
Office365-REST-Python-Client==2.6.2
webdav4>=0.10.0,<0.11.0
paramiko>=3.5.1
# ==================== 工具库 ====================
pyyaml
ruamel-yaml>=0.18.6,<0.19.0
ruamel-base==1.0.0
filelock
loguru
tenacity
ormsgpack>=1.6.0
xxhash>=3.5.0,<4.0.0
click>=8.1.8
pyjwt
python-dotenv==1.0.1
python-dateutil==2.8.2
tabulate==0.9.0
tqdm
regex>=2025.11.3
rapidfuzz==3.14.5
demjson3==3.0.6
json-repair==0.60.1
six==1.16.0
# ==================== 数据和爬虫 ====================
feedparser>=6.0.11,<7.0.0
arxiv==2.1.3
scholarly==1.7.11
wikipedia==1.4.0
yfinance==0.2.65
akshare>=1.15.78,<2.0.0
google-search-results==2.4.2
# ==================== RAGFlow 专用 ====================
infinity-sdk==0.7.3
infinity-emb>=0.0.66,<0.0.67
langfuse>=4.0.1
langgraph==1.2.0
mcp>=1.28.1,<2.0.0
agentrun-sdk>=0.0.51,<1.0.0
nest-asyncio>=1.6.0,<2.0.0
ucloud-sandbox>=1.4.2,<2.0.0
zai-sdk>=0.2.3,<1.0.0
pyobvector==0.2.22
sqlglotrs==0.9.0
ranx==0.3.20
tavily-python==0.5.1
# ==================== 其他功能 ====================
deepl==1.18.0
captcha>=0.7.1
ffmpeg-python>=0.2.0
mini-racer>=0.12.4,<0.13.0
pyclipper>=1.4.0,<2.0.0
pyodbc>=5.2.0,<6.0.0
pluginlib>=0.10.0
exceptiongroup>=1.3.0,<2.0.0
beartype>=0.20.0,<1.0.0
bio==1.7.1
debugpy>=1.8.13
aiosmtplib>=5.1.1,<6.0.0
moodlepy>=0.23.0
audioop-lts>=0.2.1
protobuf>=5.29.6
grpcio-status==1.67.1
trio>=0.26.0
shapely==2.0.5
# ==================== 注意事项 ====================
# 1. 不要同时用 pip install flask quart - 会冲突
# 2. 先装 quart 栈,再装 flask-* 扩展
# 3. Spacy 模型要单独下载:
# python -m spacy download zh_core_web_sm
# python -m spacy download en_core_web_sm
# python -m spacy download de_core_news_sm
# python -m spacy download fr_core_news_sm
# python -m spacy download es_core_news_sm
# python -m spacy download pt_core_news_sm
# python -m spacy download ja_core_news_sm
# 4. graspologic 需要从 gitee 安装(在 pyproject.toml 中指定)
#!/usr/bin/env python3
"""
从魔塔下载布局分析模型
"""
from modelscope import snapshot_download
import os
import shutil
print("=" * 80)
print("下载布局分析模型")
print("=" * 80)
# 布局分析模型
layout_model_id = "damo/cv_dla34_table-structure-recognition_cycle-centernet"
print(f"\n正在下载布局分析模型: {layout_model_id}")
print("这可能需要几分钟时间...")
cache_dir = "/datacore/ragflow/rag/res/modelscope_cache"
os.makedirs(cache_dir, exist_ok=True)
try:
model_dir = snapshot_download(
layout_model_id,
cache_dir=cache_dir
)
print(f"✓ 模型下载成功: {model_dir}")
# 查找 .onnx 文件
for root, dirs, files in os.walk(model_dir):
for file in files:
if file.endswith('.onnx'):
src_path = os.path.join(root, file)
print(f"\n找到 ONNX 文件: {file}")
print(f"源路径: {src_path}")
# 复制到 RAGFlow 目录
dest_path = "/datacore/ragflow/rag/res/deepdoc/layout.onnx"
shutil.copy2(src_path, dest_path)
print(f"✓ 已复制到: {dest_path}")
# 获取文件大小
size_mb = os.path.getsize(dest_path) / (1024 * 1024)
print(f"文件大小: {size_mb:.2f} MB")
break
print("\n" + "=" * 80)
print("布局分析模型下载完成!")
print("=" * 80)
except Exception as e:
print(f"\n✗ 下载失败: {e}")
print("\n尝试备用模型...")
# 尝试其他布局模型
alternative_models = [
"damo/cv_resnet18_layout-analysis_publaynet",
"damo/cv_resnet18_layout-analysis_cdi",
]
for alt_model in alternative_models:
try:
print(f"\n正在尝试: {alt_model}")
model_dir = snapshot_download(
alt_model,
cache_dir=cache_dir
)
print(f"✓ 模型下载成功: {model_dir}")
# 查找 .onnx 文件
for root, dirs, files in os.walk(model_dir):
for file in files:
if file.endswith('.onnx'):
src_path = os.path.join(root, file)
dest_path = "/datacore/ragflow/rag/res/deepdoc/layout.onnx"
shutil.copy2(src_path, dest_path)
print(f"✓ 已复制到: {dest_path}")
size_mb = os.path.getsize(dest_path) / (1024 * 1024)
print(f"文件大小: {size_mb:.2f} MB")
print("\n" + "=" * 80)
print("布局分析模型下载完成!")
print("=" * 80)
exit(0)
except Exception as e2:
print(f"✗ {alt_model} 下载失败: {e2}")
continue
print("\n所有模型下载都失败了")
exit(1)
#!/usr/bin/env python3
"""
从 HuggingFace 镜像下载 RAGFlow 所需的 OCR 模型
"""
import os
import sys
from pathlib import Path
# 添加项目路径到 Python 路径
project_root = Path(__file__).parent.parent.absolute()
sys.path.insert(0, str(project_root))
from huggingface_hub import snapshot_download
def download_deepdoc_model():
"""下载 DeepDoc OCR 模型"""
print("=" * 80)
print("正在从 HuggingFace 镜像下载 RAGFlow DeepDoc OCR 模型...")
print("=" * 80)
# 目标目录
model_dir = project_root / "rag" / "res" / "deepdoc"
model_dir.mkdir(parents=True, exist_ok=True)
print(f"目标目录: {model_dir}")
print()
try:
# 设置 HuggingFace 镜像源
os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'
# 从 HuggingFace 下载模型 (InfiniFlow/deepdoc)
repo_id = "InfiniFlow/deepdoc"
print(f"下载模型: {repo_id}")
print("使用镜像源: https://hf-mirror.com")
print()
downloaded_path = snapshot_download(
repo_id=repo_id,
local_dir=str(model_dir),
local_dir_use_symlinks=False
)
print(f"✓ OCR 模型下载完成: {downloaded_path}")
print()
# 列出下载的文件
print("已下载的文件:")
for item in sorted(model_dir.rglob("*")):
if item.is_file():
size_mb = item.stat().st_size / (1024 * 1024)
print(f" {item.relative_to(model_dir)} ({size_mb:.2f} MB)")
print()
print("=" * 80)
print("OCR 模型下载完成!")
print(f"模型保存位置: {model_dir}")
print("=" * 80)
return True
except Exception as e:
print(f"✗ 下载失败: {e}", file=sys.stderr)
import traceback
traceback.print_exc()
return False
if __name__ == "__main__":
success = download_deepdoc_model()
sys.exit(0 if success else 1)
#!/usr/bin/env python3
"""
从魔塔(ModelScope)下载 RAGFlow 所需的 OCR 模型
"""
import os
import sys
from pathlib import Path
# 添加项目路径到 Python 路径
project_root = Path(__file__).parent.parent.absolute()
sys.path.insert(0, str(project_root))
from modelscope import snapshot_download
def download_deepdoc_model():
"""下载 DeepDoc OCR 模型"""
print("=" * 80)
print("正在从魔塔下载 RAGFlow DeepDoc OCR 模型...")
print("=" * 80)
# 目标目录
model_dir = project_root / "rag" / "res" / "deepdoc"
model_dir.parent.mkdir(parents=True, exist_ok=True)
print(f"目标目录: {model_dir}")
print()
try:
# 从魔塔下载模型(镜像 HuggingFace 的 InfiniFlow/deepdoc)
# 魔塔上对应的模型 ID
model_id = "iic/nlp_ocr_text-detection_db"
print(f"下载模型 1/2: {model_id}")
cache_dir = snapshot_download(
model_id,
cache_dir=str(model_dir / "text_detection")
)
print(f"✓ 文本检测模型下载完成: {cache_dir}")
print()
# 下载文本识别模型
model_id = "iic/nlp_ocr_recognition_general_base_zh"
print(f"下载模型 2/2: {model_id}")
cache_dir = snapshot_download(
model_id,
cache_dir=str(model_dir / "text_recognition")
)
print(f"✓ 文本识别模型下载完成: {cache_dir}")
print()
print("=" * 80)
print("所有 OCR 模型下载完成!")
print(f"模型保存位置: {model_dir}")
print("=" * 80)
return True
except Exception as e:
print(f"✗ 下载失败: {e}", file=sys.stderr)
print()
print("备选方案:使用 HuggingFace 镜像源")
print("请运行以下命令设置环境变量后重试:")
print("export HF_ENDPOINT=https://hf-mirror.com")
return False
if __name__ == "__main__":
success = download_deepdoc_model()
sys.exit(0 if success else 1)
#!/usr/bin/env python3
"""
从魔塔下载 PaddleOCR 模型用于 RAGFlow
"""
import os
import sys
from pathlib import Path
# 添加项目路径到 Python 路径
project_root = Path(__file__).parent.parent.absolute()
sys.path.insert(0, str(project_root))
from modelscope import snapshot_download
def download_paddle_ocr_models():
"""下载 PaddleOCR 模型"""
print("=" * 80)
print("正在从魔塔下载 PaddleOCR 模型...")
print("=" * 80)
# 目标目录
model_dir = project_root / "rag" / "res" / "deepdoc"
model_dir.mkdir(parents=True, exist_ok=True)
print(f"目标目录: {model_dir}")
print()
try:
# 下载文本检测模型 - PaddleOCR 中文检测
model_id = "damo/cv_resnet18_ocr-detection-db-line-level_damo"
print(f"下载模型 1/2: {model_id}")
cache_dir = snapshot_download(
model_id,
cache_dir=str(model_dir)
)
print(f"✓ 文本检测模型下载完成: {cache_dir}")
print()
# 下载文本识别模型 - PaddleOCR 中文识别
model_id = "damo/cv_convnextTiny_ocr-recognition-general_damo"
print(f"下载模型 2/2: {model_id}")
cache_dir = snapshot_download(
model_id,
cache_dir=str(model_dir)
)
print(f"✓ 文本识别模型下载完成: {cache_dir}")
print()
# 列出下载的文件
print("已下载的文件:")
for item in sorted(model_dir.rglob("*")):
if item.is_file():
size_mb = item.stat().st_size / (1024 * 1024)
print(f" {item.relative_to(model_dir)} ({size_mb:.2f} MB)")
print()
print("=" * 80)
print("OCR 模型下载完成!")
print(f"模型保存位置: {model_dir}")
print("=" * 80)
return True
except Exception as e:
print(f"✗ 下载失败: {e}", file=sys.stderr)
import traceback
traceback.print_exc()
return False
if __name__ == "__main__":
success = download_paddle_ocr_models()
sys.exit(0 if success else 1)
#!/bin/bash
#####################################################################
# RAGFlow 服务管理脚本
# 功能: 启动、停止、重启 RAGFlow 前端和后端服务
# 使用 conda 虚拟环境: ragflow
#####################################################################
set -e
# 配置项
CONDA_ENV="ragflow"
CONDA_PATH="/datacore/home/admin2/miniconda3"
PROJECT_ROOT="/datacore/ragflow"
WEB_DIR="$PROJECT_ROOT/web"
LOGS_DIR="$PROJECT_ROOT/logs"
# PID 文件
BACKEND_PID_FILE="$LOGS_DIR/backend.pid"
FRONTEND_PID_FILE="$LOGS_DIR/frontend.pid"
# 日志文件
BACKEND_LOG="$LOGS_DIR/backend.log"
FRONTEND_LOG="$LOGS_DIR/frontend.log"
# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color
#####################################################################
# 工具函数
#####################################################################
log_info() {
echo -e "${GREEN}[INFO]${NC} $1"
}
log_warn() {
echo -e "${YELLOW}[WARN]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
# 检查进程是否存在
is_running() {
local pid_file=$1
if [ -f "$pid_file" ]; then
local pid=$(cat "$pid_file")
if ps -p "$pid" > /dev/null 2>&1; then
return 0
else
rm -f "$pid_file"
return 1
fi
fi
return 1
}
# 创建日志目录
create_log_dir() {
if [ ! -d "$LOGS_DIR" ]; then
mkdir -p "$LOGS_DIR"
log_info "创建日志目录: $LOGS_DIR"
fi
}
# 安装前端依赖
install_frontend_deps() {
log_info "开始安装前端依赖..."
# 确保使用正确的 Node.js 版本
export PATH="/usr/local/bin:$PATH"
local npm_cmd="npm"
if [ -f "/usr/local/bin/npm" ]; then
npm_cmd="/usr/local/bin/npm"
fi
# 检查 Node.js 版本
local node_version=$($npm_cmd --version 2>/dev/null | head -1)
local actual_node=$($npm_cmd config get prefix 2>/dev/null)/bin/node
local actual_node_version=$($actual_node --version 2>/dev/null || echo "unknown")
log_info "使用 npm 版本: $node_version (Node.js: $actual_node_version)"
cd "$WEB_DIR"
if $npm_cmd install; then
log_info "前端依赖安装完成"
return 0
else
log_error "前端依赖安装失败"
return 1
fi
}
#####################################################################
# 环境检查
#####################################################################
check_service() {
local host=$1
local port=$2
local service_name=$3
if timeout 2 bash -c "cat < /dev/null > /dev/tcp/$host/$port" 2>/dev/null; then
log_info "✓ $service_name 服务正常 ($host:$port)"
return 0
else
log_error "✗ $service_name 服务未运行 ($host:$port)"
return 1
fi
}
check_env() {
log_info "检查运行环境..."
# 检查 conda 环境
if [ ! -d "$CONDA_PATH/envs/$CONDA_ENV" ]; then
log_error "Conda 环境 '$CONDA_ENV' 不存在"
log_error "路径: $CONDA_PATH/envs/$CONDA_ENV"
return 1
fi
# 检查 .env 文件
if [ ! -f "$PROJECT_ROOT/docker/.env" ]; then
log_warn ".env 配置文件不存在,将创建默认配置"
if [ -f "$PROJECT_ROOT/docker/.env.single-bucket-example" ]; then
cp "$PROJECT_ROOT/docker/.env.single-bucket-example" "$PROJECT_ROOT/docker/.env"
log_info "已从示例文件创建 .env"
else
log_error "找不到示例配置文件"
return 1
fi
fi
# 检查 Node.js 版本
if command -v node &> /dev/null; then
local node_version=$(node --version 2>/dev/null | sed 's/v//')
local required_version="22.12.0"
if [ -f "/usr/local/bin/node" ]; then
local system_node_version=$(/usr/local/bin/node --version 2>/dev/null | sed 's/v//')
if [[ "$system_node_version" > "$node_version" ]] || [[ "$system_node_version" == "$node_version" ]]; then
export PATH="/usr/local/bin:$PATH"
log_info "使用系统 Node.js v$system_node_version"
fi
fi
fi
# 检查前端 node_modules
if [ ! -d "$WEB_DIR/node_modules" ]; then
log_warn "前端依赖 node_modules 不存在"
log_info "自动安装前端依赖..."
if install_frontend_deps; then
log_info "前端依赖安装成功"
else
log_error "前端依赖安装失败"
return 1
fi
fi
log_info "环境检查完成"
# 检查必要的服务
log_info "检查基础服务..."
local services_ok=1
check_service "localhost" "3306" "MySQL" || services_ok=0
check_service "localhost" "6379" "Redis" || services_ok=0
check_service "localhost" "1200" "Elasticsearch" || services_ok=0
check_service "localhost" "9000" "MinIO" || services_ok=0
if [ $services_ok -eq 0 ]; then
log_warn "部分基础服务未运行,后端可能无法正常启动"
log_warn "RAGFlow 需要以下服务:"
log_warn " - MySQL (端口 3306)"
log_warn " - Redis (端口 6379)"
log_warn " - Elasticsearch (端口 1200)"
log_warn " - MinIO (端口 9000)"
log_warn ""
log_warn "如果有 Docker,请运行:"
log_warn " docker compose -f docker/docker-compose-base.yml up -d"
log_warn ""
read -p "是否继续启动? (y/N): " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
return 1
fi
else
log_info "所有基础服务检查通过"
fi
return 0
}
#####################################################################
# 启动服务
#####################################################################
start_backend() {
log_info "启动后端服务..."
if is_running "$BACKEND_PID_FILE"; then
log_warn "后端服务已经在运行中 (PID: $(cat $BACKEND_PID_FILE))"
return 0
fi
# 创建临时启动脚本,在 conda 环境中执行
local temp_script="/tmp/ragflow_backend_start_$$.sh"
cat > "$temp_script" << 'EOF'
#!/bin/bash
source "$1/bin/activate" "$2"
cd "$3"
export PYTHONPATH="$3"
export LD_LIBRARY_PATH=/usr/lib/x86_64-linux-gnu/
export NLTK_DATA="$3/ragflow_deps/nltk_data"
bash docker/launch_backend_service.sh
# 清理临时脚本
rm -f "$0"
EOF
chmod +x "$temp_script"
# 后台启动后端服务
nohup "$temp_script" "$CONDA_PATH" "$CONDA_ENV" "$PROJECT_ROOT" > "$BACKEND_LOG" 2>&1 &
local backend_pid=$!
echo "$backend_pid" > "$BACKEND_PID_FILE"
# 等待服务启动
sleep 3
if is_running "$BACKEND_PID_FILE"; then
log_info "后端服务启动成功 (PID: $backend_pid)"
log_info "后端日志: $BACKEND_LOG"
else
log_error "后端服务启动失败,请查看日志: $BACKEND_LOG"
return 1
fi
}
start_frontend() {
log_info "启动前端服务..."
if is_running "$FRONTEND_PID_FILE"; then
log_warn "前端服务已经在运行中 (PID: $(cat $FRONTEND_PID_FILE))"
return 0
fi
# 确保使用正确的 Node.js 版本
if [ -f "/usr/local/bin/node" ]; then
export PATH="/usr/local/bin:$PATH"
fi
# 启动前端开发服务器
cd "$WEB_DIR"
nohup npm run dev > "$FRONTEND_LOG" 2>&1 &
local frontend_pid=$!
echo "$frontend_pid" > "$FRONTEND_PID_FILE"
# 等待服务启动
sleep 5
if is_running "$FRONTEND_PID_FILE"; then
log_info "前端服务启动成功 (PID: $frontend_pid)"
log_info "前端日志: $FRONTEND_LOG"
log_info "前端访问地址: http://localhost:9866"
else
log_error "前端服务启动失败,请查看日志: $FRONTEND_LOG"
return 1
fi
}
start_services() {
create_log_dir
log_info "=========================================="
log_info "启动 RAGFlow 服务"
log_info "=========================================="
# 环境检查
if ! check_env; then
log_error "环境检查失败,无法启动服务"
return 1
fi
# 启动服务
local backend_ok=0
local frontend_ok=0
if start_backend; then
backend_ok=1
fi
if start_frontend; then
frontend_ok=1
fi
log_info "=========================================="
if [ $backend_ok -eq 1 ] && [ $frontend_ok -eq 1 ]; then
log_info "RAGFlow 服务启动完成"
elif [ $backend_ok -eq 1 ]; then
log_warn "仅后端服务启动成功"
elif [ $frontend_ok -eq 1 ]; then
log_warn "仅前端服务启动成功"
else
log_error "服务启动失败"
fi
log_info "=========================================="
if [ $backend_ok -eq 1 ]; then
log_info "查看后端日志: tail -f $BACKEND_LOG"
fi
if [ $frontend_ok -eq 1 ]; then
log_info "查看前端日志: tail -f $FRONTEND_LOG"
fi
}
#####################################################################
# 停止服务
#####################################################################
stop_backend() {
log_info "停止后端服务..."
if is_running "$BACKEND_PID_FILE"; then
local pid=$(cat "$BACKEND_PID_FILE")
kill "$pid" 2>/dev/null || true
# 等待进程退出
local count=0
while ps -p "$pid" > /dev/null 2>&1 && [ $count -lt 10 ]; do
sleep 1
count=$((count + 1))
done
# 如果还在运行,强制杀死
if ps -p "$pid" > /dev/null 2>&1; then
log_warn "后端服务未响应,强制停止..."
kill -9 "$pid" 2>/dev/null || true
fi
rm -f "$BACKEND_PID_FILE"
log_info "后端服务已停止"
else
log_warn "后端服务未运行"
fi
}
stop_frontend() {
log_info "停止前端服务..."
if is_running "$FRONTEND_PID_FILE"; then
local pid=$(cat "$FRONTEND_PID_FILE")
kill "$pid" 2>/dev/null || true
# 等待进程退出
local count=0
while ps -p "$pid" > /dev/null 2>&1 && [ $count -lt 10 ]; do
sleep 1
count=$((count + 1))
done
# 如果还在运行,强制杀死
if ps -p "$pid" > /dev/null 2>&1; then
log_warn "前端服务未响应,强制停止..."
kill -9 "$pid" 2>/dev/null || true
fi
rm -f "$FRONTEND_PID_FILE"
log_info "前端服务已停止"
else
log_warn "前端服务未运行"
fi
}
stop_services() {
log_info "=========================================="
log_info "停止 RAGFlow 服务"
log_info "=========================================="
stop_frontend
stop_backend
log_info "=========================================="
log_info "RAGFlow 服务已全部停止"
log_info "=========================================="
}
#####################################################################
# 重启服务
#####################################################################
restart_services() {
log_info "=========================================="
log_info "重启 RAGFlow 服务"
log_info "=========================================="
stop_services
sleep 2
start_services
}
#####################################################################
# 查看状态
#####################################################################
status_services() {
log_info "=========================================="
log_info "RAGFlow 服务状态"
log_info "=========================================="
if is_running "$BACKEND_PID_FILE"; then
log_info "后端服务: ${GREEN}运行中${NC} (PID: $(cat $BACKEND_PID_FILE))"
else
log_info "后端服务: ${RED}未运行${NC}"
fi
if is_running "$FRONTEND_PID_FILE"; then
log_info "前端服务: ${GREEN}运行中${NC} (PID: $(cat $FRONTEND_PID_FILE))"
else
log_info "前端服务: ${RED}未运行${NC}"
fi
log_info "=========================================="
}
#####################################################################
# 查看日志
#####################################################################
show_logs() {
local log_type=${1:-all}
case "$log_type" in
backend)
if [ -f "$BACKEND_LOG" ]; then
log_info "显示后端日志 (Ctrl+C 退出):"
tail -f "$BACKEND_LOG"
else
log_error "后端日志文件不存在: $BACKEND_LOG"
fi
;;
frontend)
if [ -f "$FRONTEND_LOG" ]; then
log_info "显示前端日志 (Ctrl+C 退出):"
tail -f "$FRONTEND_LOG"
else
log_error "前端日志文件不存在: $FRONTEND_LOG"
fi
;;
all)
log_info "显示所有日志 (Ctrl+C 退出):"
if [ -f "$BACKEND_LOG" ] && [ -f "$FRONTEND_LOG" ]; then
tail -f "$BACKEND_LOG" "$FRONTEND_LOG"
elif [ -f "$BACKEND_LOG" ]; then
tail -f "$BACKEND_LOG"
elif [ -f "$FRONTEND_LOG" ]; then
tail -f "$FRONTEND_LOG"
else
log_error "没有可用的日志文件"
fi
;;
*)
log_error "未知的日志类型: $log_type"
log_info "可用选项: backend, frontend, all"
;;
esac
}
#####################################################################
# 使用说明
#####################################################################
usage() {
cat << EOF
RAGFlow 服务管理脚本
用法: $0 {start|stop|restart|status|logs}
命令:
start 启动 RAGFlow 前端和后端服务
stop 停止 RAGFlow 前端和后端服务
restart 重启 RAGFlow 前端和后端服务
status 查看服务运行状态
logs 查看日志 (可选参数: backend, frontend, all)
示例:
$0 start # 启动服务
$0 stop # 停止服务
$0 restart # 重启服务
$0 status # 查看状态
$0 logs # 查看所有日志
$0 logs backend # 只查看后端日志
$0 logs frontend # 只查看前端日志
日志位置:
后端日志: $BACKEND_LOG
前端日志: $FRONTEND_LOG
EOF
exit 1
}
#####################################################################
# 主程序
#####################################################################
main() {
if [ $# -eq 0 ]; then
usage
fi
local command=$1
shift
case "$command" in
start)
start_services
;;
stop)
stop_services
;;
restart)
restart_services
;;
status)
status_services
;;
logs)
show_logs "$@"
;;
*)
log_error "未知命令: $command"
usage
;;
esac
}
main "$@"
#!/usr/bin/env python3
"""
RAGFlow 服务管理脚本
用于启动、停止、重启前后端服务
"""
import os
import sys
import time
import signal
import subprocess
from pathlib import Path
from datetime import datetime
class ServiceManager:
def __init__(self):
# 项目根目录
self.project_root = Path(__file__).parent.parent.absolute()
self.venv_path = self.project_root / ".venv"
self.log_dir = self.project_root / "logs"
self.pid_dir = self.project_root / "logs"
# PID 文件
self.backend_pid_file = self.pid_dir / "backend.pid"
self.frontend_pid_file = self.pid_dir / "frontend.pid"
self.taskexecutor_pid_file = self.pid_dir / "taskexecutor.pid"
# 日志文件
self.backend_log = self.log_dir / "backend.log"
self.frontend_log = self.log_dir / "frontend.log"
self.taskexecutor_log = self.log_dir / "taskexecutor.log"
# 确保目录存在
self.log_dir.mkdir(parents=True, exist_ok=True)
self.pid_dir.mkdir(parents=True, exist_ok=True)
def log(self, message, level="INFO"):
"""输出带时间戳的日志"""
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(f"[{timestamp}] [{level}] {message}")
def read_pid(self, pid_file):
"""读取 PID 文件"""
if not pid_file.exists():
return None
try:
with open(pid_file, 'r') as f:
pid = int(f.read().strip())
# 检查进程是否存在
try:
os.kill(pid, 0)
return pid
except OSError:
# 进程不存在,删除过期的 PID 文件
pid_file.unlink()
return None
except (ValueError, FileNotFoundError):
return None
def write_pid(self, pid_file, pid):
"""写入 PID 文件"""
with open(pid_file, 'w') as f:
f.write(str(pid))
def kill_process(self, pid, service_name, timeout=10):
"""终止进程"""
try:
self.log(f"正在停止 {service_name} (PID: {pid})...")
os.kill(pid, signal.SIGTERM)
# 等待进程结束
for _ in range(timeout):
try:
os.kill(pid, 0)
time.sleep(1)
except OSError:
self.log(f"{service_name} 已停止")
return True
# 超时后强制杀死
self.log(f"{service_name} 未响应,强制终止...")
os.kill(pid, signal.SIGKILL)
time.sleep(1)
self.log(f"{service_name} 已强制停止")
return True
except ProcessLookupError:
self.log(f"{service_name} 进程不存在")
return True
except Exception as e:
self.log(f"停止 {service_name} 失败: {e}", "ERROR")
return False
def start_backend(self):
"""启动后端服务"""
pid = self.read_pid(self.backend_pid_file)
if pid:
self.log(f"后端服务已在运行 (PID: {pid})", "WARNING")
return False
self.log("正在启动后端服务...")
# 构建启动命令
python_path = self.venv_path / "bin" / "python"
api_script = self.project_root / "api" / "ragflow_server.py"
env = os.environ.copy()
env["PYTHONPATH"] = str(self.project_root)
env["USE_PADDLEOCR"] = "1" # 启用 PaddleOCR 中文识别
# 启动后端
with open(self.backend_log, 'a') as log_file:
log_file.write(f"\n{'='*80}\n")
log_file.write(f"后端服务启动时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
log_file.write(f"{'='*80}\n\n")
process = subprocess.Popen(
[str(python_path), str(api_script)],
cwd=str(self.project_root),
env=env,
stdout=log_file,
stderr=subprocess.STDOUT,
start_new_session=True
)
# 写入 PID
self.write_pid(self.backend_pid_file, process.pid)
self.log(f"后端服务已启动 (PID: {process.pid})")
self.log(f"后端日志: {self.backend_log}")
# 等待服务启动
self.log("等待后端服务初始化...")
time.sleep(3)
return True
def start_frontend(self):
"""启动前端服务"""
pid = self.read_pid(self.frontend_pid_file)
if pid:
self.log(f"前端服务已在运行 (PID: {pid})", "WARNING")
return False
self.log("正在启动前端服务...")
web_dir = self.project_root / "web"
# 启动前端
with open(self.frontend_log, 'a') as log_file:
log_file.write(f"\n{'='*80}\n")
log_file.write(f"前端服务启动时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
log_file.write(f"{'='*80}\n\n")
process = subprocess.Popen(
["npm", "run", "dev"],
cwd=str(web_dir),
stdout=log_file,
stderr=subprocess.STDOUT,
start_new_session=True
)
# 写入 PID
self.write_pid(self.frontend_pid_file, process.pid)
self.log(f"前端服务已启动 (PID: {process.pid})")
self.log(f"前端日志: {self.frontend_log}")
# 等待服务启动
self.log("等待前端服务初始化...")
time.sleep(3)
return True
def start_taskexecutor(self):
"""启动任务执行器服务"""
pid = self.read_pid(self.taskexecutor_pid_file)
if pid:
self.log(f"任务执行器已在运行 (PID: {pid})", "WARNING")
return False
self.log("正在启动任务执行器...")
python_path = self.venv_path / "bin" / "python"
task_script = self.project_root / "rag" / "svr" / "task_executor.py"
env = os.environ.copy()
env["PYTHONPATH"] = str(self.project_root)
env["USE_PADDLEOCR"] = "1" # 启用 PaddleOCR 中文识别
# 启动任务执行器
with open(self.taskexecutor_log, 'a') as log_file:
log_file.write(f"\n{'='*80}\n")
log_file.write(f"任务执行器启动时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
log_file.write(f"{'='*80}\n\n")
process = subprocess.Popen(
[str(python_path), str(task_script), "-i", "local_0", "-t", "common"],
cwd=str(self.project_root),
env=env,
stdout=log_file,
stderr=subprocess.STDOUT,
start_new_session=True
)
# 写入 PID
self.write_pid(self.taskexecutor_pid_file, process.pid)
self.log(f"任务执行器已启动 (PID: {process.pid})")
self.log(f"任务执行器日志: {self.taskexecutor_log}")
# 等待服务启动
self.log("等待任务执行器初始化...")
time.sleep(3)
return True
def find_process_by_cmdline(self, keyword):
"""通过命令行关键字查找进程"""
try:
result = subprocess.run(
["ps", "aux"],
capture_output=True,
text=True
)
pids = []
for line in result.stdout.split('\n'):
if keyword in line and 'grep' not in line:
parts = line.split()
if len(parts) > 1:
try:
pids.append(int(parts[1]))
except ValueError:
pass
return pids
except Exception as e:
self.log(f"查找进程失败: {e}", "ERROR")
return []
def stop_backend(self):
"""停止后端服务"""
pid = self.read_pid(self.backend_pid_file)
stopped = False
if pid:
if self.kill_process(pid, "后端服务"):
self.backend_pid_file.unlink(missing_ok=True)
stopped = True
# 额外检查是否有遗留的后端进程
backend_pids = self.find_process_by_cmdline("ragflow_server.py")
for pid in backend_pids:
self.log(f"发现遗留的后端进程 (PID: {pid}),正在清理...")
self.kill_process(pid, "后端服务")
stopped = True
if not stopped:
self.log("后端服务未运行", "WARNING")
return True
def stop_frontend(self):
"""停止前端服务"""
pid = self.read_pid(self.frontend_pid_file)
stopped = False
if pid:
if self.kill_process(pid, "前端服务"):
self.frontend_pid_file.unlink(missing_ok=True)
stopped = True
# 额外检查是否有遗留的前端进程(包括 npm 和 vite)
frontend_keywords = ["npm run dev", "vite --host", "esbuild --service"]
for keyword in frontend_keywords:
pids = self.find_process_by_cmdline(keyword)
for pid in pids:
# 确保是 ragflow web 目录下的进程
try:
result = subprocess.run(
["ps", "-p", str(pid), "-o", "cwd="],
capture_output=True,
text=True
)
cwd = result.stdout.strip()
if "ragflow/web" in cwd or "ragflow" in cwd:
self.log(f"发现遗留的前端进程 (PID: {pid}),正在清理...")
self.kill_process(pid, "前端服务")
stopped = True
except Exception:
pass
if not stopped:
self.log("前端服务未运行", "WARNING")
return True
def stop_taskexecutor(self):
"""停止任务执行器"""
pid = self.read_pid(self.taskexecutor_pid_file)
stopped = False
if pid:
if self.kill_process(pid, "任务执行器"):
self.taskexecutor_pid_file.unlink(missing_ok=True)
stopped = True
# 检查遗留的任务执行器进程
taskexecutor_pids = self.find_process_by_cmdline("task_executor.py")
for pid in taskexecutor_pids:
self.log(f"发现遗留的任务执行器进程 (PID: {pid}),正在清理...")
self.kill_process(pid, "任务执行器")
stopped = True
if not stopped:
self.log("任务执行器未运行", "WARNING")
return True
def status(self):
"""查看服务状态"""
self.log("=" * 60)
self.log("RAGFlow 服务状态")
self.log("=" * 60)
backend_pid = self.read_pid(self.backend_pid_file)
frontend_pid = self.read_pid(self.frontend_pid_file)
taskexecutor_pid = self.read_pid(self.taskexecutor_pid_file)
if backend_pid:
self.log(f"后端服务: 运行中 (PID: {backend_pid})")
else:
self.log("后端服务: 未运行")
if frontend_pid:
self.log(f"前端服务: 运行中 (PID: {frontend_pid})")
else:
self.log("前端服务: 未运行")
if taskexecutor_pid:
self.log(f"任务执行器: 运行中 (PID: {taskexecutor_pid})")
else:
self.log("任务执行器: 未运行")
self.log("=" * 60)
def start(self):
"""启动所有服务"""
self.log("=" * 60)
self.log("启动 RAGFlow 服务")
self.log("=" * 60)
# 启动后端
self.start_backend()
# 启动任务执行器
self.start_taskexecutor()
# 启动前端
self.start_frontend()
self.log("=" * 60)
self.log("所有服务已启动")
self.log(f"前端访问地址: http://localhost:9866")
self.log(f"后端 API 地址: http://localhost:7660")
self.log("=" * 60)
def stop(self):
"""停止所有服务"""
self.log("=" * 60)
self.log("停止 RAGFlow 服务")
self.log("=" * 60)
# 停止前端
self.stop_frontend()
# 停止任务执行器
self.stop_taskexecutor()
# 停止后端
self.stop_backend()
self.log("=" * 60)
self.log("所有服务已停止")
self.log("=" * 60)
def restart(self):
"""重启所有服务"""
self.log("=" * 60)
self.log("重启 RAGFlow 服务")
self.log("=" * 60)
# 停止服务
self.stop()
# 等待一下
time.sleep(2)
# 启动服务
self.start()
def print_usage():
"""打印使用说明"""
print("""
RAGFlow 服务管理脚本
用法:
python service_manager.py [命令]
命令:
start 启动前后端服务
stop 停止前后端服务
restart 重启前后端服务
status 查看服务状态
示例:
python service_manager.py start
python service_manager.py stop
python service_manager.py restart
python service_manager.py status
""")
def main():
if len(sys.argv) < 2:
print_usage()
sys.exit(1)
command = sys.argv[1].lower()
manager = ServiceManager()
try:
if command == "start":
manager.start()
elif command == "stop":
manager.stop()
elif command == "restart":
manager.restart()
elif command == "status":
manager.status()
else:
print(f"错误: 未知命令 '{command}'")
print_usage()
sys.exit(1)
except KeyboardInterrupt:
print("\n操作已取消")
sys.exit(0)
except Exception as e:
print(f"错误: {e}", file=sys.stderr)
sys.exit(1)
if __name__ == "__main__":
main()
#!/usr/bin/env python3
"""
Test ai-assistant-redis connection
"""
import redis
import sys
def test_redis_connection():
"""Test connection to ai-assistant-redis"""
# Based on your screenshot, ai-assistant-redis is on port 6379
configs = [
{
"name": "ai-assistant-redis (local)",
"host": "localhost",
"port": 6379,
"passwords": ["assitant123", "123456", "admin123", None]
},
{
"name": "ai-assistant-redis (183.230.227.10)",
"host": "183.230.227.10",
"port": 6379,
"passwords": ["assitant123", "123456", "admin123", None]
},
]
print("=" * 70)
print("Testing ai-assistant-redis Connection")
print("=" * 70)
for config in configs:
print(f"\n📍 Testing {config['name']}")
print(f" Host: {config['host']}:{config['port']}")
print("-" * 70)
for pwd in config['passwords']:
pwd_display = "(no password)" if pwd is None else f"'{pwd}'"
try:
client = redis.Redis(
host=config['host'],
port=config['port'],
password=pwd,
socket_connect_timeout=3,
decode_responses=True
)
# Test connection
response = client.ping()
# Get server info
info = client.info('server')
redis_version = info.get('redis_version', 'unknown')
# Test basic operations
client.set('test_key', 'test_value', ex=10)
value = client.get('test_key')
client.delete('test_key')
print(f" ✅ Password {pwd_display} WORKS!")
print(f" Redis version: {redis_version}")
print(f" Ping response: {response}")
print(f" Read/Write test: PASSED")
client.close()
print(f"\n{'='*70}")
print(f"✅ SUCCESS: Connected to {config['name']}")
print(f" Host: {config['host']}:{config['port']}")
print(f" Password: {pwd_display}")
print(f" Version: {redis_version}")
print(f"{'='*70}")
return True
except redis.exceptions.AuthenticationError as e:
print(f" ❌ Password {pwd_display} - Auth failed: {e}")
except redis.exceptions.ConnectionError as e:
print(f" ❌ Password {pwd_display} - Connection failed: {e}")
break # No need to try other passwords if connection fails
except Exception as e:
print(f" ❌ Password {pwd_display} - Error: {e}")
print(f"\n{'='*70}")
print("❌ FAILED: Could not connect to ai-assistant-redis")
print("\nPlease verify:")
print(" 1. Container is running: docker ps | grep redis")
print(" 2. Port is exposed correctly")
print(" 3. Correct password is used")
print(f"{'='*70}")
return False
if __name__ == "__main__":
success = test_redis_connection()
sys.exit(0 if success else 1)
#!/usr/bin/env python3
"""
External Services Connectivity Test
Tests connectivity to external MySQL and Redis services.
"""
import sys
# Test MySQL connectivity
def test_mysql():
"""Test MySQL connection to 183.230.227.10:3306"""
print("=" * 60)
print("Testing MySQL Connection")
print("=" * 60)
print(f"Host: 183.230.227.10:3306")
print(f"User: root")
print(f"Password: 123456")
try:
import pymysql
print("✓ pymysql module loaded")
except ImportError:
print("✗ pymysql not installed, trying to install...")
import subprocess
subprocess.check_call([sys.executable, "-m", "pip", "install", "pymysql"])
import pymysql
print("✓ pymysql installed and loaded")
try:
connection = pymysql.connect(
host='183.230.227.10',
port=3306,
user='root',
password='123456',
connect_timeout=10
)
print("✓ MySQL connection successful")
with connection.cursor() as cursor:
cursor.execute("SELECT VERSION()")
version = cursor.fetchone()
print(f" MySQL version: {version[0]}")
cursor.execute("SHOW DATABASES")
databases = cursor.fetchall()
db_names = [db[0] for db in databases]
print(f" Available databases: {', '.join(db_names[:10])}")
# Check if our databases exist
for db_name in ['rag_flow', 'rag_flow_dev', 'rag_flow_test', 'rag_flow_prod']:
if db_name in db_names:
print(f" ✓ Database '{db_name}' exists")
else:
print(f" ℹ Database '{db_name}' does not exist (will be created on first run)")
connection.close()
print("\n✅ MySQL connectivity test PASSED\n")
return True
except Exception as e:
print(f"\n✗ MySQL connection failed: {e}")
print("❌ MySQL connectivity test FAILED\n")
return False
def test_redis():
"""Test Redis connection to 183.230.227.10:6379"""
print("=" * 60)
print("Testing Redis Connection")
print("=" * 60)
print(f"Host: 183.230.227.10:6379")
print(f"Password: assitant123")
try:
import redis
print("✓ redis module loaded")
except ImportError:
print("✗ redis not installed, trying to install...")
import subprocess
subprocess.check_call([sys.executable, "-m", "pip", "install", "redis"])
import redis
print("✓ redis installed and loaded")
try:
client = redis.Redis(
host='183.230.227.10',
port=6379,
password='assitant123',
socket_connect_timeout=10,
decode_responses=True
)
# Test connection with PING
response = client.ping()
print("✓ Redis connection successful (PING response: PONG)")
# Get server info
info = client.info('server')
print(f" Redis version: {info.get('redis_version', 'unknown')}")
print(f" OS: {info.get('os', 'unknown')}")
# Test different DB numbers
for db_num in [0, 1, 2]:
db_client = redis.Redis(
host='183.230.227.10',
port=6379,
password='assitant123',
db=db_num,
socket_connect_timeout=10
)
db_client.ping()
print(f" ✓ DB {db_num} accessible")
client.close()
print("\n✅ Redis connectivity test PASSED\n")
return True
except Exception as e:
print(f"\n✗ Redis connection failed: {e}")
print("❌ Redis connectivity test FAILED\n")
return False
def main():
"""Run all connectivity tests"""
print("\n" + "=" * 60)
print("RAGFlow External Services Connectivity Test")
print("=" * 60 + "\n")
mysql_ok = test_mysql()
redis_ok = test_redis()
print("=" * 60)
print("Summary")
print("=" * 60)
print(f"MySQL: {'✅ PASS' if mysql_ok else '❌ FAIL'}")
print(f"Redis: {'✅ PASS' if redis_ok else '❌ FAIL'}")
if mysql_ok and redis_ok:
print("\n✅ All external services are accessible!")
print("\nRecommendation: You can proceed with unified configuration.")
print("All environments can safely use the same database name and Redis DB.")
return 0
else:
print("\n❌ Some services are not accessible.")
print("Please check network connectivity and credentials before proceeding.")
return 1
if __name__ == "__main__":
sys.exit(main())
#!/usr/bin/env python3
"""
Redis password detection tool
"""
import redis
def test_redis_with_passwords():
"""Try different password combinations"""
host = "183.230.227.10"
port = 6379
passwords = [
None, # No password
"", # Empty string
"123456", # Same as MySQL
"admin123", # Previous attempt
]
print("=" * 60)
print("Testing Redis with different passwords")
print("=" * 60)
print(f"Host: {host}:{port}\n")
for pwd in passwords:
pwd_display = "(no password)" if pwd is None else f"'{pwd}'"
try:
client = redis.Redis(
host=host,
port=port,
password=pwd,
socket_connect_timeout=5,
decode_responses=True
)
response = client.ping()
print(f"✓ Password {pwd_display} works! Response: {response}")
client.close()
return pwd
except redis.exceptions.AuthenticationError as e:
print(f"✗ Password {pwd_display} failed: {e}")
except Exception as e:
print(f"✗ Password {pwd_display} error: {e}")
print("\n❌ None of the tested passwords worked.")
print("\nPlease provide the correct Redis password.")
return None
if __name__ == "__main__":
result = test_redis_with_passwords()
if result is not None:
print(f"\n✅ Redis password is: {result if result else '(empty string)'}")
from fastapi import FastAPI, Request
app = FastAPI()
@app.post("/")
async def echo(request: Request):
body = await request.body()
return body
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)
File mode changed from 100644 to 100755
<!doctype html> <!doctype html>
<html lang="en"> <html lang="zh-CN">
<head> <head>
<meta charset="UTF-8" /> <meta charset="UTF-8" />
<link rel="icon" type="image/svg+xml" href="/logo.svg" /> <link rel="icon" type="image/png" href="/jingyu_logo.png" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>RAGFlow</title> <title>旌渝企业知识库平台</title>
<script src="/iconfont.js" defer></script> <script src="/iconfont.js" defer></script>
</head> </head>
<body> <body>
......
...@@ -50,7 +50,7 @@ export function EmbedContainer({ ...@@ -50,7 +50,7 @@ export function EmbedContainer({
<div className="md:text-xl text-foreground">{title}</div> <div className="md:text-xl text-foreground">{title}</div>
</div> </div>
<div className="flex items-center gap-2 md:ml-auto md:mr-3"> <div className="flex items-center gap-2 md:ml-auto md:mr-3">
<img src="/logo.svg" alt="" className="h-6 md:h-8" /> <img src="/jingyu_logo.png" alt="" className="h-6 md:h-8" />
<span className="hidden md:inline-block text-lg font-bold text-foreground"> <span className="hidden md:inline-block text-lg font-bold text-foreground">
{appConf.appName} {appConf.appName}
</span> </span>
......
...@@ -115,7 +115,7 @@ const MessageItem = ({ ...@@ -115,7 +115,7 @@ const MessageItem = ({
(item.role === MessageType.User ? ( (item.role === MessageType.User ? (
<RAGFlowAvatar <RAGFlowAvatar
className="size-10" className="size-10"
avatar={avatar ?? '/logo.svg'} avatar={avatar ?? '/jingyu_logo.png'}
isPerson isPerson
name={nickname} name={nickname}
/> />
......
...@@ -207,7 +207,7 @@ function MessageItem({ ...@@ -207,7 +207,7 @@ function MessageItem({
{visibleAvatar && {visibleAvatar &&
(item.role === MessageType.User ? ( (item.role === MessageType.User ? (
<RAGFlowAvatar <RAGFlowAvatar
avatar={avatar ?? '/logo.svg'} avatar={avatar ?? '/jingyu_logo.png'}
name={nickname} name={nickname}
isPerson isPerson
/> />
......
import { useId, useMemo, useState } from 'react'; import { useId, useMemo, useState } from 'react';
import { useTranslation } from 'react-i18next';
import { Link, useLocation } from 'react-router'; import { Link, useLocation } from 'react-router';
import { LucideHouse, LucideMenu } from 'lucide-react'; import { LucideHouse, LucideMenu } from 'lucide-react';
...@@ -36,43 +35,36 @@ const MenuItemsIcon = ({ ...@@ -36,43 +35,36 @@ const MenuItemsIcon = ({
}) => <HomeIcon imgClass={className} name={name || 'datasets'} width={20} />; }) => <HomeIcon imgClass={className} name={name || 'datasets'} width={20} />;
const menuItems = [ const menuItems = [
{ path: Routes.Root, name: 'header.home', icon: LucideHouse }, { path: Routes.Root, name: '首页', icon: LucideHouse },
{ {
path: Routes.Datasets, path: Routes.Datasets,
name: 'header.dataset', name: '知识库',
icon: MenuItemsIcon, icon: MenuItemsIcon,
icon_name: 'datasets', icon_name: 'datasets',
}, },
{ {
path: Routes.Chats, path: Routes.Chats,
name: 'header.chat', name: '聊天',
icon: MenuItemsIcon, icon: MenuItemsIcon,
icon_name: 'chats', icon_name: 'chats',
'data-testid': 'nav-chat', 'data-testid': 'nav-chat',
}, },
{
path: Routes.Searches,
name: 'header.search',
icon: MenuItemsIcon,
icon_name: 'searches',
'data-testid': 'nav-search',
},
{ {
path: Routes.Agents, path: Routes.Agents,
name: 'header.flow', name: '智能体',
icon: MenuItemsIcon, icon: MenuItemsIcon,
icon_name: 'agents', icon_name: 'agents',
'data-testid': 'nav-agent', 'data-testid': 'nav-agent',
}, },
{ {
path: Routes.Memories, path: Routes.Memories,
name: 'header.memories', name: '记忆',
icon: MenuItemsIcon, icon: MenuItemsIcon,
icon_name: 'memory', icon_name: 'memory',
}, },
{ {
path: Routes.Files, path: Routes.Files,
name: 'header.fileManager', name: '文件管理',
icon: MenuItemsIcon, icon: MenuItemsIcon,
icon_name: 'file', icon_name: 'file',
}, },
...@@ -93,7 +85,6 @@ function useActivePath() { ...@@ -93,7 +85,6 @@ function useActivePath() {
} }
const DesktopNavbarWithAnchor = () => { const DesktopNavbarWithAnchor = () => {
const { t } = useTranslation();
const activePath = useActivePath(); const activePath = useActivePath();
const navbarAnchorNamePrefix = useId().replace(/:/g, ''); const navbarAnchorNamePrefix = useId().replace(/:/g, '');
...@@ -126,10 +117,10 @@ const DesktopNavbarWithAnchor = () => { ...@@ -126,10 +117,10 @@ const DesktopNavbarWithAnchor = () => {
{path === Routes.Root ? ( {path === Routes.Root ? (
<> <>
<Icon className="size-6 stroke-[1.5]" /> <Icon className="size-6 stroke-[1.5]" />
<span className="sr-only">{t(name)}</span> <span className="sr-only">{name}</span>
</> </>
) : ( ) : (
<span>{t(name)}</span> <span>{name}</span>
)} )}
</Link> </Link>
</li> </li>
...@@ -157,7 +148,6 @@ const DesktopNavbarWithAnchor = () => { ...@@ -157,7 +148,6 @@ const DesktopNavbarWithAnchor = () => {
}; };
const DesktopNavbarFallback = () => { const DesktopNavbarFallback = () => {
const { t } = useTranslation();
const activePath = useActivePath(); const activePath = useActivePath();
return ( return (
...@@ -177,13 +167,13 @@ const DesktopNavbarFallback = () => { ...@@ -177,13 +167,13 @@ const DesktopNavbarFallback = () => {
isActive && isActive &&
'!text-bg-base bg-text-primary border-b-2 border-b-accent-primary', '!text-bg-base bg-text-primary border-b-2 border-b-accent-primary',
)} )}
aria-label={t(name)} aria-label={name}
aria-current={isActive ? 'page' : undefined} aria-current={isActive ? 'page' : undefined}
> >
{path === Routes.Root ? ( {path === Routes.Root ? (
<Icon className="size-6 stroke-[1.5]" /> <Icon className="size-6 stroke-[1.5]" />
) : ( ) : (
<span>{t(name)}</span> <span>{name}</span>
)} )}
</Link> </Link>
</li> </li>
...@@ -242,7 +232,6 @@ type MobileNavbarProps = { ...@@ -242,7 +232,6 @@ type MobileNavbarProps = {
}; };
export function MobileNavbar({ renderFooter }: MobileNavbarProps) { export function MobileNavbar({ renderFooter }: MobileNavbarProps) {
const { t } = useTranslation();
const activePath = useActivePath(); const activePath = useActivePath();
const [open, setOpen] = useState(false); const [open, setOpen] = useState(false);
...@@ -267,7 +256,7 @@ export function MobileNavbar({ renderFooter }: MobileNavbarProps) { ...@@ -267,7 +256,7 @@ export function MobileNavbar({ renderFooter }: MobileNavbarProps) {
className="flex w-[min(85vw,18rem)] flex-col gap-0 p-0 sm:w-72" className="flex w-[min(85vw,18rem)] flex-col gap-0 p-0 sm:w-72"
> >
<div className="flex shrink-0 justify-center py-5"> <div className="flex shrink-0 justify-center py-5">
<img src="/logo.svg" alt="RAGFlow logo" className="size-9" /> <img src="/jingyu_logo.png" alt="RAGFlow logo" className="size-8" />
</div> </div>
<nav className="min-h-0 flex-1 overflow-y-auto py-3"> <nav className="min-h-0 flex-1 overflow-y-auto py-3">
...@@ -277,7 +266,7 @@ export function MobileNavbar({ renderFooter }: MobileNavbarProps) { ...@@ -277,7 +266,7 @@ export function MobileNavbar({ renderFooter }: MobileNavbarProps) {
<MobileNavItem <MobileNavItem
{...props} {...props}
to={path} to={path}
label={t(name)} label={name}
icon={icon} icon={icon}
icon_name={icon_name} icon_name={icon_name}
isActive={path === activePath} isActive={path === activePath}
......
...@@ -80,7 +80,7 @@ export function Header({ ...@@ -80,7 +80,7 @@ export function Header({
aria-current={pathname === Routes.Root ? 'page' : undefined} aria-current={pathname === Routes.Root ? 'page' : undefined}
className="flex size-10 shrink-0 items-center justify-center" className="flex size-10 shrink-0 items-center justify-center"
> >
<img src={'/logo.svg'} alt="RAGFlow logo" className="size-10" /> <img src={'/jingyu_logo.png'} alt="RAGFlow logo" className="size-10" />
</Link> </Link>
</div> </div>
</div> </div>
...@@ -100,77 +100,7 @@ export function Header({ ...@@ -100,77 +100,7 @@ export function Header({
)} )}
data-testid="auth-status" data-testid="auth-status"
> >
{!isCompact && ( {!isCompact && hasNotification && <BellButton className="!size-8" />}
<>
<a
className="inline-flex p-2 text-text-secondary hover:text-text-primary focus-visible:text-text-primary"
target="_blank"
href="https://discord.com/invite/NjYzJD3GM3"
rel="noreferrer noopener"
>
<IconFontFill name="a-DiscordIconSVGVectorIcon" />
</a>
<a
className="inline-flex p-2 text-text-secondary hover:text-text-primary focus-visible:text-text-primary"
target="_blank"
href="https://github.com/infiniflow/ragflow"
rel="noreferrer noopener"
>
<IconFontFill name="GitHub" />
</a>
</>
)}
<DropdownMenu>
<DropdownMenuTrigger asChild>
<Button
variant="ghost"
className={cn(
'size-10 shrink-0 px-0',
!isCompact && 'size-auto gap-1 px-4',
)}
aria-label={currentLanguage?.displayName}
>
{isCompact && <LucideLanguages className="size-5" />}
{!isCompact && (
<>
{currentLanguage?.displayName}
<LucideChevronDown className="size-[1em]" />
</>
)}
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent align="end">
{supportedLanguages.map((x) => (
<DropdownMenuItem
key={x.code}
onClick={() => changeLanguage(x.code)}
>
{x.displayName}
</DropdownMenuItem>
))}
</DropdownMenuContent>
</DropdownMenu>
{!isCompact && (
<>
<Button
asLink
variant="ghost"
size="icon"
className="size-8"
to="https://ragflow.io/docs/dev/category/user-guides"
target="_blank"
rel="noreferrer noopener"
>
<LucideCircleHelp className="size-[1em]" />
</Button>
{hasNotification && <BellButton className="!size-8" />}
</>
)}
<ThemeButton className={cn(!isCompact && '!size-8')} /> <ThemeButton className={cn(!isCompact && '!size-8')} />
......
...@@ -6,6 +6,7 @@ import LanguageDetector from 'i18next-browser-languagedetector'; ...@@ -6,6 +6,7 @@ import LanguageDetector from 'i18next-browser-languagedetector';
import { upperFirst } from 'lodash'; import { upperFirst } from 'lodash';
import { initReactI18next } from 'react-i18next'; import { initReactI18next } from 'react-i18next';
import translation_en from './en'; import translation_en from './en';
import translation_zh from './zh';
//The language is based on the .ng file stored in the client's local storage. //The language is based on the .ng file stored in the client's local storage.
// The language stored in the database is for agent template resources, as these resources reside on the server. // The language stored in the database is for agent template resources, as these resources reside on the server.
...@@ -45,11 +46,11 @@ export const supportedLanguages = supportedLanguageCodes.map((code) => { ...@@ -45,11 +46,11 @@ export const supportedLanguages = supportedLanguageCodes.map((code) => {
}; };
}); });
export const DEFAULT_LANGUAGE_CODE = export const DEFAULT_LANGUAGE_CODE = LanguageAbbreviation.Zh;
import.meta.env.VITE_DEFAULT_LANGUAGE_CODE || LanguageAbbreviation.En;
const resources = { const resources = {
[LanguageAbbreviation.En]: translation_en, [LanguageAbbreviation.En]: translation_en,
[LanguageAbbreviation.Zh]: translation_zh,
}; };
const updateDocumentLocale = (lng: string) => { const updateDocumentLocale = (lng: string) => {
...@@ -60,16 +61,11 @@ const updateDocumentLocale = (lng: string) => { ...@@ -60,16 +61,11 @@ const updateDocumentLocale = (lng: string) => {
i18n i18n
.use(initReactI18next) .use(initReactI18next)
.use(LanguageDetector)
.init({ .init({
detection: { lng: LanguageAbbreviation.Zh,
lookupLocalStorage: 'lng', supportedLngs: [LanguageAbbreviation.Zh],
order: ['localStorage'],
caches: [],
},
supportedLngs: supportedLanguageCodes,
resources, resources,
fallbackLng: DEFAULT_LANGUAGE_CODE, fallbackLng: LanguageAbbreviation.Zh,
interpolation: { interpolation: {
escapeValue: false, escapeValue: false,
}, },
...@@ -121,9 +117,10 @@ export const changeLanguageAsync = async ( ...@@ -121,9 +117,10 @@ export const changeLanguageAsync = async (
}; };
export const initLanguage = async (): Promise<void> => { export const initLanguage = async (): Promise<void> => {
const currentLng = storage.getLanguage() || DEFAULT_LANGUAGE_CODE; const currentLng = LanguageAbbreviation.Zh;
await changeLanguageAsync(currentLng); updateDocumentLocale(currentLng);
await i18n.changeLanguage(currentLng);
}; };
export default i18n; export default i18n;
...@@ -886,6 +886,27 @@ NER:使用 spaCy NER 和基于规则的关键词提取来抽取 Entities 和 R ...@@ -886,6 +886,27 @@ NER:使用 spaCy NER 和基于规则的关键词提取来抽取 Entities 和 R
communityTip: communityTip:
'区块被聚集成层次化的 Community,Entities 和 Relations 通过更高抽象层次将每个部分连接起来。然后,我们使用 LLM 生成每个 Community 的摘要,称为 Community 报告。更多信息:https://www.microsoft.com/en-us/research/blog/graphrag-improving-global-search-via-dynamic-community-selection/', '区块被聚集成层次化的 Community,Entities 和 Relations 通过更高抽象层次将每个部分连接起来。然后,我们使用 LLM 生成每个 Community 的摘要,称为 Community 报告。更多信息:https://www.microsoft.com/en-us/research/blog/graphrag-improving-global-search-via-dynamic-community-selection/',
top: '前n条', top: '前n条',
parserLabel: {
naive: '通用',
general: '通用',
qa: '问答',
resume: '简历',
manual: '手册',
table: '表格',
paper: '论文',
book: '书籍',
laws: '法律',
presentation: '演示文稿',
picture: '图片',
one: '整篇',
audio: '音频',
email: '邮件',
tag: '标签',
},
save: '保存',
me: '只有我',
team: '团队',
cancel: '取消',
}, },
chunk: { chunk: {
chunk: '解析块', chunk: '解析块',
......
...@@ -92,7 +92,7 @@ const AdminNavigationLayout = () => { ...@@ -92,7 +92,7 @@ const AdminNavigationLayout = () => {
<main className="w-screen h-screen flex flex-row px-6 pt-12 pb-6 dark:*:focus-visible:ring-white"> <main className="w-screen h-screen flex flex-row px-6 pt-12 pb-6 dark:*:focus-visible:ring-white">
<aside className="w-72 mr-6 flex flex-col gap-6"> <aside className="w-72 mr-6 flex flex-col gap-6">
<div className="flex items-center mb-6"> <div className="flex items-center mb-6">
<img className="size-8 mr-5" src="/logo.svg" alt="logo" /> <img className="size-8 mr-5" src="/jingyu_logo.png" alt="logo" />
<span className="text-xl font-bold">{t('admin.title')}</span> <span className="text-xl font-bold">{t('admin.title')}</span>
</div> </div>
......
...@@ -136,7 +136,7 @@ function AdminLogin() { ...@@ -136,7 +136,7 @@ function AdminLogin() {
<div className="absolute top-3 left-0 w-full"> <div className="absolute top-3 left-0 w-full">
<div className="absolute mt-12 ml-12 flex items-center"> <div className="absolute mt-12 ml-12 flex items-center">
<img className="size-8 mr-5" src="/logo.svg" alt="logo" /> <img className="size-8 mr-5" src="/jingyu_logo.png" alt="logo" />
<span className="text-xl font-bold">RAGFlow</span> <span className="text-xl font-bold">RAGFlow</span>
</div> </div>
......
import { BuiltinPipelineItem } from '@/components/builtin-pipeline-form-field'; import { BuiltinPipelineItem } from '@/components/builtin-pipeline-form-field';
import { DataFlowSelect } from '@/components/data-pipeline-select';
import { ParseTypeItem } from '@/components/parse-type-form-field';
import { ButtonLoading } from '@/components/ui/button'; import { ButtonLoading } from '@/components/ui/button';
import { import {
Dialog, Dialog,
...@@ -20,13 +18,11 @@ import { ...@@ -20,13 +18,11 @@ import {
} from '@/components/ui/form'; } from '@/components/ui/form';
import { Input } from '@/components/ui/input'; import { Input } from '@/components/ui/input';
import { FormLayout } from '@/constants/form'; import { FormLayout } from '@/constants/form';
import { ParseType } from '@/constants/knowledge';
import { useFetchDefaultModelDictionary } from '@/hooks/use-llm-request'; import { useFetchDefaultModelDictionary } from '@/hooks/use-llm-request';
import { IModalProps } from '@/interfaces/common'; import { IModalProps } from '@/interfaces/common';
import { zodResolver } from '@hookform/resolvers/zod'; import { zodResolver } from '@hookform/resolvers/zod';
import { omit } from 'lodash';
import { useEffect } from 'react'; import { useEffect } from 'react';
import { useForm, useWatch } from 'react-hook-form'; import { useForm } from 'react-hook-form';
import { useTranslation } from 'react-i18next'; import { useTranslation } from 'react-i18next';
import { z } from 'zod'; import { z } from 'zod';
import { import {
...@@ -53,70 +49,44 @@ export function InputForm({ onOk }: IModalProps<any>) { ...@@ -53,70 +49,44 @@ export function InputForm({ onOk }: IModalProps<any>) {
message: t('knowledgeList.namePlaceholder'), message: t('knowledgeList.namePlaceholder'),
}) })
.trim(), .trim(),
parseType: z.nativeEnum(ParseType).optional(),
embedding_model: z embedding_model: z
.string() .string()
.min(1, { .min(1, {
message: t('knowledgeConfiguration.embeddingModelPlaceholder'), message: t('knowledgeConfiguration.embeddingModelPlaceholder'),
}) })
.trim(), .trim(),
// Go registers parser_id, Python registers chunk_method; only the
// active key is set at runtime (see ChunkMethodName).
parser_id: z.string().optional(), parser_id: z.string().optional(),
chunk_method: z.string().optional(), chunk_method: z.string().optional(),
pipeline_id: z.string().optional(),
}) })
.superRefine((data, ctx) => { .superRefine((data, ctx) => {
const chunkMethod = data[ChunkMethodName]; const chunkMethod = data[ChunkMethodName];
// When parseType === BuiltIn, chunk_method is required if (!chunkMethod?.trim()) {
if (data.parseType === ParseType.BuiltIn && !chunkMethod?.trim()) {
ctx.addIssue({ ctx.addIssue({
code: z.ZodIssueCode.custom, code: z.ZodIssueCode.custom,
message: t('knowledgeList.parserRequired'), message: t('knowledgeList.parserRequired'),
path: [ChunkMethodName], path: [ChunkMethodName],
}); });
} }
// When parseType === Pipeline, pipeline_id required
if (data.parseType === ParseType.Pipeline && !data.pipeline_id) {
ctx.addIssue({
code: z.ZodIssueCode.custom,
message: t('knowledgeList.dataFlowRequired'),
path: ['pipeline_id'],
});
}
}); });
const form = useForm<z.infer<typeof FormSchema>>({ const form = useForm<z.infer<typeof FormSchema>>({
resolver: zodResolver(FormSchema), resolver: zodResolver(FormSchema),
defaultValues: { defaultValues: {
name: '', name: '',
parseType: ParseType.BuiltIn,
[ChunkMethodName]: '', [ChunkMethodName]: '',
embedding_model: defaultModelDictionary?.embd_id, embedding_model: defaultModelDictionary?.embd_id,
}, },
}); });
const parseType = useWatch({
control: form.control,
name: 'parseType',
});
function onSubmit(data: z.infer<typeof FormSchema>) { function onSubmit(data: z.infer<typeof FormSchema>) {
const nextData = onOk?.(data);
parseType === ParseType.BuiltIn
? omit(data, ['pipeline_id'])
: omit(data, [ChunkMethodName]);
onOk?.(nextData);
} }
useEffect(() => { useEffect(() => {
if (parseType === ParseType.BuiltIn) {
form.setValue('pipeline_id', '');
}
if (defaultModelDictionary?.embd_id) { if (defaultModelDictionary?.embd_id) {
form.setValue('embedding_model', defaultModelDictionary?.embd_id); form.setValue('embedding_model', defaultModelDictionary?.embd_id);
} }
}, [parseType, form, defaultModelDictionary]); }, [form, defaultModelDictionary]);
return ( return (
<Form {...form}> <Form {...form}>
...@@ -145,21 +115,10 @@ export function InputForm({ onOk }: IModalProps<any>) { ...@@ -145,21 +115,10 @@ export function InputForm({ onOk }: IModalProps<any>) {
/> />
<EmbeddingModelItem line={2} isEdit={false} /> <EmbeddingModelItem line={2} isEdit={false} />
<ParseTypeItem />
{parseType === ParseType.BuiltIn && (
<BackendVariant <BackendVariant
go={<BuiltinPipelineItem name={ChunkMethodName} />} go={<BuiltinPipelineItem name={ChunkMethodName} />}
python={<ChunkMethodItem name={ChunkMethodName}></ChunkMethodItem>} python={<ChunkMethodItem name={ChunkMethodName}></ChunkMethodItem>}
/> />
)}
{parseType === ParseType.Pipeline && (
<DataFlowSelect
isMult={false}
showToDataPipeline={true}
formFieldName="pipeline_id"
layout={FormLayout.Vertical}
/>
)}
</form> </form>
</Form> </Form>
); );
......
...@@ -11,18 +11,15 @@ import { Agents } from './agent-list'; ...@@ -11,18 +11,15 @@ import { Agents } from './agent-list';
import { SeeAllAppCard } from './application-card'; import { SeeAllAppCard } from './application-card';
import { ChatList } from './chat-list'; import { ChatList } from './chat-list';
import { MemoryList } from './memory-list'; import { MemoryList } from './memory-list';
import { SearchList } from './search-list';
const IconMap = { const IconMap = {
[Routes.Chats]: 'chats', [Routes.Chats]: 'chats',
[Routes.Searches]: 'searches',
[Routes.Agents]: 'agents', [Routes.Agents]: 'agents',
[Routes.Memories]: 'memory', [Routes.Memories]: 'memory',
}; };
const EmptyTypeMap = { const EmptyTypeMap = {
[Routes.Chats]: EmptyCardType.Chat, [Routes.Chats]: EmptyCardType.Chat,
[Routes.Searches]: EmptyCardType.Search,
[Routes.Agents]: EmptyCardType.Agent, [Routes.Agents]: EmptyCardType.Agent,
[Routes.Memories]: EmptyCardType.Memory, [Routes.Memories]: EmptyCardType.Memory,
}; };
...@@ -48,7 +45,6 @@ export function Applications() { ...@@ -48,7 +45,6 @@ export function Applications() {
const options = useMemo( const options = useMemo(
() => [ () => [
{ value: Routes.Chats, label: t('header.chat') }, { value: Routes.Chats, label: t('header.chat') },
{ value: Routes.Searches, label: t('header.search') },
{ value: Routes.Agents, label: t('header.flow') }, { value: Routes.Agents, label: t('header.flow') },
{ value: Routes.Memories, label: t('header.memories') }, { value: Routes.Memories, label: t('header.memories') },
], ],
...@@ -97,12 +93,6 @@ export function Applications() { ...@@ -97,12 +93,6 @@ export function Applications() {
setLoading={(loading: boolean) => setLoading(loading)} setLoading={(loading: boolean) => setLoading(loading)}
/> />
)} )}
{val === Routes.Searches && (
<SearchList
setListLength={(length: number) => setListLength(length)}
setLoading={(loading: boolean) => setLoading(loading)}
/>
)}
{val === Routes.Memories && ( {val === Routes.Memories && (
<MemoryList <MemoryList
setListLength={(length: number) => setListLength(length)} setListLength={(length: number) => setListLength(length)}
......
...@@ -40,17 +40,16 @@ export function Banner() { ...@@ -40,17 +40,16 @@ export function Banner() {
} }
export function NextBanner() { export function NextBanner() {
const { t, i18n } = useTranslation();
return ( return (
<h1 <h1
className="text-5xl leading-normal text-left" className="text-5xl leading-normal text-left"
dir={i18n.language?.startsWith('ar') ? 'rtl' : 'ltr'} dir="ltr"
> >
<span className="font-semibold text-text-primary"> <span className="font-semibold text-text-primary">
{t('header.welcome')}{' '} 欢迎来到
</span> </span>
<span className="font-bold text-transparent bg-clip-text bg-gradient-to-l from-[#40EBE3] to-[#4A51FF]"> <span className="font-bold text-transparent bg-clip-text bg-gradient-to-l from-[#40EBE3] to-[#4A51FF]">
RAGFlow 旌渝企业知识库平台
</span> </span>
</h1> </h1>
); );
......
...@@ -380,12 +380,12 @@ const Login = () => { ...@@ -380,12 +380,12 @@ const Login = () => {
<div className="flex items-center mb-4 w-full pl-10 pt-10 "> <div className="flex items-center mb-4 w-full pl-10 pt-10 ">
<div className="w-12 h-12 p-2 rounded-lg flex items-center justify-center mr-3"> <div className="w-12 h-12 p-2 rounded-lg flex items-center justify-center mr-3">
<img <img
src={'/logo.svg'} src={'/jingyu_logo.png'}
alt="logo" alt="logo"
className="size-8 mr-[12] cursor-pointer" className="size-8 mr-[12] cursor-pointer"
/> />
</div> </div>
<div className="text-xl font-bold self-center">RAGFlow</div> <div className="text-xl font-bold self-center">旌渝企业知识库平台</div>
</div> </div>
<h1 className="text-[36px] font-medium text-center mb-2"> <h1 className="text-[36px] font-medium text-center mb-2">
{t('title')} {t('title')}
......
...@@ -47,26 +47,14 @@ export const GenericApiKeyConfig: ProviderConfig = { ...@@ -47,26 +47,14 @@ export const GenericApiKeyConfig: ProviderConfig = {
{ {
name: 'base_url', name: 'base_url',
label: 'baseUrl', label: 'baseUrl',
type: 'inputSelect', type: FormFieldType.Text,
required: false, required: true,
tooltip: (factory) => { defaultValue: 'http://36.212.61.62:18600/v1',
if (factory === LLMFactory.MiniMax) return 'minimaxBaseUrlTip'; tooltip: 'baseUrlTip',
if (factory === LLMFactory.TongYiQianWen) return 'tongyiBaseUrlTip'; placeholder: 'http://36.212.61.62:18600/v1',
if (factory === LLMFactory.SILICONFLOW) return 'siliconBaseUrlTip';
return 'baseUrlTip';
},
placeholder: (factory) => {
if (factory === LLMFactory.MiniMax) return 'minimaxBaseUrlPlaceholder';
if (factory === LLMFactory.TongYiQianWen)
return 'tongyiBaseUrlPlaceholder';
if (factory === LLMFactory.SILICONFLOW)
return 'siliconflowBaseUrlPlaceholder';
if (factory?.toLowerCase() === 'Anthropic')
return 'anthropicBaseUrlPlaceholder';
return 'openaiBaseUrlPlaceholder';
},
shouldRender: 'showBaseUrl', shouldRender: 'showBaseUrl',
autoComplete: 'new-password', autoComplete: 'new-password',
disabled: true,
}, },
{ {
name: 'group_id', name: 'group_id',
......
...@@ -219,7 +219,8 @@ export const useProviderFields = ({ ...@@ -219,7 +219,8 @@ export const useProviderFields = ({
// In viewMode, only the model-related fields are editable. // In viewMode, only the model-related fields are editable.
// All other fields (instance_name, api_key, base_url, etc.) // All other fields (instance_name, api_key, base_url, etc.)
// are rendered as disabled. // are rendered as disabled.
disabled: !!viewMode && !LIST_MODEL_FIELD_NAMES.has(field.name), // base_url is always disabled if field.disabled is true
disabled: field.disabled || (!!viewMode && !LIST_MODEL_FIELD_NAMES.has(field.name)),
dependencies: dependencies:
field.shouldRender === 'modelTypeIncludesChat' || field.shouldRender === 'modelTypeIncludesChat' ||
field.shouldRender === 'modelTypeSupportsToolCall' || field.shouldRender === 'modelTypeSupportsToolCall' ||
......
...@@ -227,15 +227,6 @@ const routeConfigOptions = [ ...@@ -227,15 +227,6 @@ const routeConfigOptions = [
path: Routes.Chats, path: Routes.Chats,
Component: () => import('@/pages/next-chats'), Component: () => import('@/pages/next-chats'),
}, },
{
path: Routes.Searches,
Component: () => import('@/pages/next-searches'),
},
{
path: `${Routes.Search}/:id`,
layout: false,
Component: () => import('@/pages/next-search'),
},
{ {
path: Routes.Agents, path: Routes.Agents,
Component: () => import('@/pages/agents'), Component: () => import('@/pages/agents'),
......
const { fontFamily } = require('tailwindcss/defaultTheme'); import defaultTheme from 'tailwindcss/defaultTheme';
import tailwindcssAnimate from 'tailwindcss-animate';
import tailwindcssLineClamp from '@tailwindcss/line-clamp';
import tailwindScrollbar from 'tailwind-scrollbar';
import tailwindcssContainerQueries from '@tailwindcss/container-queries';
import tailwindcssTypography from '@tailwindcss/typography';
const { fontFamily } = defaultTheme;
/** @type {import('tailwindcss').Config} */ /** @type {import('tailwindcss').Config} */
module.exports = { export default {
darkMode: ['selector'], darkMode: ['selector'],
content: [ content: [
'./src/pages/**/*.tsx', './src/pages/**/*.tsx',
...@@ -209,10 +216,10 @@ module.exports = { ...@@ -209,10 +216,10 @@ module.exports = {
}, },
}, },
plugins: [ plugins: [
require('tailwindcss-animate'), tailwindcssAnimate,
require('@tailwindcss/line-clamp'), tailwindcssLineClamp,
require('tailwind-scrollbar'), tailwindScrollbar,
require('@tailwindcss/container-queries'), tailwindcssContainerQueries,
require('@tailwindcss/typography'), tailwindcssTypography,
], ],
}; };
...@@ -5,6 +5,7 @@ ...@@ -5,6 +5,7 @@
"lib": ["ES2022", "DOM", "DOM.Iterable"], "lib": ["ES2022", "DOM", "DOM.Iterable"],
"module": "ESNext", "module": "ESNext",
"skipLibCheck": true, "skipLibCheck": true,
"ignoreDeprecations": "6.0",
/* Bundler mode */ /* Bundler mode */
"moduleResolution": "bundler", "moduleResolution": "bundler",
......
# RAGFlow 快速启动指南
## 当前状态
### ✅ 已完成
- Docker 服务已恢复运行
- 所有基础服务已启动并健康:
- MySQL (端口 3306)
- Redis/Valkey (端口 6379)
- Elasticsearch (端口 1200)
- MinIO (端口 9000-9001)
- ClickHouse、NATS、Kvrocks
- RAGFlow 后端服务已启动
- Node.js 已升级到 v22.12.0
- 启动脚本已更新,支持自动安装前端依赖
### ⏳ 进行中
- 前端依赖正在安装 (npm install)
---
## 使用启动脚本
### 1. 启动服务
```bash
cd /datacore/ragflow
./scripts/ragflow_service.sh start
```
**功能**:
- 自动检查环境
- 自动安装前端依赖(如果未安装)
- 启动后端服务
- 启动前端服务
- 显示服务状态和访问地址
### 2. 停止服务
```bash
./scripts/ragflow_service.sh stop
```
### 3. 重启服务
```bash
./scripts/ragflow_service.sh restart
```
### 4. 查看状态
```bash
./scripts/ragflow_service.sh status
```
### 5. 查看日志
```bash
# 查看所有日志
./scripts/ragflow_service.sh logs
# 只查看后端日志
./scripts/ragflow_service.sh logs backend
# 只查看前端日志
./scripts/ragflow_service.sh logs frontend
```
---
## 快捷别名(可选)
为了更方便使用,可以添加别名到 ~/.bashrc:
```bash
# 添加别名
cat /datacore/ragflow/ragflow_aliases.sh >> ~/.bashrc
source ~/.bashrc
# 之后可以使用:
ragflow-start # 启动服务
ragflow-stop # 停止服务
ragflow-restart # 重启服务
ragflow-status # 查看状态
ragflow-logs # 查看日志
```
---
## 服务信息
### 后端服务
- **启动脚本**: `docker/launch_backend_service.sh`
- **Python 环境**: conda 环境 `ragflow`
- **日志位置**: `/datacore/ragflow/logs/backend.log`
- **PID 文件**: `/datacore/ragflow/logs/backend.pid`
### 前端服务
- **启动命令**: `npm run dev`
- **访问地址**: http://localhost:8888
- **日志位置**: `/datacore/ragflow/logs/frontend.log`
- **PID 文件**: `/datacore/ragflow/logs/frontend.pid`
### 基础服务
- **MySQL**: localhost:3306
- **Redis**: localhost:6379
- **Elasticsearch**: localhost:1200
- **MinIO**: localhost:9000 (API), localhost:9001 (Console)
---
## 常见问题
### Q1: 前端依赖安装失败?
**A**: 脚本会自动使用正确的 Node.js 版本 (v22.12.0) 进行安装。如果失败,可以手动安装:
```bash
cd /datacore/ragflow/web
/usr/local/bin/npm install
```
### Q2: 后端服务启动失败?
**A**: 检查后端日志:
```bash
tail -f /datacore/ragflow/logs/backend.log
```
常见原因:
- 基础服务未运行
- conda 环境问题
- 缺少依赖库
### Q3: 基础服务未运行?
**A**: 启动 Docker 容器:
```bash
cd /datacore/ragflow
docker compose -f docker/docker-compose-base.yml up -d
# 检查状态
docker compose -f docker/docker-compose-base.yml ps
```
### Q4: 端口被占用?
**A**: 检查端口占用:
```bash
# 检查 8888 端口(前端)
sudo lsof -i :8888
# 检查其他端口
sudo lsof -i :3306 # MySQL
sudo lsof -i :6379 # Redis
```
---
## 等待前端依赖安装完成
当前 npm install 正在后台运行,安装完成后:
1. 执行启动脚本:
```bash
cd /datacore/ragflow
./scripts/ragflow_service.sh start
```
2. 访问前端:
```
http://localhost:8888
```
3. 查看服务状态:
```bash
./scripts/ragflow_service.sh status
```
---
## 脚本更新说明
### 新增功能
1. **自动安装前端依赖**: 检测到 node_modules 不存在时自动执行 `npm install`
2. **智能选择 Node.js 版本**: 优先使用 `/usr/local/bin/node` (v22.12.0)
3. **统一启动管理**: 一个命令同时启动前后端
4. **完善的日志输出**: 清晰的状态信息和错误提示
### 使用的环境
- **Python**: conda 环境 `ragflow` (/datacore/home/admin2/miniconda3/envs/ragflow)
- **Node.js**: v22.12.0 (/usr/local/bin/node)
- **项目路径**: /datacore/ragflow
---
## 下一步
等待 npm install 完成后(大约还需 5-10 分钟),执行:
```bash
cd /datacore/ragflow
./scripts/ragflow_service.sh start
```
脚本会自动:
1. 检查环境
2. 确认基础服务运行
3. 启动后端服务
4. 启动前端服务
5. 显示访问地址
**前端访问地址**: http://localhost:8888
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论