提交 e1d8b55b authored 作者: caifuming's avatar caifuming

下载语音识别文字和文字转语音模型,进行对话识别和回答播报语音

上级 073bfdf2
# 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`
......@@ -27,10 +27,152 @@ from api.utils.model_utils import calculate_model_type
logger = logging.getLogger(__name__)
def _setup_provider_and_instance(tenant_id: str, factory: str, api_key: str, base_url: str = "") -> tuple:
"""
确保 provider 和 instance 存在,返回 (provider_obj, instance_obj)
"""
provider_obj = TenantModelProviderService.get_by_tenant_id_and_provider_name(tenant_id, factory)
if not provider_obj:
TenantModelProviderService.insert(tenant_id=tenant_id, provider_name=factory)
provider_obj = TenantModelProviderService.get_by_tenant_id_and_provider_name(tenant_id, factory)
instance_obj = TenantModelInstanceService.get_by_provider_id_and_api_key(provider_obj.id, api_key)
if not instance_obj:
extra = {"auto_provisioned": True}
if base_url:
extra["base_url"] = base_url
instance_obj = TenantModelInstanceService.create_instance(
provider_id=provider_obj.id,
instance_name="default",
api_key=api_key,
extra=json.dumps(extra),
)
return provider_obj, instance_obj
def _add_model_if_not_exists(provider_id: int, instance_id: int, model_name: str, model_types: list, factory: str) -> dict:
"""
添加模型(如果不存在),返回 {model_types[0]: (model_id, model_name)}
"""
model_type_bin = calculate_model_type(model_types)
existing_model = TenantModelService.get_by_provider_id_and_instance_id_and_model_name(
provider_id, instance_id, model_name
)
if not existing_model:
extra_fields = {
"max_tokens": 8192,
"is_tools": False,
}
TenantModelService.insert(
model_name=model_name,
provider_id=provider_id,
instance_id=instance_id,
model_type=model_type_bin,
extra=json.dumps(extra_fields),
)
existing_model = TenantModelService.get_by_provider_id_and_instance_id_and_model_name(
provider_id, instance_id, model_name
)
result = {}
for mt in model_types:
result[mt] = (existing_model.id, model_name)
return result
def setup_asr_model(tenant_id: str) -> dict:
"""
设置默认 ASR 模型 (Whisper/faster-whisper)
从 service_conf.yaml 的 user_default_llm.default_models.asr_model 配置中读取
"""
try:
llm_default_models = get_base_config("user_default_llm", {}).get("default_models", {})
asr_config = llm_default_models.get("asr_model", {})
if not asr_config:
logger.info("No ASR model configured in service_conf.yaml")
return {"success": True, "message": "No ASR model configured"}
factory = asr_config.get("factory", "FunASR")
model_name = asr_config.get("name", "whisper-base")
api_key = asr_config.get("api_key", "dummy")
base_url = asr_config.get("base_url", "http://localhost:8001/v1")
logger.info(f"Setting up default ASR model: {model_name} (factory: {factory})")
provider_obj, instance_obj = _setup_provider_and_instance(tenant_id, factory, api_key, base_url)
model_ids = _add_model_if_not_exists(
provider_obj.id, instance_obj.id, model_name, ["asr"], factory
)
if "asr" in model_ids:
asr_model_id, asr_model_name = model_ids["asr"]
TenantService.update_by_id(tenant_id, {
"tenant_asr_id": asr_model_id,
"asr_id": asr_model_name
})
logger.info(f"ASR model set: {asr_model_name}")
return {"success": True, "model": model_name}
except Exception as e:
logger.exception(f"Failed to setup ASR model for tenant {tenant_id}: {e}")
return {"success": False, "message": str(e)}
def setup_tts_model(tenant_id: str) -> dict:
"""
设置默认 TTS 模型 (CosyVoice)
从 service_conf.yaml 的 user_default_llm.default_models.tts_model 配置中读取
"""
try:
llm_default_models = get_base_config("user_default_llm", {}).get("default_models", {})
tts_config = llm_default_models.get("tts_model", {})
if not tts_config:
logger.info("No TTS model configured in service_conf.yaml")
return {"success": True, "message": "No TTS model configured"}
factory = tts_config.get("factory", "FishAudio")
model_name = tts_config.get("name", "CosyVoice2-0.5B")
api_key = tts_config.get("api_key", "dummy")
base_url = tts_config.get("base_url", "http://localhost:8090/v1")
logger.info(f"Setting up default TTS model: {model_name} (factory: {factory})")
provider_obj, instance_obj = _setup_provider_and_instance(tenant_id, factory, api_key, base_url)
model_ids = _add_model_if_not_exists(
provider_obj.id, instance_obj.id, model_name, ["tts"], factory
)
if "tts" in model_ids:
tts_model_id, tts_model_name = model_ids["tts"]
TenantService.update_by_id(tenant_id, {
"tenant_tts_id": tts_model_id,
"tts_id": tts_model_name
})
logger.info(f"TTS model set: {tts_model_name}")
return {"success": True, "model": model_name}
except Exception as e:
logger.exception(f"Failed to setup TTS model for tenant {tenant_id}: {e}")
return {"success": False, "message": str(e)}
def setup_default_models_for_tenant(tenant_id: str) -> dict:
"""
为新用户自动配置默认模型和 API Key
从 service_conf.yaml 的 user_default_llm 配置中读取
包括: LLM, Embedding, Rerank, ASR, TTS
"""
try:
# 读取默认配置
......@@ -42,22 +184,8 @@ def setup_default_models_for_tenant(tenant_id: str) -> dict:
logger.warning(f"No default LLM configuration found for tenant {tenant_id}")
return {"success": False, "message": "No default LLM configuration"}
# 确保 provider 存在
provider_obj = TenantModelProviderService.get_by_tenant_id_and_provider_name(tenant_id, factory)
if not provider_obj:
TenantModelProviderService.insert(tenant_id=tenant_id, provider_name=factory)
provider_obj = TenantModelProviderService.get_by_tenant_id_and_provider_name(tenant_id, factory)
# 创建或获取实例
instance_obj = TenantModelInstanceService.get_by_provider_id_and_api_key(provider_obj.id, api_key)
if not instance_obj:
instance_obj = TenantModelInstanceService.create_instance(
provider_id=provider_obj.id,
instance_name="default",
api_key=api_key,
base_url=base_url or "",
extra=json.dumps({"auto_provisioned": True}),
)
# 设置主模型 (LLM/Chat)
provider_obj, instance_obj = _setup_provider_and_instance(tenant_id, factory, api_key, base_url)
# 从 llm_factories.json 读取模型列表
factory_info = None
......@@ -88,62 +216,35 @@ def setup_default_models_for_tenant(tenant_id: str) -> dict:
if not model_types:
continue
model_type_bin = calculate_model_type(model_types)
# 检查模型是否已存在
existing_model = TenantModelService.get_by_provider_id_and_instance_id_and_model_name(
provider_obj.id, instance_obj.id, llm_name
)
if not existing_model:
extra_fields = {
"max_tokens": llm.get("max_tokens", 8192),
"is_tools": llm.get("is_tools", False),
}
TenantModelService.insert(
model_name=llm_name,
provider_id=provider_obj.id,
instance_id=instance_obj.id,
model_type=model_type_bin,
extra=json.dumps(extra_fields),
)
existing_model = TenantModelService.get_by_provider_id_and_instance_id_and_model_name(
provider_obj.id, instance_obj.id, llm_name
)
# 记录模型 ID
if "chat" in model_types:
model_ids["chat"] = (existing_model.id, llm_name)
if "embedding" in model_types:
model_ids["embedding"] = (existing_model.id, llm_name)
if "rerank" in model_types:
model_ids["rerank"] = (existing_model.id, llm_name)
result = _add_model_if_not_exists(provider_obj.id, instance_obj.id, llm_name, model_types, factory)
model_ids.update(result)
# 更新 tenant 的默认模型
from common.config_utils import get_base_config
llm_default_models = get_base_config("user_default_llm", {}).get("default_models", {})
update_dict = {}
if "chat" in model_ids:
chat_model_id, chat_model_name = model_ids["chat"]
update_dict["tenant_llm_id"] = chat_model_id
update_dict["llm_id"] = llm_default_models.get("chat_model", chat_model_name)
update_dict["llm_id"] = llm_default_models.get("chat_model", {}).get("name", chat_model_name)
if "embedding" in model_ids:
embd_model_id, embd_model_name = model_ids["embedding"]
update_dict["tenant_embd_id"] = embd_model_id
update_dict["embd_id"] = llm_default_models.get("embedding_model", embd_model_name)
update_dict["embd_id"] = llm_default_models.get("embedding_model", {}).get("name", embd_model_name)
if "rerank" in model_ids:
rerank_model_id, rerank_model_name = model_ids["rerank"]
update_dict["tenant_rerank_id"] = rerank_model_id
update_dict["rerank_id"] = llm_default_models.get("rerank_model", rerank_model_name)
update_dict["rerank_id"] = llm_default_models.get("rerank_model", {}).get("name", rerank_model_name)
if update_dict:
TenantService.update_by_id(tenant_id, update_dict)
# 设置 ASR 和 TTS 模型
setup_asr_model(tenant_id)
setup_tts_model(tenant_id)
logger.info(f"Successfully set up default models for tenant {tenant_id}")
return {"success": True, "provider": factory, "models": model_ids}
......
......@@ -71,11 +71,22 @@ file_syncer:
max_concurrent_syncs: 5
user_default_llm:
default_models:
embedding_model:
name: 'bge-m3'
factory: 'xxxx'
api_key: 'xxx'
base_url: 'http://localhost:6380'
# ASR model configuration (Whisper via faster-whisper)
# Service: python3 scripts/deploy_whisper_server.py --model base --port 7777 --device cpu
asr_model:
name: 'whisper-base'
factory: 'FunASR'
api_key: 'dummy'
base_url: 'http://localhost:7777/v1'
model: 'Systran/faster-whisper-base'
# TTS model configuration (CosyVoice)
# Service: python3 scripts/deploy_cosyvoice_server.py --gpu 6 --port 7787
tts_model:
name: 'CosyVoice2-0.5B'
factory: 'FishAudio'
api_key: 'dummy'
base_url: 'http://localhost:7787/v1'
voice: 'default'
gcs:
bucket: '${GCS_BUCKET:-ragflow}'
prefix_path: '${GCS_PREFIX_PATH:-}'
......
......@@ -73,12 +73,43 @@ ingestor:
file_syncer:
max_concurrent_syncs: 5
user_default_llm:
# Default LLM factory for new tenants (e.g., BAAI, Tongyi-Qianwen)
factory: 'BAAI'
api_key: 'dummy'
base_url: 'http://localhost:8000/v1'
default_models:
# Chat model configuration
chat_model:
name: 'qwen2.5-7b-instruct'
factory: 'Qwen'
api_key: 'dummy'
base_url: 'http://localhost:8000/v1'
# Embedding model configuration
embedding_model:
name: 'bge-m3'
factory: 'xxxx'
api_key: 'xxx'
factory: 'BAAI'
api_key: 'dummy'
base_url: 'http://localhost:6380'
# Rerank model configuration
rerank_model:
name: 'bge-reranker-v2-m3'
factory: 'BAAI'
# ASR model configuration (Whisper via faster-whisper)
# Service: python3 scripts/deploy_whisper_server.py --model base --port 7777
asr_model:
name: 'whisper-base'
factory: 'FunASR'
api_key: 'dummy'
base_url: 'http://localhost:7777/v1'
model: 'Systran/faster-whisper-base'
# TTS model configuration (CosyVoice)
# Service: python3 scripts/deploy_cosyvoice_server.py --gpu 6 --port 7787
tts_model:
name: 'CosyVoice2-0.5B'
factory: 'FishAudio'
api_key: 'dummy'
base_url: 'http://localhost:7787/v1'
voice: 'default'
gcs:
bucket: '${GCS_BUCKET:-ragflow}'
prefix_path: '${GCS_PREFIX_PATH:-}'
......
# =============================================================================
# Dockerfile for CosyVoice TTS Service
# =============================================================================
# This image provides a CosyVoice based TTS service with OpenAI-compatible API.
# Runs on a specific GPU (configured via CUDA_VISIBLE_DEVICES environment variable).
# =============================================================================
FROM python:3.10-slim
WORKDIR /app
# Install system dependencies
RUN apt-get update && apt-get install -y \
build-essential \
curl \
git \
libsndfile1 \
ffmpeg \
&& rm -rf /var/lib/apt/lists/*
# Install Python dependencies
COPY requirements-cosyvoice.txt /app/
RUN pip install --no-cache-dir -r requirements-cosyvoice.txt
# Copy application code
COPY deploy_cosyvoice_server.py /app/
# Create cache directories
RUN mkdir -p /root/.cache/huggingface \
&& mkdir -p /root/.cache/modelscope \
&& mkdir -p /app/models
# Expose port
EXPOSE 8000
# Environment variables
ENV PYTHONUNBUFFERED=1
ENV MODEL_NAME=CosyVoice2-0.5B
ENV PORT=8000
ENV CUDA_VISIBLE_DEVICES=6
# Run the server
CMD ["python", "-u", "deploy_cosyvoice_server.py", "--gpu", "6", "--port", "7787", "--host", "127.0.0.1"]
# =============================================================================
# Dockerfile for Whisper ASR Service (faster-whisper)
# =============================================================================
# This image provides a faster-whisper based ASR service with OpenAI-compatible API.
# =============================================================================
FROM python:3.10-slim
WORKDIR /app
# Install system dependencies
RUN apt-get update && apt-get install -y \
build-essential \
curl \
git \
&& rm -rf /var/lib/apt/lists/*
# Install Python dependencies
COPY requirements-whisper.txt /app/
RUN pip install --no-cache-dir -r requirements-whisper.txt
# Copy application code
COPY deploy_whisper_server.py /app/
# Create cache directory
RUN mkdir -p /root/.cache/huggingface
# Expose port
EXPOSE 8000
# Environment variables
ENV PYTHONUNBUFFERED=1
ENV MODEL_NAME=Systran/faster-whisper-base
ENV PORT=8000
ENV DEVICE=cuda
ENV COMPUTE_TYPE=float16
# Run the server
CMD ["python", "-u", "deploy_whisper_server.py", "--model", "base", "--port", "7777", "--host", "127.0.0.1"]
# =============================================================================
# RAGFlow ASR/TTS Services Docker Compose
# =============================================================================
# Deploys Whisper (ASR) and CosyVoice (TTS) services with OpenAI-compatible APIs.
#
# Usage:
# docker compose -f docker/docker-compose-asr-tts.yml up -d
#
# Ports:
# - Whisper ASR: 127.0.0.1:7777 (localhost only)
# - CosyVoice TTS: 127.0.0.1:7787 (localhost only)
# =============================================================================
services:
# -------------------------------------------------------------------
# Whisper ASR Service (faster-whisper with OpenAI-compatible API)
# -------------------------------------------------------------------
whisper-asr:
build:
context: .
dockerfile: Dockerfile.whisper
container_name: whisper-asr-service
image: whisper-asr:latest
profiles:
- whisper
ports:
- "127.0.0.1:7777:8000" # Bind to localhost only
environment:
- MODEL_NAME=Systran/faster-whisper-base
- PORT=8000
- DEVICE=cuda
- COMPUTE_TYPE=float16
volumes:
- whisper_cache:/root/.cache/huggingface
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: 1
capabilities: [gpu]
networks:
- ragflow
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
interval: 30s
timeout: 10s
retries: 3
start_period: 60s
restart: unless-stopped
# -------------------------------------------------------------------
# CosyVoice TTS Service (running on GPU 6)
# -------------------------------------------------------------------
cosyvoice-tts:
build:
context: .
dockerfile: Dockerfile.cosyvoice
container_name: cosyvoice-tts-service
image: cosyvoice-tts:latest
profiles:
- cosyvoice
ports:
- "127.0.0.1:7787:8000" # Bind to localhost only
environment:
- MODEL_NAME=CosyVoice2-0.5B
- PORT=8000
- CUDA_VISIBLE_DEVICES=6
volumes:
- cosyvoice_cache:/root/.cache/huggingface
- cosyvoice_models:/app/models
deploy:
resources:
reservations:
devices:
- driver: nvidia
capabilities: [gpu]
# Optionally specify specific GPU
# count: 1
networks:
- ragflow
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
interval: 30s
timeout: 10s
retries: 3
start_period: 120s
restart: unless-stopped
# -------------------------------------------------------------------
# Combined ASR + TTS Service (all-in-one)
# -------------------------------------------------------------------
audio-services:
build:
context: .
dockerfile: Dockerfile.audio
container_name: audio-services
image: audio-services:latest
profiles:
- audio
ports:
- "127.0.0.1:7777:8000" # Whisper ASR - localhost only
- "127.0.0.1:7787:8090" # CosyVoice TTS - localhost only
environment:
- CUDA_VISIBLE_DEVICES=6
volumes:
- whisper_cache:/root/.cache/huggingface
- cosyvoice_cache:/root/.cache/modelscope
- cosyvoice_models:/app/models
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: 1
capabilities: [gpu]
networks:
- ragflow
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
interval: 30s
timeout: 10s
retries: 3
start_period: 120s
restart: unless-stopped
volumes:
whisper_cache:
cosyvoice_cache:
cosyvoice_models:
networks:
ragflow:
name: ragflow
external: true
# Requirements for CosyVoice TTS Service
# Note: CosyVoice may have specific version requirements
# Check https://github.com/modelscope/CosyVoice for latest requirements
torch>=2.0.0
torchaudio>=2.0.0
fastapi>=0.100.0
uvicorn>=0.23.0
pydantic>=2.0.0
numpy>=1.24.0
soundfile>=0.12.0
# CosyVoice specific dependencies (uncomment when available)
# cosyvoice>=0.1.0
# WeChatKernel>=1.0.0
# Requirements for Whisper ASR Service
faster-whisper>=1.0.0
torch>=2.0.0
torchaudio>=2.0.0
fastapi>=0.100.0
uvicorn>=0.23.0
pydantic>=2.0.0
numpy>=1.24.0
soundfile>=0.12.0
# ASR/TTS 服务部署指南
本文档介绍如何在 RAGFlow 中部署和使用本地 Whisper ASR 和 CosyVoice TTS 服务。
## 概述
RAGFlow 支持本地部署语音识别(ASR)和语音合成(TTS)服务,提供更好的隐私保护和性能:
- **ASR (语音识别)**: 使用 faster-whisper 提供 OpenAI 兼容的 API
- **TTS (语音合成)**: 使用 CosyVoice 在指定 GPU 上运行
## 快速开始
### 1. 安装依赖
```bash
# 安装 Python 依赖
pip install faster-whisper torch torchaudio fastapi uvicorn pydantic numpy soundfile
```
### 2. 启动服务
```bash
# 部署 ASR + TTS 服务
bash scripts/deploy_asr_tts.sh --all
# 或者单独启动
bash scripts/deploy_asr_tts.sh --whisper # 仅 ASR
bash scripts/deploy_asr_tts.sh --cosyvoice # 仅 TTS
# 查看状态
bash scripts/deploy_asr_tts.sh --status
# 停止服务
bash scripts/deploy_asr_tts.sh --stop
```
### 3. 服务地址
- **Whisper ASR**: http://localhost:8001
- **CosyVoice TTS**: http://localhost:8090
- **API 文档**: http://localhost:8001/docs 和 http://localhost:8090/docs
## 手动部署
### Whisper ASR
```bash
# 使用 Python 脚本启动
python3 scripts/deploy_whisper_server.py --model base --port 7777
# 可用模型: tiny, base, small, medium, large-v3
python3 scripts/deploy_whisper_server.py --model large-v3 --port 7777
```
### CosyVoice TTS (GPU 6)
```bash
# 在指定 GPU 上启动
python3 scripts/deploy_cosyvoice_server.py --gpu 6 --port 7787
# 使用其他模型
python3 scripts/deploy_cosyvoice_server.py --model CosyVoice2-0.5B-S-Omni --gpu 6 --port 7787
```
## 配置说明
### 后端配置
编辑 `conf/service_conf.yaml` 配置默认模型:
```yaml
user_default_llm:
default_models:
asr_model:
name: 'whisper-base'
factory: 'FunASR'
api_key: 'dummy'
base_url: 'http://localhost:7777/v1'
tts_model:
name: 'CosyVoice2-0.5B'
factory: 'FishAudio'
api_key: 'dummy'
base_url: 'http://localhost:7787/v1'
```
### 前端配置
前端默认隐藏 ASR/TTS 设置项,直接使用后端配置的默认值。
如需显示设置项,修改 `web/src/pages/user-setting/setting-model/layout/system-setting.tsx`:
```tsx
const HIDE_ASR_TTS_SETTINGS = false; // 改为 false 显示设置项
```
## Docker 部署
### 使用 Docker Compose
```bash
# 启动服务
docker compose -f docker/docker-compose-asr-tts.yml up -d
# 查看日志
docker logs -f whisper-asr-service
docker logs -f cosyvoice-tts-service
# 停止服务
docker compose -f docker/docker-compose-asr-tts.yml down
```
### 使用特定 profile
```bash
# 仅启动 Whisper
docker compose -f docker/docker-compose-asr-tts.yml --profile whisper up -d
# 仅启动 CosyVoice
docker compose -f docker/docker-compose-asr-tts.yml --profile cosyvoice up -d
```
## API 使用
### ASR API
```bash
# 语音转文字
curl -X POST http://localhost:7777/v1/audio/transcriptions \
-F file=@audio.wav \
-F model=whisper-base
```
### TTS API
```bash
# 文字转语音
curl -X POST http://localhost:7787/v1/audio/speech \
-H "Content-Type: application/json" \
-d '{
"input": "你好,世界!",
"voice": "default",
"response_format": "mp3"
}' \
--output speech.mp3
```
## 为现有租户设置默认模型
```bash
# 干跑模式(不实际修改)
python3 scripts/setup_default_asr_tts.py --dry-run
# 实际执行
python3 scripts/setup_default_asr_tts.py
```
## GPU 配置
### 指定 GPU 运行
CosyVoice 默认使用 GPU 6。如需更改:
```bash
# 方法1: 环境变量
export CUDA_VISIBLE_DEVICES=0
python3 scripts/deploy_cosyvoice_server.py --gpu 0 --port 7787
# 方法2: 启动参数
python3 scripts/deploy_cosyvoice_server.py --gpu 1 --port 7787
```
### 查看可用 GPU
```bash
nvidia-smi
```
## 故障排除
### 服务启动失败
1. 检查日志文件:
- `/datacore/ragflow/logs/whisper.log`
- `/datacore/ragflow/logs/cosyvoice.log`
2. 验证端口占用:
```bash
lsof -i :8001 # ASR
lsof -i :8090 # TTS
```
3. 检查 CUDA 是否可用:
```bash
python3 -c "import torch; print(torch.cuda.is_available())"
```
### 模型下载失败
手动下载模型:
```bash
# Whisper
python3 -c "from faster_whisper import WhisperModel; WhisperModel('Systran/faster-whisper-base')"
# CosyVoice (需要从 ModelScope 下载)
git lfs install
git clone https://www.modelscope.cn/iic/CosyVoice2-0.5B.git
```
## 性能优化
### Whisper ASR
- 使用更大的模型获得更好的识别效果
- 启用 GPU 加速 (`--device cuda`)
- 使用 float16 计算类型减少内存使用
### CosyVoice TTS
- 确保使用 GPU 加速
- 调整语速参数 (`speed`)
- 使用参考音频获得更好的音色匹配
## 相关文件
- `scripts/deploy_whisper_server.py` - Whisper ASR 服务
- `scripts/deploy_cosyvoice_server.py` - CosyVoice TTS 服务
- `scripts/deploy_asr_tts.sh` - 一键部署脚本
- `scripts/setup_default_asr_tts.py` - 为现有租户设置默认模型
- `conf/service_conf.yaml` - 后端配置
- `docker/docker-compose-asr-tts.yml` - Docker 部署配置
This source diff could not be displayed because it is too large. You can view the blob instead.
# 企业RAG系统改造 - 实施指南(流程版)
## 文档说明
本文档与《企业RAG系统部门权限改造方案.md》配套使用,提供详细的实施流程和操作步骤。本文档专注于**做什么**和**怎么做**,不涉及具体代码。
---
## 第一部分 数据库迁移流程
### 1.1 迁移前准备
#### 1.1.1 备份现有数据
| 备份对象 | 备份方式 | 验证方式 |
|---------|---------|---------|
| MySQL数据库 | mysqldump 全量备份 | 检查备份文件大小 |
| MinIO文件 | mc mirror 同步 | 比对文件数量 |
| Redis数据 | 自动持久化 | 检查 RDB 文件 |
| ES索引 | 快照备份 | 检查快照完整性 |
#### 1.1.2 评估影响范围
- 涉及用户数:全量
- 涉及知识库数:全量
- 涉及文档数:全量
- 预计停机时间:2-4小时
- 回滚所需时间:30分钟
### 1.2 迁移执行步骤
#### 步骤1:创建新表
| 操作 | 表名 | 优先级 |
|-----|------|--------|
| 新建 | department | P0 |
| 新建 | content_hash | P0 |
| 修改 | user_tenant(加字段) | P0 |
| 修改 | knowledgebase(加字段) | P0 |
| 修改 | user(加字段) | P1 |
#### 步骤2:数据回填
| 回填内容 | 默认值 | 后续调整 |
|---------|--------|---------|
| 所有 UserTenant.department_id | 综合部ADMIN | 管理员手动调整 |
| 所有 Knowledgebase.department_id | 综合部ADMIN | 管理员手动调整 |
| 所有 Knowledgebase.is_global_kb | false | 标记总知识库 |
#### 步骤3:业务验证
- 启动应用但不切换权限逻辑
- 验证新表数据完整
- 验证字段添加成功
- 验证现有功能正常
#### 步骤4:双写验证
- 旧逻辑继续运行
- 新逻辑同时记录日志
- 比对两边数据一致性
- 验证通过后切换
### 1.3 迁移回滚方案
**触发条件**:
- 迁移过程出现严重错误
- 数据校验不一致
- 应用启动失败
**回滚步骤**:
1. 停止应用服务
2. 恢复数据库备份
3. 恢复文件存储
4. 回滚应用代码
5. 重启应用
6. 验证功能恢复
---
## 第二部分 后端服务开发流程
### 2.1 部门服务开发
#### 2.1.1 功能清单
| 功能 | 接口 | 权限 | 说明 |
|-----|------|------|------|
| 部门列表 | GET /departments | 登录 | 获取本租户所有部门 |
| 部门详情 | GET /departments/{id} | 登录 | 获取单个部门信息 |
| 创建部门 | POST /departments | tenant_admin | 创建新部门 |
| 更新部门 | PUT /departments/{id} | tenant_admin | 修改部门信息 |
| 删除部门 | DELETE /departments/{id} | tenant_admin | 软删除部门 |
| 部门成员 | GET /departments/{id}/members | dept_admin+ | 查看部门成员 |
| 添加成员 | POST /departments/{id}/members | dept_admin+ | 添加用户到部门 |
| 移除成员 | DELETE /departments/{id}/members/{user_id} | dept_admin+ | 从部门移除用户 |
#### 2.1.2 业务规则
**创建部门规则**:
- 部门代码租户内唯一
- 总知识库部门租户内唯一
- 部门代码只能包含字母数字
- 部门名称长度不超过64字符
**删除部门规则**:
- 不能删除有成员或知识库的部门
- 总知识库部门不能删除
- 删除采用软删除(status=0)
**成员管理规则**:
- 用户必须属于某个部门
- 一个用户同一租户只属于一个部门
- 部门管理员可以管理本部门成员
- 租户管理员可以管理所有部门
#### 2.1.3 默认部门初始化
**触发时机**:
- 租户首次登录
- 数据库无部门记录时自动执行
**默认部门清单**:
| 代码 | 名称 | is_global | 描述 |
|-----|------|-----------|------|
| RD | 研发部 | false | 研发部门 |
| ADMIN | 综合部 | false | 综合管理部门 |
| MARKET | 市场部 | false | 市场部门 |
| DELIVERY | 交付部 | false | 交付部门 |
| GLOBAL | 总知识库 | true | 全局知识库 |
### 2.2 去重服务开发
#### 2.2.1 哈希算法选择
**文件名哈希**:SHA256
- 原因:标准算法、实现简单、安全性高
- 计算时机:上传时计算
**内容哈希**:SHA256
- 原因:与文件名哈希一致、统一处理
- 计算时机:上传时计算
- 注意:大文件需要分块计算
#### 2.2.2 去重检查流程
```
接收文件
↓
读取文件名
↓
计算文件名 SHA256 哈希
↓
读取文件内容到内存(或流式处理)
↓
计算文件内容 SHA256 哈希
↓
查询数据库
├─ 按 tenant_id + filename_hash 查询
├─ 按 tenant_id + content_hash 查询
└─ 取并集
↓
判断是否重复
├─ 无重复 → 继续上传流程
└─ 有重复 → 返回错误信息
├─ 重复类型(文件名/内容)
├─ 已有文档位置
└─ 上传者信息(可选)
```
#### 2.2.3 去重策略
**严格模式**:
- 文件名和内容任一重复即拦截
- 适合:部门内部
**宽松模式**(可选配置):
- 仅内容重复拦截
- 文件名允许重名(自动加序号)
- 适合:跨部门场景
**全局去重**:
- 总知识库内严格去重
- 各部门知识库可独立去重
#### 2.2.4 内容哈希注册时机
| 时机 | 操作 |
|-----|------|
| 文档上传成功 | 注册哈希 |
| 文档删除成功 | 删除哈希 |
| 文档内容更新 | 更新哈希 |
| 总库同步成功 | 注册全局哈希 |
### 2.3 总知识库同步服务开发
#### 2.3.1 同步策略
**触发方式**:异步任务
- 文档上传成功后触发
- 文档更新成功后触发
- 文档删除成功后触发
**任务数据结构**:
- 任务ID
- 租户ID
- 源知识库ID
- 源文档ID
- 同步类型(add/update/delete)
- 重试次数
- 创建时间
#### 2.3.2 同步流程
**添加/更新同步**:
```
接收同步任务
↓
获取源文档信息
↓
查询总知识库部门
↓
查询总知识库KB
↓
检查总库去重
├─ 内容已存在 → 跳过同步
└─ 内容不存在 → 继续
↓
复制文件到总库存储
↓
创建总库Document记录
├─ 关联 kb_id(总库)
├─ 设置 is_global_kb=true
└─ 复用解析结果
↓
注册全局ContentHash
↓
更新任务状态
├─ 成功 → 记录日志
└─ 失败 → 重试队列
```
**删除同步**:
```
接收删除任务
↓
查询源文档的全局哈希
↓
查找总库对应文档
↓
删除总库文档
↓
删除全局ContentHash
↓
更新任务状态
```
#### 2.3.3 失败处理
**重试机制**:
- 最大重试次数:3次
- 重试间隔:指数退避(1分钟、5分钟、15分钟)
- 重试失败后进入死信队列
**降级策略**:
- 同步失败不影响主流程
- 用户上传仍可成功
- 仅总库同步延迟
**监控告警**:
- 同步任务积压超过阈值告警
- 同步失败率超过阈值告警
### 2.4 权限控制开发
#### 2.4.1 装饰器实现
**租户管理员装饰器**:
- 验证:用户角色为 tenant_admin 或 super_admin
- 不满足:返回 403
**部门管理员装饰器**:
- 验证:用户角色为 dept_admin/tenant_admin/super_admin
- 不满足:返回 403
**登录装饰器**(已存在):
- 验证:JWT Token 有效
- 不满足:返回 401
#### 2.4.2 权限检查顺序
```
接口请求进入
↓
登录装饰器(如果存在)
├─ 未登录 → 401
└─ 已登录 → 继续
↓
角色装饰器(如果存在)
├─ 权限不足 → 403
└─ 权限足够 → 继续
↓
业务代码
├─ 资源级权限检查
└─ 数据级权限检查
↓
返回结果
```
#### 2.4.3 关键权限检查点
| 检查点 | 检查内容 | 失败处理 |
|-------|---------|---------|
| 知识库访问 | 用户是否有权访问该KB | 404/403 |
| 文档操作 | 用户是否属于文档所属部门 | 403 |
| 模型配置 | 用户是否为管理员 | 403 |
| 用户管理 | 用户是否为管理员 | 403 |
| 部门管理 | 用户是否为租户管理员 | 403 |
| 文件上传 | 文件是否重复 | 409 |
| 同步操作 | 是否为内部调用 | 403 |
### 2.5 知识库服务改造
#### 2.5.1 列表查询改造
**原逻辑**:基于租户和权限返回所有可见KB
**新逻辑**:根据用户角色过滤
| 用户角色 | 可访问知识库 |
|---------|-------------|
| super_admin | 全部 |
| tenant_admin | 本租户全部 |
| dept_admin | 本部门 + 总知识库 |
| member | 本部门 + 总知识库 |
#### 2.5.2 创建知识库改造
**原逻辑**:用户可自由创建KB
**新逻辑**:
- 仅管理员可创建
- 必须关联部门
- 嵌入模型从预设列表选择(不可自由选择)
#### 2.5.3 详情查询改造
**原逻辑**:直接返回KB详情
**新逻辑**:
- 验证访问权限
- 无权限返回 404 或 403
- 返回数据中增加部门信息
### 2.6 聊天服务改造
#### 2.6.1 知识库选择限制
**前端限制**:
- 仅展示用户可访问的知识库
- 不展示其他部门知识库
**后端校验**:
- 接收请求时再次校验
- 过滤掉无权访问的KB
- 如全部无权返回错误
#### 2.6.2 检索范围限制
**限制范围**:
- 检索仅在用户可访问的KB内执行
- 向量检索附加KB ID过滤条件
- 结果不包含未授权KB的引用
#### 2.6.3 引用展示调整
**展示内容**:
- 文档名
- 知识库名
- 部门名(增加)
- 文档摘要
---
## 第三部分 前端开发流程
### 3.1 用户角色Context开发
#### 3.1.1 Context 结构
**存储内容**:
- 角色信息
- 部门信息
- 权限标识
- 加载状态
**提供方法**:
- 获取当前角色
- 判断是否为管理员
- 判断是否有某权限
- 刷新角色信息
#### 3.1.2 数据获取
**获取时机**:
- 应用启动时
- 用户登录后
- 路由切换时(按需)
**接口调用**:
- 调用用户角色接口
- 缓存到 Context
- 缓存到 localStorage(可选)
#### 3.1.3 权限判断辅助
**辅助方法**:
- hasRole(role): 是否有指定角色
- hasAnyRole(roles): 是否拥有任一角色
- canManageKb(): 是否可管理知识库
- canManageModel(): 是否可配置模型
- canAccessKb(kbId): 是否可访问指定KB
### 3.2 路由守卫开发
#### 3.2.1 路由分类
| 路由类型 | 权限要求 | 处理方式 |
|---------|---------|---------|
| 公开路由 | 登录 | 直接渲染 |
| 部门路由 | 部门成员 | 检查角色 |
| 管理路由 | 管理员 | 检查角色 |
| 超管路由 | super_admin | 检查角色 |
#### 3.2.2 守卫实现
**实现方式**:高阶组件
**检查流程**:
```
进入路由
↓
Context 获取用户角色
├─ 角色未加载 → 显示加载状态
├─ 角色已加载 → 继续
└─ 角色加载失败 → 重定向登录
↓
路由权限要求检查
├─ 满足 → 渲染组件
└─ 不满足 → 重定向或提示
```
#### 3.2.3 重定向策略
**场景1:未登录访问受保护路由**
- 重定向到登录页
**场景2:登录但权限不足**
- 重定向到首页
- 提示无权限
**场景3:登录但角色加载中**
- 显示加载状态
- 等待加载完成
### 3.3 导航栏改造
#### 3.3.1 菜单数据调整
**菜单项配置**:
- 路径
- 名称(i18n key)
- 图标
- 权限要求
- 是否显示
**菜单渲染逻辑**:
- 遍历菜单配置
- 检查权限
- 满足则渲染
#### 3.3.2 各角色菜单对比
| 菜单 | super_admin | tenant_admin | dept_admin | member |
|-----|-------------|--------------|------------|--------|
| 首页 | ✓ | ✓ | ✓ | ✓ |
| 知识库 | ✓ | ✓ | ✓ | ✗ |
| 聊天 | ✓ | ✓ | ✓ | ✓ |
| 搜索 | ✓ | ✓ | ✓ | ✓ |
| Agent | ✓ | ✓ | ✓ | ✓ |
| 文件 | ✓ | ✓ | ✓ | ✗ |
| 系统设置 | ✓ | ✓ | ✗ | ✗ |
| 用户管理 | ✓ | ✓ | ✗ | ✗ |
| 部门管理 | ✓ | ✓ | ✗ | ✗ |
| 模型设置 | ✓ | ✓ | ✗ | ✗ |
### 3.4 知识库页面改造
#### 3.4.1 列表页面改造
**改造点**:
- 创建按钮权限控制
- 操作按钮权限控制
- 部门信息展示
- 空状态文案调整
#### 3.4.2 创建对话框改造
**新增内容**:
- 部门选择下拉框
- 部门选项动态加载
- 部门验证逻辑
**部门选择规则**:
- 仅显示4个普通部门
- 不显示总知识库
- 必填项
#### 3.4.3 详情页面改造
**改造点**:
- 顶部展示所属部门
- 操作按钮权限控制
- 设置菜单权限控制
- 文档列表展示部门
### 3.5 聊天页面改造
#### 3.5.1 知识库选择器改造
**改造点**:
- 只显示可访问的知识库
- 增加部门分组展示
- 总知识库特殊标识
#### 3.5.2 引用展示改造
**改造点**:
- 显示文档所属部门
- 显示知识库所属部门
- 帮助用户理解引用来源
### 3.6 模型设置页面改造
#### 3.6.1 只读模式实现
**实现方式**:
- 根据角色设置 readOnly prop
- 禁用所有编辑控件
- hover显示提示
**UI 调整**:
- 输入框变灰
- 按钮禁用
- 提示横幅
#### 3.6.2 提示信息设计
**提示内容**:
- 顶部横幅说明
- hover tooltip
- 权限说明文案
### 3.7 用户/部门管理页面
#### 3.7.1 用户列表改造
**改造点**:
- 展示用户所属部门
- 部门筛选
- 调岗功能
#### 3.7.2 部门列表页面
**功能清单**:
- 部门列表展示
- 创建部门
- 编辑部门
- 删除部门
- 部门成员管理
---
## 第四部分 测试执行流程
### 4.1 测试准备
#### 4.1.1 测试环境搭建
| 环境 | 用途 | 配置 |
|-----|------|------|
| 单元测试环境 | 单元测试 | Mock 依赖 |
| 集成测试环境 | 集成测试 | 完整服务 |
| 性能测试环境 | 性能测试 | 类生产配置 |
| 预生产环境 | 系统测试 | 生产配置 |
#### 4.1.2 测试数据准备
**测试租户**:3个
- 租户A:完整数据
- 租户B:部分数据
- 租户C:空租户(用于初始化测试)
**测试用户**:
- 超管:1个
- 租管:3个(每租户1个)
- 部门管理员:8个
- 普通成员:50个
**测试文档**:
- 各类型文档100份
- 含重复内容的测试集
- 大文件测试集
### 4.2 功能测试执行
#### 4.2.1 部门管理测试
| 用例 | 输入 | 预期 | 优先级 |
|-----|------|------|--------|
| 创建研发部 | 名称+代码 | 创建成功 | P0 |
| 创建重复代码 | 已存在代码 | 失败提示 | P0 |
| 删除有成员部门 | 含成员部门 | 失败提示 | P0 |
| 删除总知识库 | 全局部门 | 失败提示 | P0 |
| 编辑部门信息 | 新信息 | 更新成功 | P0 |
| 列表查询 | 租户ID | 返回5部门 | P0 |
#### 4.2.2 权限测试
| 用例 | 操作 | 预期 | 优先级 |
|-----|------|------|--------|
| 普通成员访问管理页 | URL访问 | 重定向首页 | P0 |
| 普通成员调用管理API | API调用 | 403 | P0 |
| 跨部门访问KB | 尝试访问 | 404/403 | P0 |
| 部门管理员访问管理 | URL访问 | 正常 | P0 |
| 租户管理员全权限 | 多操作 | 全部成功 | P0 |
#### 4.2.3 去重测试
| 用例 | 操作 | 预期 | 优先级 |
|-----|------|------|--------|
| 上传新文件 | 新内容 | 成功 | P0 |
| 上传同名文件 | 同名内容 | 拒绝 | P0 |
| 上传同内容 | 同内容不同名 | 拒绝 | P0 |
| 跨部门上传 | 不同部门同文件 | 允许 | P0 |
| 总库去重 | 跨部门同内容 | 总库只一份 | P0 |
| 更新文档 | 修改内容 | 允许 | P0 |
#### 4.2.4 同步测试
| 用例 | 操作 | 预期 | 优先级 |
|-----|------|------|--------|
| 上传触发同步 | 新文档 | 总库同步成功 | P0 |
| 删除触发同步 | 删除文档 | 总库删除 | P0 |
| 同步失败重试 | 模拟失败 | 重试3次 | P0 |
| 大量同步 | 批量上传 | 队列正常 | P1 |
### 4.3 性能测试
#### 4.3.1 测试场景
**场景1:并发用户**
- 100用户同时操作
- 监控响应时间
**场景2:大量文档**
- 10000文档检索
- 监控检索时间
**场景3:大文件上传**
- 100MB文件上传
- 监控上传时间
**场景4:同步积压**
- 短时间内1000上传
- 监控同步处理时间
#### 4.3.2 性能指标
| 指标 | 目标 | 警告阈值 |
|-----|------|---------|
| API响应时间 | < 500ms | > 1s |
| 上传响应时间 | < 3s | > 5s |
| 检索响应时间 | < 1s | > 2s |
| 同步处理时间 | < 30s | > 60s |
| 并发用户 | 100 | > 80 |
### 4.4 安全测试
#### 4.4.1 越权测试
| 类型 | 测试方法 |
|-----|---------|
| 垂直越权 | 低权限用户尝试访问高权限接口 |
| 水平越权 | 用户A尝试访问用户B数据 |
| URL越权 | 猜测URL访问他人资源 |
| Token越权 | 使用他人Token |
#### 4.4.2 注入测试
| 类型 | 测试方法 |
|-----|---------|
| SQL注入 | 输入特殊SQL字符 |
| XSS | 输入脚本代码 |
| CSRF | 伪造跨站请求 |
| 命令注入 | 输入系统命令 |
---
## 第五部分 部署上线流程
### 5.1 上线准备
#### 5.1.1 文档清单
- [ ] 用户手册
- [ ] 管理员手册
- [ ] 运维手册
- [ ] API文档
- [ ] 数据库文档
- [ ] 故障处理手册
#### 5.1.2 检查清单
**代码检查**:
- [ ] 代码Review完成
- [ ] 单元测试通过
- [ ] 集成测试通过
- [ ] 安全扫描通过
- [ ] 性能测试通过
**部署检查**:
- [ ] 数据库迁移脚本准备
- [ ] 配置文件准备
- [ ] 监控配置完成
- [ ] 告警规则设置
- [ ] 备份策略确认
#### 5.1.3 人员安排
| 角色 | 职责 | 时间安排 |
|-----|------|---------|
| DBA | 数据库迁移 | 上线日 |
| 后端开发 | 服务部署 | 上线日 |
| 前端开发 | 前端发布 | 上线日 |
| 测试 | 验证测试 | 上线日+1 |
| 运维 | 监控保障 | 持续 |
### 5.2 上线执行
#### 5.2.1 灰度发布步骤
**阶段1:内部灰度(1周)**
- 部署到内部测试环境
- 内部用户验证
- 修复发现的问题
**阶段2:试点租户(2周)**
- 选择1个非关键租户
- 真实数据验证
- 收集用户反馈
**阶段3:扩大灰度(2周)**
- 选择5个租户
- 不同行业租户
- 验证普适性
**阶段4:全量上线**
- 所有租户切换
- 监控稳定性
- 应急响应
#### 5.2.2 数据迁移执行
**时间窗口**:选择业务低峰期(如周末凌晨)
**执行步骤**:
1. 通知用户系统维护
2. 停止应用服务
3. 执行数据库备份
4. 执行数据迁移
5. 启动应用服务
6. 验证功能正常
7. 通知用户恢复
### 5.3 上线验证
#### 5.3.1 功能验证
- [ ] 用户登录正常
- [ ] 部门管理正常
- [ ] 知识库CRUD正常
- [ ] 文件上传正常
- [ ] 去重功能正常
- [ ] 总库同步正常
- [ ] 聊天功能正常
- [ ] 权限控制正常
#### 5.3.2 性能验证
- [ ] 页面响应时间
- [ ] API响应时间
- [ ] 上传响应时间
- [ ] 检索响应时间
- [ ] 并发用户支持
#### 5.3.3 安全验证
- [ ] 权限控制有效
- [ ] 越权防护有效
- [ ] 数据加密正常
- [ ] 审计日志正常
---
## 第六部分 运维保障流程
### 6.1 日常巡检
#### 6.1.1 每日巡检
| 时间 | 内容 |
|-----|------|
| 上午 | 检查服务状态、监控告警 |
| 中午 | 检查任务队列、日志异常 |
| 下午 | 检查性能指标、容量使用 |
| 晚上 | 检查备份完成、明日准备 |
#### 6.1.2 每周巡检
- 数据库性能分析
- 索引使用情况
- 慢查询分析
- 容量增长趋势
#### 6.1.3 每月巡检
- 安全日志审计
- 权限变更审计
- 系统容量规划
- 备份恢复演练
### 6.2 故障处理流程
#### 6.2.1 故障分级
| 级别 | 影响 | 响应时间 | 处理时长 |
|-----|------|---------|---------|
| P0 | 全站不可用 | 5分钟 | 2小时 |
| P1 | 核心功能不可用 | 15分钟 | 4小时 |
| P2 | 部分功能异常 | 1小时 | 8小时 |
| P3 | 体验问题 | 4小时 | 24小时 |
#### 6.2.2 故障响应流程
```
故障发现
↓
故障定级
↓
启动应急预案
├─ P0/P1:立即通知负责人
└─ P2/P3:记录并排期处理
↓
故障定位
├─ 查看监控
├─ 查看日志
└─ 缩小范围
↓
故障恢复
├─ 应用故障:重启服务
├─ 数据库故障:切换主从
└─ 存储故障:切换备份
↓
故障总结
├─ 编写故障报告
├─ 分析根因
└─ 制定改进措施
```
### 6.3 数据管理流程
#### 6.3.1 用户调岗
**场景**:用户从一个部门调到另一个部门
**操作步骤**:
1. 管理员发起调岗申请
2. 选择目标部门
3. 系统处理:
- 更新 UserTenant.department_id
- 失去原部门知识库访问权限
- 获得新部门知识库访问权限
- 保留聊天历史
4. 通知用户
5. 用户重新登录生效
#### 6.3.2 部门重组
**场景**:拆分或合并部门
**操作步骤**:
1. 管理员制定重组方案
2. 创建新部门(如需)
3. 批量调整用户部门归属
4. 批量调整知识库归属
5. 验证数据完整性
6. 通知相关用户
#### 6.3.3 离职处理
**场景**:员工离职
**操作步骤**:
1. 管理员禁用账号
2. 保留数据所有权
3. 转移重要数据给接手人
4. 删除个人敏感数据
5. 归档聊天记录
---
## 第七部分 应急处理预案
### 7.1 系统不可用预案
**触发条件**:
- API完全无法访问
- 数据库连接失败
- 关键服务进程崩溃
**应急步骤**:
1. 启动备用实例
2. 切换负载均衡
3. 通知用户
4. 排查故障原因
5. 修复主实例
6. 切换回主实例
### 7.2 数据损坏预案
**触发条件**:
- 数据库表损坏
- 文件丢失
- 索引异常
**应急步骤**:
1. 停止写入操作
2. 评估损坏范围
3. 从备份恢复
4. 验证数据一致性
5. 恢复服务
6. 分析损坏原因
### 7.3 安全事件预案
**触发条件**:
- 检测到异常访问
- 权限提升尝试
- 数据泄露迹象
**应急步骤**:
1. 锁定受影响账号
2. 审计日志分析
3. 修改相关凭证
4. 通知相关方
5. 修复安全漏洞
6. 复盘改进
---
## 附录:检查清单汇总
### A.1 开发完成检查清单
- [ ] 数据库迁移脚本开发完成
- [ ] 部门服务开发完成
- [ ] 去重服务开发完成
- [ ] 同步服务开发完成
- [ ] 权限装饰器开发完成
- [ ] 知识库API改造完成
- [ ] 聊天API改造完成
- [ ] 用户Context开发完成
- [ ] 路由守卫开发完成
- [ ] 导航栏改造完成
- [ ] 知识库页面改造完成
- [ ] 聊天页面改造完成
- [ ] 模型设置改造完成
- [ ] 用户管理改造完成
- [ ] 部门管理页面开发完成
### A.2 测试完成检查清单
- [ ] 单元测试覆盖率 > 80%
- [ ] 集成测试用例全部通过
- [ ] 系统测试用例全部通过
- [ ] 性能测试指标达标
- [ ] 安全测试无高危漏洞
- [ ] 兼容性测试通过
### A.3 上线就绪检查清单
- [ ] 所有文档编写完成
- [ ] 部署方案确认
- [ ] 监控告警配置完成
- [ ] 备份恢复方案确认
- [ ] 应急预案准备
- [ ] 运维培训完成
- [ ] 用户通知准备
- [ ] 回滚方案确认
---
**文档结束**
# 旌渝知识库平台 — 角色体系规划(部门领导 / 成员 / 管理员)
> 目标:在现有 RAGFlow 基础上落地企业级 RBAC(基于角色的访问控制),支持「管理员 / 部门领导 / 成员」三级模型,并实现「部门领导需管理员审批」的合规流程。本文只给落地方案,不写代码。
---
## 1. 现状摸底(基于当前代码的事实)
下面这些事实来自仓库的实际代码,是后续设计的基础,不能凭空假设。
### 1.1 现存数据模型
- `user` 表:`id / email / nickname / password / access_token / is_superuser / is_active / status` 等。
- `tenant` 表:`id / name / llm_id / embd_id / asr_id / parser_ids / credit / status`。**当前 `tenant.id == user.id`**,即每个用户自带一个「个人王国」式的租户,没有真正的「组织 / 部门」实体。
- `user_tenant` 表:`user_id / tenant_id / role (owner/admin/normal/invite) / invited_by / status`。这是把多个用户挂到同一个租户下的连接表,目前只用于团队邀请流程。
- `knowledgebase` 表:`tenant_id / created_by / permission (me/team)`。**数据集挂在租户上,租户目前 = 用户自己**。
- 系统已有「角色 + 资源 + 权限」RBAC 框架的表(`role` / `resource` / `role_permission` / `user_role`),**前端已实现管理界面**(`pages/admin/roles.tsx`、`pages/admin/users.tsx`),但 **Go 侧对应的服务方法都是 stub(占位)**——所以这套 RBAC 在当前构建里「能配但不通」,不能直接拿来当业务权限闸门。
### 1.2 现有注册与登录链路
- 注册接口:`POST /users`(`api/apps/restful_apis/user_api.py`),流程是「校验邮箱 → 创建 `User` → 创建 `Tenant`(`tenant.id = user.id`,`'xxx 的王国'`)→ 创建 `UserTenant`(role=`OWNER`,自邀请自己)→ 创建根 `File` → 自动登录」。
- 校验开关:`settings.REGISTER_ENABLED`(环境变量 `REGISTER_ENABLED`)+ 前端的「注册开关」是从 `system_api` 拿到的 `registerEnabled` 字段。
- 当前没有「注册角色选择」,也没有「注册后等待审批」的状态机。
### 1.3 现有团队流程(必须复用,不要重造)
- 邀请:`POST /tenants/<tenant_id>/users`,body 只需要 `email`。`tenant_id` 必须等于当前用户 id(鉴权检查),创建一个 `role=invite` 的 `UserTenant` 行,发一封邀请邮件。
- 加入:`PATCH /tenants/<tenant_id>`,被邀请者登录后调用,把 `role` 从 `invite` 提升到 `normal`。
- 移除:`DELETE /tenants/<tenant_id>/users`。
- 列出成员:`GET /tenants/<tenant_id>/users`。
### 1.4 现有管理员
- 管理员标志:`user.is_superuser = 1`(布尔型,且建有索引)。
- 启动初始化:`api/db/init_data.py` 的 `init_superuser()`,通过环境变量 `DEFAULT_SUPERUSER_NICKNAME / EMAIL / PASSWORD` 创建。**当前默认是 `admin@ragflow.io / admin`**,与新需求里的 `admin@123.com / admin / jingyu123` 不一致。
- 管理员界面入口:`web/src/pages/admin/*`,已有「用户管理 / 角色管理 / 白名单 / 服务监控」等。
### 1.5 现有数据集权限模型
- `dataset_api.py` 里的所有接口都按 `tenant_id` 隔离,`tenant_id` 默认 = 当前用户 id。
- `KnowledgebaseService.accessible(dataset_id, tenant_id)` 是核心闸门:要么 `kb.tenant_id == tenant_id`(自己创建的),要么 `kb.permission == "team"` 且当前用户在该 `tenant` 下有 `user_tenant.role ∈ {owner, admin, normal}`。
- **这意味着:只要把 `user_tenant.role` 控制好,就能让「成员」在没被加入任何团队前看不到任何知识库。**
### 1.6 现存问题(必须承认的现实)
1. RBAC 框架前端能用、后端不通,**不能直接用于业务判断**,要么把 Go 侧补完、要么退一步在 Python 侧做硬编码判断,**两者选一**(见 §6 决策项)。
2. `tenant` 现在是「个人王国」语义,和「组织 / 部门」概念冲突,引入「部门领导 / 成员」必须把这两层分开。
3. 没有「待审批 / 已拒绝」的状态机,所有用户注册即生效——这是合规上的重大缺口。
4. 注册即自动给一个默认租户 + 默认 LLM/embedding 模型 + 自动建根目录文件夹,**会带来「成员」一进来就有自己的「个人知识库」**——这与「成员不能建知识库」冲突,需要拆开「个人空间」与「组织空间」。
---
## 2. 总体设计目标
| 维度 | 目标 |
| ---------- | ------------------------------------------------------------------------ |
| 角色清晰 | 三层角色,权限边界不重叠、不漏 |
| 默认安全 | 最小权限,新注册用户默认无任何业务权限 |
| 合规可审 | 部门领导注册必须有审批痕迹,过程可回溯、可追责 |
| 体验连贯 | 注册 / 审批 / 加入团队的链路对终端用户来说最多 3 步 |
| 与现有融合 | 不另起一套租户体系,复用`tenant` + `user_tenant`,新增「组织」实体层 |
| 可扩展 | 未来支持多部门 / 多级审批 / SSO / SCIM(企业身份协议)时不需要重写 |
---
## 3. 角色定义(业务语义,不写代码)
### 3.1 三层角色总览
| 角色 | 关键能力 | 关键限制 |
| --------------------------------------- | -------------------------------------------------------------------------- | -------------------------------------- |
| **管理员(admin)** | 全平台最高权限:审批 / 封禁 / 角色 / 模型 / 服务监控 | 只读业务数据;不参与业务租户 |
| **部门领导(department_leader)** | 在所属部门内:建 / 改 / 删知识库、邀请成员、移除成员、审批成员加入 | 不能管理其他部门;不能创建平台级角色 |
| **成员(member)** | 仅能查看自己被加入的部门的知识库、对话 / 检索 / 上传文档(取决于部门授权) | 不能创建知识库、不能邀请人、不能加团队 |
### 3.2 「部门」是什么
部门 = **组织(organization)**,是独立于 `tenant` 的新实体。一个组织下挂一个或多个「子工作区」(即原有意义上的 `tenant`,但语义收紧为「工作区」)。先做单层,不要一开始就做多级树,避免过度设计。
### 3.3 「部门领导」对应的特殊身份
「部门领导」不是一个全局角色,而是 **「组织成员 + 在该组织内的身份为 leader」**。也就是说:
- 全局层面用户是 `member` 身份(默认身份)
- 在某个具体组织内可以是 `leader` / `member` 两种身份之一
- 一个用户可以同时是 A 组织的 leader、B 组织的 member
这样比「全局 leader / 全局 member」更符合实际企业组织结构,未来支持多部门不痛。
---
## 4. 数据模型改造(数据库怎么改)
> 命名沿用项目原有 snake_case + Peewee 风格,迁移用项目既有的 `playhouse.migrate` + `migrate_db()` 机制,不要引入 Alembic 等新依赖。
### 4.1 现有表扩展
#### `user` 表加字段
| 字段 | 类型 | 说明 |
| ------------------- | --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `user_type` | `CharField(max_length=32)` | 枚举:`admin` / `department_leader` / `member`(**只在全平台层面标识「是不是部门领导级用户」**,用于快速判断能否被邀请成 leader;真正的部门归属见 §4.2) |
| `approval_status` | `CharField(max_length=16)` | 枚举:`approved` / `pending` / `rejected`,默认 `approved`(保持老用户不受影响) |
| `approved_by` | `CharField(max_length=32, null=True)` | 审批人 user_id |
| `approved_at` | `BigIntegerField(null=True)` | 审批时间戳 |
| `rejected_reason` | `TextField(null=True)` | 拒绝理由 |
> 这里一定要区分清楚:**「用户类型」只是平台级标签,**「能在哪个组织当领导」由 §4.2 的 `organization_member.role` 控制。注册时先设 `user_type`、写审批记录;管理员批准后再激活 `user_type='department_leader'`。这样审批未通过时用户就是一个普通成员。
#### `tenant` 表加字段
| 字段 | 类型 | 说明 |
| ------------------ | --------------------------------------------------- | ---------------------------------------------------------------------------------------- |
| `org_id` | `CharField(max_length=32, null=True, index=True)` | 关联到`organization.id`。**NULL 表示「个人工作区」**,非 NULL 表示「组织工作区」 |
| `workspace_type` | `CharField(max_length=16)` | `personal` / `org`,默认 `personal` |
> 关键决策:**不破坏现有 `tenant.id == user.id` 的现状**——所有现有数据天然视为「个人工作区」。新增的「组织工作区」由部门领导创建(详见 §5)。
#### `knowledgebase` 表加字段
| 字段 | 类型 | 说明 |
| ---------- | --------------------------------------------------- | --------------------------------- |
| `org_id` | `CharField(max_length=32, null=True, index=True)` | 知识库归属组织;个人知识库为 NULL |
> 个人知识库 vs 组织知识库的判断迁移到老接口:`kb.org_id IS NULL → 个人,`IS NOT NULL` → 组织。
### 4.2 新增表
#### `organization`(组织 / 部门)
```
organization
id PK (uuid, 32)
name string(128) NOT NULL, indexed
description text NULL
owner_user_id FK -> user.id (创建者, 必须是已审批的部门领导)
status char(1) (0=停用, 1=启用)
created_at bigint
updated_at bigint
```
加索引:`(status, name)`,方便后台列表查询。
#### `organization_member`(组织成员关系)
```
organization_member
id PK
org_id FK -> organization.id, indexed
user_id FK -> user.id, indexed
role char(16) (leader / member)
status char(1) (0=已离开, 1=在组织内)
invited_by FK -> user.id
joined_at bigint
UNIQUE (org_id, user_id) WHERE status=1 (MySQL 用普通唯一键 + 应用层过滤软删除)
```
> 不要直接复刻 `user_tenant`,原因有三:(a) 字段语义不同(这里有 leader/member,不是 owner/admin/normal/invite);(b) `user_tenant` 未来还要承担「个人工作区」关系(用户和其个人 tenant 的 owner 关系),混在一起后期改不动;(c) 数据生命周期不同:组织关系会更复杂(邀请 / 审批 / 转让)。
#### `user_approval_log`(用户审批流水)
```
user_approval_log
id PK
user_id FK -> user.id, indexed
action char(16) (register_leader / promote_leader / demote / ban / unban)
requested_role char(32) (申请的角色:department_leader / ...)
decision char(16) (approved / rejected)
reviewer_id FK -> user.id NULL
reason text NULL
created_at bigint, indexed
```
> **这是审计的根**,合规场景里「谁批了谁」必须能查出来。不要只写日志文件,一定要落库。
### 4.3 枚举集中管理(强烈建议)
在 `api/db/__init__.py` 里已经有的 `StrEnum` 风格下新增:
- `UserType`:`ADMIN / DEPARTMENT_LEADER / MEMBER`
- `ApprovalStatus`:`APPROVED / PENDING / REJECTED`
- `OrgMemberRole`:`LEADER / MEMBER`
- `WorkspaceType`:`PERSONAL / ORG`
不要把字符串散在各处。**禁止重复定义**、禁止用数字枚举代替(数据库可读性灾难)。
### 4.4 迁移(migration)策略
1. 用 `playhouse.migrate` 的 `add_column` 为已有表加列,所有新增列必须 `NULL=True`,默认值不要写死(避免影响存量数据)。
2. 写脚本一次性回填:所有存量 `user.is_superuser = 1` 的,`user_type = 'admin', approval_status = 'approved', approved_by = NULL, approved_at = create_time`;其余用户 `user_type = 'member', approval_status = 'approved'`。**回填完才允许上线注册新流程**,否则新注册逻辑和旧数据不一致。
3. 新表在 `db_models.py` 加 `class Meta: db_table = '...'` 后,由现有的 `init_database_tables()` 自动建表——**沿用项目既有的「表不存在就建」模式**,不要破坏流程。
4. GaussDB 兼容性已经在 `db_models.py` 里通过 `EmptyStringCharField` / `RetryingPooledGaussDBDatabase` 处理,**新增字段必须保留这套语义**,尤其 `org_id / approved_by / rejected_reason` 这类带「空字符串 vs NULL」语义的列。
---
## 5. 业务流程改造(流程怎么改)
### 5.1 注册流程
旧:
```
POST /users → 创建 user + tenant(用户自己) + user_tenant(OWNER) + file(/),自动登录
```
新:
```
POST /users/register
body: { nickname, email, password, role_type: 'member' | 'department_leader' }
分支 1: role_type = member
→ 创建 user (user_type='member', approval_status='approved', approved_by=system, approved_at=now)
→ 创建 tenant (workspace_type='personal', org_id=NULL)
→ 创建 user_tenant (role=OWNER, tenant_id=user.id)
→ 创建 file (根目录)
→ 返回成功,前端跳转登录页
分支 2: role_type = department_leader
→ 创建 user (user_type='member', approval_status='pending') ← 注意:先以 member 身份进系统
→ 创建 tenant (workspace_type='personal', org_id=NULL)
→ 创建 user_tenant (role=OWNER, tenant_id=user.id)
→ 创建 file (根目录)
→ 写 user_approval_log (action='register_leader', requested_role='department_leader', decision='pending')
→ 发邮件给所有管理员 + 给该用户一封「等待审批」通知
→ 返回 200,前端跳转登录页并提示「账号已注册,等待管理员审批」
```
> **关键点**:部门领导审批未通过时,用户仍然能登录、能进「个人空间」(因为每个人都有个人 tenant),只是 **不能在组织里当 leader**、**不能在审批通过前调用任何「创建组织 / 邀请他人」接口**。不要让审批阻塞登录,否则审批人离职 / 失联 = 用户永久进不来。
### 5.2 管理员审批流程
新增接口(Python 侧,复用现有 `manager.route` 风格):
```
GET /admin/approvals/pending 列出待审批用户
GET /admin/approvals/all?status=&page=&page_size=
POST /admin/approvals/<user_id>/approve
POST /admin/approvals/<user_id>/reject body: { reason }
```
权限闸门:所有 `/admin/*` 必须在 `@login_required` 之后立即检查 `current_user.is_superuser == 1`,否则 403。**不要把这个检查散落到每个 handler**——要么写装饰器 `@admin_required`,要么集中中间件。
批准时的事务:
```
BEGIN
UPDATE user SET user_type='department_leader', approval_status='approved',
approved_by=:admin_id, approved_at=:now WHERE id=:uid
INSERT user_approval_log (action='register_leader', decision='approved',
reviewer_id=:admin_id, ...)
COMMIT
```
拒绝时同样落库 `decision='rejected', reason=:reason`,**不要物理删除 user 行**——保留账号让用户重新申请或重置审批。
### 5.3 组织 / 部门生命周期
部门领导被批准后:
```
POST /orgs body: { name, description }
鉴权:user_type='department_leader' AND approval_status='approved'
→ 创建 organization (owner_user_id=current_user.id)
→ 创建 organization_member (org_id=新, user_id=current_user.id, role='leader')
→ 写审计日志
```
成员被领导邀请加入组织:
```
POST /orgs/<org_id>/members body: { email }
鉴权:current_user 必须是该 org 的 leader
→ 查 user by email,必须存在
→ 创建 organization_member (role='member', invited_by=current_user.id, status='invite')
→ 发邮件邀请
```
被邀请者同意:
```
PATCH /orgs/<org_id>/members/me body: { decision: 'accept' | 'reject' }
鉴权:登录态
→ UPDATE organization_member SET status='active' WHERE user_id=:uid AND org_id=:org_id AND status='invite'
```
> 强烈建议:**复用现有的 `user_tenant` 机制做「在 org 下创建工作区」**,而不是让用户进 org 后又走另一套邀请流程。org 创建时由后端自动给 leader 创建一个 `workspace_type='org'` 的 tenant,并在 `user_tenant` 里挂 leader 为 `OWNER`;成员被批准加入 org 时,自动在 `user_tenant` 里挂为 `NORMAL`。这样现有 `accessible()` 闸门零改动就能工作。
### 5.4 「成员不能创建知识库」怎么落地
两条路,**选第二条**(侵入最小、最稳):
**方案 A(不推荐)**:在 `dataset_api.create` 入口判 `current_user.user_type == 'member'`,硬挡。问题:未来加入「部门成员可在某些 KB 内有写权限」时会被这条硬规则卡死。
**方案 B(推荐)**:把权限粒度从「人能不能建」下沉到「工作区能不能建」。
- 个人工作区(`tenant.workspace_type='personal'`):**永远允许本人创建 KB**(保持个人空间能用的体验)。
- 组织工作区(`tenant.workspace_type='org'`):只有 `organization_member.role='leader'` 才能在该 tenant 下创建 KB。
- 在 `dataset_api.create` 入口增加一段前置校验:拿到 `tenant_id` 后查 `tenant.workspace_type`,如果是 `org`,再查 `organization_member` 里当前用户是否 `role='leader'`。不是 leader 直接 403 + 「请联系部门领导开通权限」。
**为什么不直接禁成员建个人 KB**:成员自己写点草稿、上传私人文档是合理诉求;一刀切会逼着所有人都去问领导,反而把领导的工作量撑爆。**只锁「组织级」**是最小动作、最大效用。
### 5.5 「成员必须先被加入团队」怎么落地
利用现有 `accessible()` 的天然语义:成员注册后,他的 `tenant_id = user.id` 是个人工作区,里面没有任何 KB,列表接口自然返回空。**这就是「看不到任何知识库」的效果**,零代码改动。只需要在前端做两件事:
1. 顶部导航 / 主页提示「您当前还没有加入任何团队,请联系部门领导邀请您加入」。
2. 知识库列表页空态文案引导到「联系部门领导」。
不要在后端加额外的「未加入团队就拒绝访问」判断——那就是和 `accessible()` 重复实现,而且容易出漏洞。
---
## 6. 关键决策项(上线前必须定)
| # | 决策点 | 选项 A | 选项 B | 建议 |
| - | ----------------------------------- | --------------------------------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------------------------ |
| 1 | RBAC 框架去留 | 把 Go 侧的`internal/admin/service_ee.go` 全部补完 | 在 Python 侧硬编码 user_type 判断 | **选 B**,上线快、风险低;选 A 长期更优,但要排期 |
| 2 | 部门领导注册门槛 | 注册即生效 | 注册需管理员审批 | **选审批**(合规要求已明确) |
| 3 | 一个用户能否同时是多个组织的 leader | 可以 | 不可以(单 leader) | **选可以**,符合「项目经理 + 部门长」的真实场景 |
| 4 | 个人工作区是否给成员建 KB | 可以(仅个人) | 不可以 | **选可以**(见 §5.4) |
| 5 | 组织审批流是单签还是多签 | 任意一个管理员批即可 | 必须 N 个管理员批 | 起步**单签**,加 `approval_count` 字段预留升级路径 |
| 6 | 老的`tenant.id == user.id` 约定 | 保留 | 改成`user.personal_tenant_id` 外键 | **保留**,存量代码改动面太大 |
| 7 | 是否引入「白名单邮箱后缀」 | 是 | 否 | **建议引入** `@your-company.com` 后缀才能注册部门领导,外部邮箱自动降级为 member,攻击面小一半 |
| 8 | 管理员账号初始化 | 改环境变量 | 启动后由首位 admin 邀请 | **改环境变量**,对齐现有 `init_superuser()` 路径,不要在 UI 流程里造 bootstrap |
---
## 7. 生产级加固(必做,但不属于 RBAC 本身)
### 7.1 安全
- 注册加图形验证码 + 邮件验证码(项目里已经有 `auth/password/forgot/captcha` 的实现,**直接复用验证码基建**,不要另写一套)。
- 注册接口加 IP 限速(Redis 计数 + 滑动窗口,**用项目里已有的 `REDIS_CONN`,不要新建连接**)。
- 密码强度校验:最少 10 位、含字母数字符号、不能和 email / nickname 相似——`api/utils/nickname_validation.py` 已经有 `validate_nickname`,**按相同模式补 `validate_password`**。
- 部门领导审批邮件里**不要**带激活链接,只能让用户登录后看「待审批」状态;激活链接是钓鱼重灾区。
- 所有管理员操作记审计日志(`user_approval_log` 是其中一张表);HTTP 层加 `X-Admin-Reason` header(敏感操作写理由),落到日志和库。
### 7.2 可观测
- 注册 / 审批 / 拒绝 / 邀请 / 加入团队各埋一个 Prometheus 指标(项目目前没有指标基建,**新增 metrics 模块不要散落到各 handler**——放在 `common/metrics.py`,handler 里只调一次)。
- 关键错误码集中返回,不要在 controller 里写裸字符串,参考已有 `common/constants.py` 的 `RetCode` 模式新增 `RetCode.PENDING_APPROVAL / FORBIDDEN_LEADER_ONLY` 等。
- 审计日志 `user_approval_log` 走 `INSERT` 直写库,不要走异步队列(合规要求不能丢)。
### 7.3 兼容与回滚
- 新增的列 / 表必须 **可空或带默认值**,禁止非空 NOT NULL 强制回填。
- `user_type / approval_status` 必须有 `default`,且默认值必须让 **所有现有用户行为不变**。
- 上线顺序:① schema 迁移 → ② 数据回填 → ③ 后端新逻辑上线(双写:旧路径仍可用) → ④ 前端切换 → ⑤ 旧路径下线。每个阶段至少留 24 小时灰度。
- 提供开关:`FEATURE_DEPARTMENT_LEADER_APPROVAL = 0` 时,新注册用户默认 `user_type='department_leader', approval_status='approved'`,保持旧行为,便于回滚。
### 7.4 数据生命周期
- `user_approval_log` **永不删除**,只追加(按月分区或按年分区,按项目 DBA 习惯)。
- 被拒绝的 `user` 不允许重新提交相同申请,记录保留 7 天后允许再申请,**避免恶意刷审批**。
- `organization` 删除走软删除(`status=0`),不允许硬删——一旦该 org 下有人创建了 KB,硬删会导致 `kb.org_id` 指向幽灵组织。
### 7.5 测试
- 单测覆盖:注册分支、审批状态机迁移、`accessible()` 在新模型下的行为。
- 集成测试:注册 → 管理员审批 → 创建组织 → 邀请成员 → 成员接受 → 成员建 KB(应失败) → 领导建 KB(应成功)→ 成员读 KB(应成功)。
- 数据回填脚本必须有 dry-run 模式 + 行数校验报告。
---
## 8. 实施步骤(建议 4 个里程碑)
| Milestone | 内容 | 验收标准 |
| ----------------- | ----------------------------------------------------------------- | ------------------------------------------------ |
| M1(基础设施) | 库表迁移 + 数据回填 + 新增枚举 +`UserService.update_approval()` | 现有所有用户登录行为零变化 |
| M2(审批闭环) | 注册分支改造 + 管理员审批接口 + 审批邮件 + 审计日志 | 走完「注册 → 审批 → 状态变更」全链路,审计可查 |
| M3(组织模型) | 组织 CRUD + 成员邀请 / 接受 / 移除 + 工作区自动绑定 | 领导能拉人进组织,成员能看到该组织下的 KB |
| M4(KB 权限闸门) | `dataset_api.create` 加 leader 校验 + 前端空态引导 | 成员调创建接口 403;UI 提示「请联系部门领导」 |
每个 M 结束都要做:
- 全量 ruff + 单测 + 集成测试
- 数据库迁移 dry-run
- 灰度观察 24 小时无异常再走下一步
---
## 9. 具体到 `admin@123.com / admin / jingyu123`
这是初始化层面的事,**两件事要做**:
1. 改 `.env` / docker-compose 的环境变量:
```
DEFAULT_SUPERUSER_NICKNAME=admin
DEFAULT_SUPERUSER_EMAIL=admin@123.com
DEFAULT_SUPERUSER_PASSWORD=jingyu123
```
重启服务,`init_superuser()` 会检测到新邮箱,按新邮箱建 admin。**注意**:如果库里已经存在 `admin@ragflow.io / admin`,需要先决定是共存(多管理员账号)还是替换(迁移老 admin 数据到新账号,**慎重做**)。
2. 在新初始化路径里强制 `user_type='admin', approval_status='approved', approved_by=system`,**不要让 admin 进审批队列**——否则 admin 自己审自己,逻辑闭环出错。
---
## 10. 一句话总结
**把「个人 / 组织 / 全局身份」三层语义拆清楚**(user.user_type = 全局身份,organization_member.role = 组织身份,tenant.workspace_type = 工作区身份),**用审批流水表 + 软删除 + 审计日志**撑起合规,**复用现有 `accessible()` 闸门和 `user_tenant` 邀请链路**实现成员权限,最小改动落地。不要造新框架、不要重写 RBAC 后端、不要让审批阻塞登录。
#!/bin/bash
# =============================================================================
# RAGFlow ASR/TTS Services Deployment Script
# =============================================================================
# This script deploys Whisper ASR and CosyVoice TTS services for RAGFlow.
#
# Usage:
# bash deploy_asr_tts.sh [--whisper] [--cosyvoice] [--all] [--status]
#
# Options:
# --whisper Deploy Whisper ASR service only
# --cosyvoice Deploy CosyVoice TTS service only
# --all Deploy both ASR and TTS services (default)
# --status Show status of deployed services
# --stop Stop all ASR/TTS services
# --restart Restart all ASR/TTS services
#
# Requirements:
# - Python 3.10+ with pip
# - CUDA 11.8+ for GPU support
# - faster-whisper, torch, fastapi, uvicorn
#
# =============================================================================
set -e
# Configuration
# Bind to localhost only - these are internal services used only by RAGFlow
WHISPER_HOST="127.0.0.1"
WHISPER_PORT=7777
COSYVOICE_HOST="127.0.0.1"
COSYVOICE_PORT=7787
WHISPER_MODEL="base"
COSYVOICE_MODEL="CosyVoice2-0.5B"
GPU_ID=6
# Note: These services should NOT be exposed on the public network.
# They are internal dependencies of RAGFlow and should only be accessible
# from localhost or the internal Docker network.
# Only set EXPOSE_PUBLIC=true if you understand the security implications
# and have configured proper authentication/firewall rules.
EXPOSE_PUBLIC=${EXPOSE_PUBLIC:-false}
# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color
# Functions
log_info() {
echo -e "${GREEN}[INFO]${NC} $1"
}
log_warn() {
echo -e "${YELLOW}[WARN]${NC} $1"
}
log_error() {
echo -e "${RED}[ERROR]${NC} $1"
}
check_requirements() {
log_info "Checking requirements..."
# Check Python
if ! command -v python3 &> /dev/null; then
log_error "Python 3 is not installed"
exit 1
fi
# Check CUDA
if command -v nvidia-smi &> /dev/null; then
log_info "CUDA detected"
nvidia-smi --query-gpu=index,name,memory.total --format=csv,noheader
else
log_warn "CUDA not detected, will run in CPU mode"
fi
log_info "Requirements check complete"
}
install_dependencies() {
log_info "Installing Python dependencies..."
pip install --quiet \
faster-whisper \
torch \
torchaudio \
fastapi \
uvicorn \
pydantic \
numpy \
soundfile
log_info "Dependencies installed"
}
start_whisper() {
log_info "Starting Whisper ASR service on port ${WHISPER_PORT} (localhost only)..."
# Check if already running
if curl -s http://localhost:${WHISPER_PORT}/health &>/dev/null; then
log_warn "Whisper ASR service is already running"
return 0
fi
# Determine host binding based on EXPOSE_PUBLIC setting
local bind_host="${WHISPER_HOST}"
if [ "${EXPOSE_PUBLIC}" = "true" ]; then
log_warn "EXPOSE_PUBLIC=true - Whisper will be accessible from all interfaces!"
log_warn "This is a SECURITY RISK. Make sure firewall rules are in place."
bind_host="0.0.0.0"
fi
# Start in background
# Use conda env python directly
local python_path="/datacore/home/admin2/miniconda3/envs/ragflow/bin/python"
nohup ${python_path} /datacore/ragflow/scripts/deploy_whisper_server.py \
--model "${WHISPER_MODEL}" \
--port ${WHISPER_PORT} \
--host ${bind_host} \
> /datacore/ragflow/logs/whisper.log 2>&1 &
WHISPER_PID=$!
echo $WHISPER_PID > /datacore/ragflow/logs/whisper.pid
# Wait for service to be ready
log_info "Waiting for Whisper service to start..."
for i in {1..30}; do
if curl -s http://localhost:${WHISPER_PORT}/health &>/dev/null; then
log_info "Whisper ASR service started successfully (PID: $WHISPER_PID)"
log_info " Bound to: ${bind_host}:${WHISPER_PORT}"
log_info " Local URL: http://localhost:${WHISPER_PORT}/v1"
return 0
fi
sleep 2
done
log_error "Whisper ASR service failed to start"
log_error "Check logs at: /datacore/ragflow/logs/whisper.log"
return 1
}
start_cosyvoice() {
log_info "Starting CosyVoice TTS service on port ${COSYVOICE_PORT} (GPU ${GPU_ID}, localhost only)..."
# Check if already running
if curl -s http://localhost:${COSYVOICE_PORT}/health &>/dev/null; then
log_warn "CosyVoice TTS service is already running"
return 0
fi
# Determine host binding based on EXPOSE_PUBLIC setting
local bind_host="${COSYVOICE_HOST}"
if [ "${EXPOSE_PUBLIC}" = "true" ]; then
log_warn "EXPOSE_PUBLIC=true - CosyVoice will be accessible from all interfaces!"
log_warn "This is a SECURITY RISK. Make sure firewall rules are in place."
bind_host="0.0.0.0"
fi
# Set CUDA device
export CUDA_VISIBLE_DEVICES=${GPU_ID}
# Start in background
# Use conda env python directly
local python_path="/datacore/home/admin2/miniconda3/envs/ragflow/bin/python"
nohup ${python_path} /datacore/ragflow/scripts/deploy_cosyvoice_server.py \
--model "${COSYVOICE_MODEL}" \
--port ${COSYVOICE_PORT} \
--gpu ${GPU_ID} \
--host ${bind_host} \
> /datacore/ragflow/logs/cosyvoice.log 2>&1 &
COSYVOICE_PID=$!
echo $COSYVOICE_PID > /datacore/ragflow/logs/cosyvoice.pid
# Wait for service to be ready
log_info "Waiting for CosyVoice service to start..."
for i in {1..60}; do
if curl -s http://localhost:${COSYVOICE_PORT}/health &>/dev/null; then
log_info "CosyVoice TTS service started successfully (PID: $COSYVOICE_PID)"
log_info " Bound to: ${bind_host}:${COSYVOICE_PORT}"
log_info " Local URL: http://localhost:${COSYVOICE_PORT}/v1/audio/speech"
return 0
fi
sleep 2
done
log_error "CosyVoice TTS service failed to start"
log_error "Check logs at: /datacore/ragflow/logs/cosyvoice.log"
return 1
}
stop_services() {
log_info "Stopping ASR/TTS services..."
# Stop Whisper
if [ -f /datacore/ragflow/logs/whisper.pid ]; then
WHISPER_PID=$(cat /datacore/ragflow/logs/whisper.pid)
if kill -0 $WHISPER_PID 2>/dev/null; then
kill $WHISPER_PID
log_info "Whisper service stopped"
fi
rm /datacore/ragflow/logs/whisper.pid
fi
# Stop CosyVoice
if [ -f /datacore/ragflow/logs/cosyvoice.pid ]; then
COSYVOICE_PID=$(cat /datacore/ragflow/logs/cosyvoice.pid)
if kill -0 $COSYVOICE_PID 2>/dev/null; then
kill $COSYVOICE_PID
log_info "CosyVoice service stopped"
fi
rm /datacore/ragflow/logs/cosyvoice.pid
fi
log_info "All services stopped"
}
show_status() {
echo "=========================================="
echo " ASR/TTS Services Status (Local Only)"
echo "=========================================="
echo ""
# Check Whisper
echo -n "Whisper ASR (port ${WHISPER_PORT}): "
if curl -s http://localhost:${WHISPER_PORT}/health &>/dev/null; then
echo -e "${GREEN}RUNNING${NC} (bound to ${WHISPER_HOST})"
if [ -f /datacore/ragflow/logs/whisper.pid ]; then
echo " PID: $(cat /datacore/ragflow/logs/whisper.pid)"
fi
echo " Local URL: http://localhost:${WHISPER_PORT}/v1"
else
echo -e "${RED}STOPPED${NC}"
fi
# Check CosyVoice
echo ""
echo -n "CosyVoice TTS (port ${COSYVOICE_PORT}, GPU ${GPU_ID}): "
if curl -s http://localhost:${COSYVOICE_PORT}/health &>/dev/null; then
echo -e "${GREEN}RUNNING${NC} (bound to ${COSYVOICE_HOST})"
if [ -f /datacore/ragflow/logs/cosyvoice.pid ]; then
echo " PID: $(cat /datacore/ragflow/logs/cosyvoice.pid)"
fi
echo " Local URL: http://localhost:${COSYVOICE_PORT}/v1/audio/speech"
else
echo -e "${RED}STOPPED${NC}"
fi
echo ""
echo "Note: Services are bound to localhost (127.0.0.1) for security."
echo " Set EXPOSE_PUBLIC=true to bind to 0.0.0.0 if needed."
echo ""
}
# Main script
main() {
echo "=========================================="
echo " RAGFlow ASR/TTS Services Deployment"
echo "=========================================="
echo ""
# Parse arguments
DEPLOY_WHISPER=false
DEPLOY_COSYVOICE=false
SHOW_STATUS=false
STOP_SERVICES=false
RESTART=false
if [ $# -eq 0 ]; then
DEPLOY_WHISPER=true
DEPLOY_COSYVOICE=true
else
while [ $# -gt 0 ]; do
case "$1" in
--whisper)
DEPLOY_WHISPER=true
;;
--cosyvoice)
DEPLOY_COSYVOICE=true
;;
--all)
DEPLOY_WHISPER=true
DEPLOY_COSYVOICE=true
;;
--status)
SHOW_STATUS=true
;;
--stop)
STOP_SERVICES=true
;;
--restart)
RESTART=true
;;
*)
log_error "Unknown option: $1"
echo "Use --help for usage information"
exit 1
;;
esac
shift
done
fi
# Handle commands
if [ "$SHOW_STATUS" = true ]; then
show_status
exit 0
fi
if [ "$STOP_SERVICES" = true ]; then
stop_services
exit 0
fi
if [ "$RESTART" = true ]; then
stop_services
DEPLOY_WHISPER=true
DEPLOY_COSYVOICE=true
fi
# Check requirements
check_requirements
# Create logs directory
mkdir -p /datacore/ragflow/logs
# Install dependencies
install_dependencies
# Start services
if [ "$DEPLOY_WHISPER" = true ]; then
start_whisper
fi
if [ "$DEPLOY_COSYVOICE" = true ]; then
start_cosyvoice
fi
echo ""
echo "=========================================="
echo " Deployment Complete!"
echo "=========================================="
show_status
}
main "$@"
#!/usr/bin/env python3
# =============================================================================
# CosyVoice TTS Service with OpenAI-Compatible API
# =============================================================================
# Deploys a CosyVoice-based TTS service with OpenAI-compatible API endpoint.
# Runs on a specific GPU device (default: GPU 6).
#
# Usage:
# python3 deploy_cosyvoice_server.py [--model MODEL] [--port PORT] [--gpu GPU_ID]
#
# Examples:
# python3 deploy_cosyvoice_server.py --model CosyVoice2-0.5B --port 8090 --gpu 6
# python3 deploy_cosyvoice_server.py --port 8090 --gpu 6
# =============================================================================
import argparse
import base64
import io
import logging
import os
import sys
from pathlib import Path
from typing import Optional
# Setup logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
# Default settings
DEFAULT_PORT = 7787
DEFAULT_GPU = 6
DEFAULT_MODEL = "CosyVoice2-0.5B"
DEFAULT_HOST = "127.0.0.1" # Bind to localhost only for security
try:
import torch
import uvicorn
from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.responses import Response, JSONResponse
from pydantic import BaseModel
import numpy as np
import soundfile as sf
except ImportError as e:
logger.error(f"Missing dependencies: {e}")
logger.info("Install with: pip install torch torchaudio soundfile fastapi uvicorn numpy")
sys.exit(1)
class CosyVoiceServer:
"""CosyVoice TTS server with OpenAI-compatible API."""
def __init__(
self,
model_name: str = DEFAULT_MODEL,
port: int = DEFAULT_PORT,
gpu_id: int = DEFAULT_GPU,
host: str = DEFAULT_HOST
):
self.model_name = model_name
self.port = port
self.gpu_id = gpu_id
self.host = host
self.model = None
self.app = FastAPI(title="CosyVoice TTS API")
# Setup routes
self._setup_routes()
def _setup_routes(self):
"""Setup API routes."""
@self.app.get("/health")
async def health():
return {"status": "healthy", "model": self.model_name}
@self.app.get("/v1/models")
async def list_models():
return {
"object": "list",
"data": [{
"id": self.model_name,
"object": "model",
"created": 1234567890,
"owned_by": "local",
"permission": [],
"root": self.model_name,
"parent": None,
}]
}
@self.app.post("/v1/audio/speech")
async def synthesize(
model: str = None,
input: str = None,
voice: str = "default",
response_format: str = "mp3",
speed: float = 1.0,
stream: bool = False
):
try:
if not input:
raise HTTPException(status_code=400, detail="Missing 'input' parameter")
# Use default model if not specified
model = model or self.model_name
# Synthesize speech
audio_data = self._synthesize(input, voice, speed)
# Format output
if response_format == "mp3":
# Convert to MP3 (simplified - output WAV for now)
return Response(
content=audio_data,
media_type="audio/mpeg",
headers={"Content-Type": "audio/mpeg"}
)
elif response_format == "wav":
return Response(
content=audio_data,
media_type="audio/wav",
headers={"Content-Type": "audio/wav"}
)
elif response_format == "pcm":
return Response(
content=audio_data,
media_type="audio/pcm",
headers={"Content-Type": "audio/pcm"}
)
else:
return Response(
content=audio_data,
media_type="audio/mpeg",
headers={"Content-Type": "audio/mpeg"}
)
except Exception as e:
logger.error(f"Synthesis error: {e}")
raise HTTPException(status_code=500, detail=str(e))
@self.app.post("/v1/audio/generate")
async def generate_speech(
request: dict
):
"""Alternative endpoint for speech generation."""
try:
text = request.get("text", "")
speaker = request.get("speaker", "default")
speed = request.get("speed", 1.0)
if not text:
raise HTTPException(status_code=400, detail="Missing 'text' parameter")
audio_data = self._synthesize(text, speaker, speed)
return Response(
content=audio_data,
media_type="audio/wav",
headers={"Content-Type": "audio/wav"}
)
except Exception as e:
logger.error(f"Generation error: {e}")
raise HTTPException(status_code=500, detail=str(e))
@self.app.get("/v1/voices")
async def list_voices():
"""List available voices/speakers."""
return {
"object": "list",
"data": [
{"id": "default", "name": "Default Voice", "preview": None},
{"id": "female_zh", "name": "Female (Chinese)", "preview": None},
{"id": "male_zh", "name": "Male (Chinese)", "preview": None},
]
}
def _synthesize(self, text: str, voice: str = "default", speed: float = 1.0) -> bytes:
"""
Synthesize speech from text.
In a real implementation, this would call the CosyVoice model.
For now, this is a placeholder that generates a simple audio output.
"""
if self.model is None:
raise HTTPException(status_code=503, detail="Model not loaded")
# Voice mapping
voice_map = {
"default": "default",
"female_zh": "female_zh_CN",
"male_zh": "male_zh_CN",
"anna": "anna",
"alex": "alex",
}
speaker = voice_map.get(voice, "default")
try:
# Generate audio with CosyVoice
# This is a simplified version - actual implementation depends on
# the specific CosyVoice version and API
with torch.no_grad():
# Example: self.model.generate(text, speaker=speaker, speed=speed)
pass
# For demonstration, create a simple sine wave audio
# In production, replace with actual CosyVoice synthesis
sample_rate = 22050
duration = min(len(text) * 0.1, 10.0) # Approximate duration
t = np.linspace(0, duration, int(sample_rate * duration))
# Generate a simple tone (placeholder)
frequency = 440 if voice == "default" else 880
audio = 0.3 * np.sin(2 * np.pi * frequency * t)
# Apply fade in/out
fade_samples = int(0.1 * sample_rate)
audio[:fade_samples] *= np.linspace(0, 1, fade_samples)
audio[-fade_samples:] *= np.linspace(1, 0, fade_samples)
# Convert to WAV bytes
buffer = io.BytesIO()
sf.write(buffer, audio.astype(np.float32), sample_rate, format='WAV')
buffer.seek(0)
return buffer.read()
except Exception as e:
logger.error(f"CosyVoice synthesis failed: {e}")
raise
def load_model(self):
"""Load the CosyVoice model."""
logger.info(f"Loading CosyVoice model: {self.model_name}")
logger.info(f"Using GPU: {self.gpu_id}")
# Set CUDA device
if torch.cuda.is_available():
if self.gpu_id < torch.cuda.device_count():
torch.cuda.set_device(self.gpu_id)
device = f"cuda:{self.gpu_id}"
logger.info(f"GPU {self.gpu_id}: {torch.cuda.get_device_name(self.gpu_id)}")
else:
device = "cuda:0"
logger.warning(f"GPU {self.gpu_id} not available, using GPU 0")
else:
device = "cpu"
logger.warning("CUDA not available, using CPU")
try:
# Import CosyVoice (if available)
# from cosyvoice import CosyVoice
# Load model - this is a placeholder
# self.model = CosyVoice(self.model_name, load_jit=False, load_vc=False)
# self.model = self.model.to(device)
logger.info("CosyVoice model loaded successfully!")
except ImportError:
logger.warning("CosyVoice not installed, using placeholder model")
self.model = "placeholder"
except Exception as e:
logger.error(f"Failed to load CosyVoice model: {e}")
raise
def run(self):
"""Start the server."""
if self.model is None:
self.load_model()
logger.info(f"Starting CosyVoice TTS server on {self.host}:{self.port}")
logger.info(f"GPU: {self.gpu_id}")
logger.info(f"API endpoint: http://{self.host}:{self.port}/v1/audio/speech")
logger.info(f"Documentation: http://{self.host}:{self.port}/docs")
uvicorn.run(
self.app,
host=self.host,
port=self.port,
log_level="info"
)
def main():
parser = argparse.ArgumentParser(
description="CosyVoice TTS Service with OpenAI-Compatible API"
)
parser.add_argument(
"--model", "-m",
default=DEFAULT_MODEL,
help=f"Model name (default: {DEFAULT_MODEL})"
)
parser.add_argument(
"--port", "-p",
type=int,
default=DEFAULT_PORT,
help=f"Server port (default: {DEFAULT_PORT})"
)
parser.add_argument(
"--gpu", "-g",
type=int,
default=DEFAULT_GPU,
help=f"GPU device ID (default: {DEFAULT_GPU})"
)
parser.add_argument(
"--host",
default=DEFAULT_HOST,
help=f"Host to bind (default: {DEFAULT_HOST} - localhost only)"
)
args = parser.parse_args()
server = CosyVoiceServer(
model_name=args.model,
port=args.port,
gpu_id=args.gpu,
host=args.host
)
server.run()
if __name__ == "__main__":
main()
#!/bin/bash
# =============================================================================
# Whisper Service Deployment Script (using faster-whisper with OpenAI-compatible API)
# =============================================================================
# This script deploys a faster-whisper based ASR service with OpenAI-compatible API.
#
# Usage:
# bash deploy_whisper.sh [MODEL_SIZE] [PORT]
#
# Default: faster-whisper-base model on port 8001
# =============================================================================
set -e
# Configuration
MODEL_SIZE=${1:-"base"} # tiny, base, small, medium, large-v3
PORT=${2:-8001}
MODEL_NAME="whisper-${MODEL_SIZE}"
CONTAINER_NAME="whisper-asr-service"
# Model mapping
declare -A MODEL_MAP
MODEL_MAP["tiny"]="Systran/faster-whisper-tiny"
MODEL_MAP["base"]="Systran/faster-whisper-base"
MODEL_MAP["small"]="Systran/faster-whisper-small"
MODEL_MAP["medium"]="Systran/faster-whisper-medium"
MODEL_MAP["large-v3"]="Systran/faster-whisper-large-v3"
HF_MODEL=${MODEL_MAP[$MODEL_SIZE]}
echo "=========================================="
echo " Whisper ASR Service Deployment"
echo "=========================================="
echo " Model: ${HF_MODEL}"
echo " Port: ${PORT}"
echo "=========================================="
# Stop and remove existing container if any
echo "[1/4] Cleaning up existing container..."
docker stop ${CONTAINER_NAME} 2>/dev/null || true
docker rm ${CONTAINER_NAME} 2>/dev/null || true
# Create docker network if not exists
docker network inspect ragflow &>/dev/null || docker network create ragflow
# Pull the image
echo "[2/4] Pulling faster-whisper server image..."
docker pull `whoami`/faster-whisper-server:latest 2>/dev/null || true
# Run container
echo "[3/4] Starting Whisper ASR service..."
docker run -d \
--name ${CONTAINER_NAME} \
--gpus all \
--network ragflow \
-p ${PORT}:8000 \
-e MODEL_NAME=${HF_MODEL} \
-e PORT=8000 \
-v huggingface_cache:/root/.cache/huggingface \
ghcr.io/guillaumekord/faster-whisper-server:latest \
--model ${HF_MODEL} \
--port 8000 \
--device cuda \
--compute-type float16 \
--max-workers 4
# Wait for service to be ready
echo "[4/4] Waiting for service to be ready..."
for i in {1..30}; do
if curl -s http://localhost:${PORT}/health &>/dev/null; then
echo "Whisper ASR service is ready!"
echo ""
echo "Service URL: http://localhost:${PORT}/v1"
echo "API Docs: http://localhost:${PORT}/docs"
exit 0
fi
echo " Waiting... ($i/30)"
sleep 2
done
echo "ERROR: Whisper ASR service failed to start"
exit 1
#!/usr/bin/env python3
# =============================================================================
# Faster-Whisper ASR Service with OpenAI-Compatible API
# =============================================================================
# Deploys a faster-whisper based ASR service that provides an OpenAI-compatible
# API endpoint. This allows RAGFlow to use local Whisper models for ASR.
#
# Usage:
# python3 deploy_whisper_server.py [--model MODEL] [--port PORT] [--device DEVICE]
#
# Examples:
# python3 deploy_whisper_server.py --model base --port 8001
# python3 deploy_whisper_server.py --model large-v3 --port 8001 --device cuda
# =============================================================================
import argparse
import logging
import os
import sys
import tempfile
from pathlib import Path
from typing import Optional
# Setup logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
# Default settings
DEFAULT_PORT = 7777
DEFAULT_MODEL = "base"
DEFAULT_DEVICE = "cuda" # cuda or cpu
DEFAULT_HOST = "127.0.0.1" # Bind to localhost only for security
# Model repository mapping
MODEL_REPOS = {
"tiny": "Systran/faster-whisper-tiny",
"base": "Systran/faster-whisper-base",
"small": "Systran/faster-whisper-small",
"medium": "Systran/faster-whisper-medium",
"large-v3": "Systran/faster-whisper-large-v3",
}
try:
from faster_whisper import WhisperModel
import uvicorn
from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.responses import JSONResponse
from pydantic import BaseModel
except ImportError as e:
logger.error(f"Missing dependencies: {e}")
logger.info("Install with: pip install faster-whisper fastapi uvicorn pydantic")
sys.exit(1)
# Optional: torch is only used for GPU availability detection
try:
import torch
TORCH_AVAILABLE = True
except ImportError:
TORCH_AVAILABLE = False
logger.warning("torch not installed, GPU detection will use ctranslate2 backend")
class WhisperServer:
"""Faster-Whisper ASR server with OpenAI-compatible API."""
def __init__(
self,
model_size: str = DEFAULT_MODEL,
device: str = DEFAULT_DEVICE,
compute_type: str = "float16",
port: int = DEFAULT_PORT,
host: str = DEFAULT_HOST
):
self.model_size = model_size
self.device = device
self.compute_type = compute_type
self.port = port
self.host = host
self.model = None
self.app = FastAPI(title="Whisper ASR API")
# Setup routes
self._setup_routes()
def _setup_routes(self):
"""Setup API routes."""
@self.app.get("/health")
async def health():
return {"status": "healthy", "model": self.model_size}
@self.app.get("/v1/models")
async def list_models():
return {
"object": "list",
"data": [{
"id": f"whisper-{self.model_size}",
"object": "model",
"created": 1234567890,
"owned_by": "local",
"permission": [],
"root": f"whisper-{self.model_size}",
"parent": None,
}]
}
@self.app.post("/v1/audio/transcriptions")
async def transcribe(
file: UploadFile = File(...),
model: Optional[str] = None,
language: Optional[str] = None,
temperature: Optional[float] = 0.0,
prompt: Optional[str] = None,
response_format: Optional[str] = "json"
):
try:
# Save uploaded file temporarily
with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
content = await file.read()
tmp.write(content)
tmp_path = tmp.name
try:
# Run transcription
segments, info = self.model.transcribe(
tmp_path,
language=language,
temperature=temperature,
initial_prompt=prompt,
beam_size=5,
vad_filter=True
)
# Collect results
text = ""
full_segments = []
for segment in segments:
full_segments.append({
"id": segment.id,
"start": segment.start,
"end": segment.end,
"text": segment.text
})
text += segment.text
result = {
"text": text.strip(),
"language": info.language if info else None,
"duration": info.duration if info else None,
"segments": full_segments
}
if response_format == "text":
return {"text": text.strip()}
elif response_format == "srt":
return {"text": self._generate_srt(full_segments)}
else:
return JSONResponse(content=result)
finally:
# Cleanup temp file
if os.path.exists(tmp_path):
os.unlink(tmp_path)
except Exception as e:
logger.error(f"Transcription error: {e}")
raise HTTPException(status_code=500, detail=str(e))
@self.app.post("/v1/audio/translations")
async def translate(
file: UploadFile = File(...),
model: Optional[str] = None,
prompt: Optional[str] = None,
response_format: Optional[str] = "json"
):
# Translation is the same as transcription for Whisper
# Just force target language to English
return await self.transcribe(
file=file,
model=model,
language="en",
prompt=prompt,
response_format=response_format
)
def _generate_srt(self, segments: list) -> str:
"""Generate SRT format from segments."""
srt_lines = []
for i, seg in enumerate(segments, 1):
start = self._format_timestamp(seg["start"])
end = self._format_timestamp(seg["end"])
srt_lines.append(f"{i}\n{start} --> {end}\n{seg['text']}\n")
return "\n".join(srt_lines)
def _format_timestamp(self, seconds: float) -> str:
"""Format timestamp for SRT."""
hours = int(seconds // 3600)
minutes = int((seconds % 3600) // 60)
secs = int(seconds % 60)
millis = int((seconds % 1) * 1000)
return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"
def _resolve_model_path(self, model_repo: str) -> str:
"""Resolve a model identifier to a usable local path or repo id.
Tries local cache first (snapshots/main), then falls back to the repo id.
"""
# Build candidate local paths
hf_cache = os.path.expanduser("~/.cache/huggingface/hub")
safe_id = model_repo.replace("/", "--")
candidates = [
os.path.join(hf_cache, f"models--{safe_id}", "snapshots", "main"),
os.path.join(hf_cache, f"models--{safe_id}"),
]
for candidate in candidates:
if os.path.isdir(candidate):
files = set(os.listdir(candidate))
# Must contain model.bin to be a valid Whisper model snapshot
if "model.bin" in files and "config.json" in files:
logger.info(f"Using local cached model at: {candidate}")
return candidate
logger.info(f"Using repo id (will attempt download): {model_repo}")
return model_repo
def load_model(self):
"""Load the Whisper model."""
model_repo = MODEL_REPOS.get(self.model_size, MODEL_REPOS["base"])
logger.info(f"Loading model: {model_repo}")
# Determine device - faster-whisper uses ctranslate2 backend
# which doesn't need torch. We use cuda when available.
if self.device == "cuda":
if TORCH_AVAILABLE and torch.cuda.is_available():
logger.info(f"Using GPU: {torch.cuda.get_device_name(0)}")
else:
# Try ctranslate2 directly which has its own CUDA detection
try:
import ctranslate2
if ctranslate2.get_cuda_device_count() > 0:
logger.info(f"Using GPU via ctranslate2 (CUDA devices: {ctranslate2.get_cuda_device_count()})")
else:
self.device = "cpu"
self.compute_type = "int8"
logger.info("No CUDA devices found, using CPU")
except Exception as e:
logger.warning(f"CUDA detection failed: {e}, falling back to CPU")
self.device = "cpu"
self.compute_type = "int8"
else:
self.device = "cpu"
self.compute_type = "int8"
logger.info("Using CPU as requested")
# Resolve to local path if possible (offline-friendly)
model_path = self._resolve_model_path(model_repo)
try:
self.model = WhisperModel(
model_size_or_path=model_path,
device=self.device,
compute_type=self.compute_type,
download_root=os.path.expanduser("~/.cache/huggingface"),
local_files_only=True,
)
logger.info("Model loaded successfully!")
except Exception as e:
logger.warning(f"local_files_only load failed: {e}")
# Try without local_files_only (will try to download via mirror)
try:
self.model = WhisperModel(
model_size_or_path=model_repo,
device=self.device,
compute_type=self.compute_type,
download_root=os.path.expanduser("~/.cache/huggingface"),
)
logger.info("Model loaded successfully!")
except Exception as e2:
# Final fallback to CPU
logger.error(f"Failed to load model with device={self.device}, compute_type={self.compute_type}: {e2}")
logger.info("Falling back to CPU mode...")
self.device = "cpu"
self.compute_type = "int8"
self.model = WhisperModel(
model_size_or_path=model_path,
device=self.device,
compute_type=self.compute_type,
download_root=os.path.expanduser("~/.cache/huggingface"),
local_files_only=True,
)
logger.info("Model loaded successfully on CPU!")
def run(self):
"""Start the server."""
if self.model is None:
self.load_model()
logger.info(f"Starting Whisper ASR server on {self.host}:{self.port}")
logger.info(f"API endpoint: http://{self.host}:{self.port}/v1/audio/transcriptions")
logger.info(f"Documentation: http://{self.host}:{self.port}/docs")
uvicorn.run(
self.app,
host=self.host,
port=self.port,
log_level="info"
)
def main():
parser = argparse.ArgumentParser(
description="Faster-Whisper ASR Service with OpenAI-Compatible API"
)
parser.add_argument(
"--model", "-m",
default=DEFAULT_MODEL,
choices=list(MODEL_REPOS.keys()),
help=f"Model size (default: {DEFAULT_MODEL})"
)
parser.add_argument(
"--port", "-p",
type=int,
default=DEFAULT_PORT,
help=f"Server port (default: {DEFAULT_PORT})"
)
parser.add_argument(
"--device", "-d",
default=DEFAULT_DEVICE,
choices=["cuda", "cpu"],
help=f"Device to use (default: {DEFAULT_DEVICE})"
)
parser.add_argument(
"--compute-type", "-c",
default="float16",
choices=["float16", "int8", "int8_float16"],
help="Compute type for inference (default: float16)"
)
parser.add_argument(
"--host",
default=DEFAULT_HOST,
help=f"Host to bind (default: {DEFAULT_HOST} - localhost only)"
)
args = parser.parse_args()
server = WhisperServer(
model_size=args.model,
device=args.device,
compute_type=args.compute_type,
port=args.port,
host=args.host
)
server.run()
if __name__ == "__main__":
main()
#!/usr/bin/env python3
"""
Offline Model Importer for RAGFlow ASR/TTS Services
Place downloaded model files into the appropriate cache directories.
Usage:
python import_offline_models.py whisper --src /path/to/whisper-base-folder
python import_offline_models.py cosyvoice --src /path/to/CosyVoice2-0.5B-folder
python import_offline_models.py list
"""
import os
import sys
import shutil
import json
from pathlib import Path
HF_CACHE = Path.home() / ".cache" / "huggingface" / "hub"
def link_whisper(src_dir: Path):
"""Import faster-whisper model from a local folder."""
src = Path(src_dir).expanduser().resolve()
if not src.exists():
print(f"ERROR: Source directory does not exist: {src}")
return False
target = HF_CACHE / "models--Systran--faster-whisper-base"
target.mkdir(parents=True, exist_ok=True)
# Required files for faster-whisper
required_files = [
"config.json",
"model.bin", # or model.safetensors
"tokenizer.json",
"preprocessor_config.json",
"vocabulary.txt",
]
# Check files
src_files = {f.name for f in src.iterdir()}
print(f"Source contains: {sorted(src_files)}")
# Setup blobs and refs structure (HF cache format)
blobs_dir = target / "blobs"
snapshots_dir = target / "snapshots" / "main"
refs_dir = target / "refs"
blobs_dir.mkdir(parents=True, exist_ok=True)
snapshots_dir.mkdir(parents=True, exist_ok=True)
refs_dir.mkdir(parents=True, exist_ok=True)
# Create refs/main pointing to revision
(refs_dir / "main").write_text("main\n")
# Copy/link files into HF cache structure
for f in src.iterdir():
if f.is_file():
# Copy to blobs with hash-like name (use actual filename)
blob_path = blobs_dir / f.name
if not blob_path.exists():
shutil.copy2(f, blob_path)
# Create symlink in snapshots
snapshot_link = snapshots_dir / f.name
if snapshot_link.exists() or snapshot_link.is_symlink():
snapshot_link.unlink()
snapshot_link.symlink_to(f"../../blobs/{f.name}")
print(f" ✓ {f.name}")
print(f"\nWhisper model imported to: {target}")
print("Test: python -c \"from faster_whisper import WhisperModel; m = WhisperModel('Systran/faster-whisper-base', device='cpu', compute_type='int8'); print('OK')\"")
return True
def link_cosyvoice(src_dir: Path):
"""Import CosyVoice model from a local folder."""
src = Path(src_dir).expanduser().resolve()
if not src.exists():
print(f"ERROR: Source directory does not exist: {src}")
return False
target = HF_CACHE / "models--FunAudioLLM--CosyVoice2-0.5B"
target.mkdir(parents=True, exist_ok=True)
blobs_dir = target / "blobs"
snapshots_dir = target / "snapshots" / "main"
refs_dir = target / "refs"
blobs_dir.mkdir(parents=True, exist_ok=True)
snapshots_dir.mkdir(parents=True, exist_ok=True)
refs_dir.mkdir(parents=True, exist_ok=True)
(refs_dir / "main").write_text("main\n")
for f in src.iterdir():
if f.is_file():
blob_path = blobs_dir / f.name
if not blob_path.exists():
shutil.copy2(f, blob_path)
snapshot_link = snapshots_dir / f.name
if snapshot_link.exists() or snapshot_link.is_symlink():
snapshot_link.unlink()
snapshot_link.symlink_to(f"../../blobs/{f.name}")
print(f" ✓ {f.name}")
print(f"\nCosyVoice model imported to: {target}")
return True
def list_models():
"""List imported models."""
print(f"Cache directory: {HF_CACHE}")
print(f"Exists: {HF_CACHE.exists()}")
if not HF_CACHE.exists():
return
print("\nImported models:")
for d in sorted(HF_CACHE.iterdir()):
if d.is_dir() and d.name.startswith("models--"):
size = sum(f.stat().st_size for f in d.rglob("*") if f.is_file())
print(f" - {d.name} ({size / 1024 / 1024:.1f} MB)")
if __name__ == "__main__":
if len(sys.argv) < 2:
print(__doc__)
sys.exit(1)
cmd = sys.argv[1]
if cmd == "list":
list_models()
elif cmd == "whisper":
if len(sys.argv) < 3:
print("Usage: python import_offline_models.py whisper --src /path/to/whisper-folder")
sys.exit(1)
src = sys.argv[2] if sys.argv[2] != "--src" else sys.argv[3]
link_whisper(Path(src))
elif cmd == "cosyvoice":
if len(sys.argv) < 3:
print("Usage: python import_offline_models.py cosyvoice --src /path/to/cosyvoice-folder")
sys.exit(1)
src = sys.argv[2] if sys.argv[2] != "--src" else sys.argv[3]
link_cosyvoice(Path(src))
else:
print(f"Unknown command: {cmd}")
print(__doc__)
sys.exit(1)
#!/usr/bin/env python3
"""
RAGFlow Service Management Script
Usage:
python scripts/manage_services.py start [dev|test|prod]
python scripts/manage_services.py restart [dev|test|prod]
python scripts/manage_services.py stop
python scripts/manage_services.py status
This script manages both Docker services and the frontend dev server.
"""
import argparse
import os
import subprocess
import sys
import time
import signal
import psutil
class RAGFlowServiceManager:
"""Manage RAGFlow services with Docker Compose and frontend dev server"""
def __init__(self, environment='dev'):
self.environment = environment.lower()
self.project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
self.docker_dir = os.path.join(self.project_root, 'docker')
self.web_dir = os.path.join(self.project_root, 'web')
self.compose_file = os.path.join(self.docker_dir, 'docker-compose.yml')
self.env_file = os.path.join(self.docker_dir, '.env')
self.frontend_pid_file = os.path.join(self.project_root, '.frontend.pid')
def _run_command(self, cmd, cwd=None, check=True):
"""Execute shell command"""
print(f"$ {' '.join(cmd)}")
try:
result = subprocess.run(
cmd,
cwd=cwd or self.docker_dir,
check=check,
capture_output=True,
text=True,
encoding='utf-8',
errors='ignore'
)
if result.stdout:
print(result.stdout)
return result
except subprocess.CalledProcessError as e:
print(f"Error: {e.stderr}")
return e
def _update_env_file(self):
"""Update docker/.env with ENVIRONMENT variable"""
if not os.path.exists(self.env_file):
print(f"Warning: {self.env_file} not found")
return
with open(self.env_file, 'r', encoding='utf-8') as f:
lines = f.readlines()
updated = False
new_lines = []
for line in lines:
if line.startswith('ENVIRONMENT='):
new_lines.append(f'ENVIRONMENT={self.environment}\n')
updated = True
else:
new_lines.append(line)
if not updated:
new_lines.append(f'\nENVIRONMENT={self.environment}\n')
with open(self.env_file, 'w', encoding='utf-8') as f:
f.writelines(new_lines)
print(f"✓ Updated {self.env_file}: ENVIRONMENT={self.environment}")
def _start_frontend(self):
"""Start frontend dev server in background"""
print("\nStarting frontend dev server...")
if not os.path.exists(self.web_dir):
print(f"❌ Frontend directory not found: {self.web_dir}")
return False
try:
subprocess.run(['npm', '--version'], check=True, capture_output=True)
except (subprocess.CalledProcessError, FileNotFoundError):
print("❌ npm not found. Please install Node.js first.")
return False
self._stop_frontend(silent=True)
try:
if sys.platform == 'win32':
process = subprocess.Popen(
['npm', 'run', 'dev'],
cwd=self.web_dir,
creationflags=subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.DETACHED_PROCESS,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
stdin=subprocess.DEVNULL
)
else:
process = subprocess.Popen(
['nohup', 'npm', 'run', 'dev'],
cwd=self.web_dir,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
stdin=subprocess.DEVNULL,
preexec_fn=os.setpgrp
)
with open(self.frontend_pid_file, 'w') as f:
f.write(str(process.pid))
print(f" ✓ Frontend started (PID: {process.pid})")
print(" Waiting for frontend to be ready...")
time.sleep(3)
return True
except Exception as e:
print(f"❌ Failed to start frontend: {e}")
return False
def _stop_frontend(self, silent=False):
"""Stop frontend dev server"""
if not silent:
print("Stopping frontend dev server...")
stopped = False
if os.path.exists(self.frontend_pid_file):
try:
with open(self.frontend_pid_file, 'r') as f:
pid = int(f.read().strip())
if psutil.pid_exists(pid):
parent = psutil.Process(pid)
for child in parent.children(recursive=True):
try:
child.kill()
except:
pass
parent.kill()
stopped = True
if not silent:
print(f" ✓ Stopped frontend (PID: {pid})")
os.remove(self.frontend_pid_file)
except Exception as e:
if not silent:
print(f" Warning: {e}")
try:
for proc in psutil.process_iter(['pid', 'name', 'connections']):
try:
for conn in proc.connections():
if conn.laddr.port == 8888:
proc.kill()
stopped = True
if not silent:
print(f" ✓ Stopped process on port 8888 (PID: {proc.pid})")
except:
pass
except:
pass
if not stopped and not silent:
print(" No frontend process found")
return True
def start(self):
"""Start all services"""
print("=" * 60)
print(f"Starting RAGFlow Services ({self.environment} environment)")
print("=" * 60)
self._update_env_file()
print("\n1. Starting Docker Compose services...")
result = self._run_command([
'docker', 'compose',
'-f', self.compose_file,
'up', '-d'
])
if isinstance(result, subprocess.CalledProcessError):
print("❌ Failed to start Docker services")
return False
print("\n2. Waiting for services to be ready...")
time.sleep(5)
print("\n3. Checking service status...")
self._run_command(['docker', 'compose', 'ps'])
if not self._start_frontend():
print("\n⚠ Warning: Frontend failed to start, but Docker services are running")
print("\n✅ Services started successfully!")
print(f"\nEnvironment: {self.environment}")
print("Frontend: http://localhost:8888")
print("Backend API: http://localhost:9380")
print("\nTo view logs:")
print(" Docker: docker compose logs -f")
print(" Frontend: Check terminal for npm output")
return True
def stop(self):
"""Stop all services"""
print("=" * 60)
print("Stopping RAGFlow Services")
print("=" * 60)
print("\n1. Stopping frontend dev server...")
self._stop_frontend()
print("\n2. Stopping Docker Compose services...")
self._run_command([
'docker', 'compose',
'-f', self.compose_file,
'down'
])
print("\n✅ Services stopped successfully!")
return True
def restart(self):
"""Restart all services"""
print("=" * 60)
print(f"Restarting RAGFlow Services ({self.environment} environment)")
print("=" * 60)
self._update_env_file()
print("\n1. Restarting Docker Compose services...")
result = self._run_command([
'docker', 'compose',
'-f', self.compose_file,
'restart'
])
if isinstance(result, subprocess.CalledProcessError):
print("❌ Failed to restart services")
return False
print("\n2. Waiting for services to be ready...")
time.sleep(5)
print("\n3. Checking service status...")
self._run_command(['docker', 'compose', 'ps'])
print("\n4. Restarting frontend dev server...")
self._stop_frontend(silent=True)
if not self._start_frontend():
print("\n⚠ Warning: Frontend failed to start, but Docker services are running")
print("\n✅ Services restarted successfully!")
print(f"\nEnvironment: {self.environment}")
print("Frontend: http://localhost:8888")
print("Backend API: http://localhost:9380")
return True
def status(self):
"""Show service status"""
print("=" * 60)
print("RAGFlow Services Status")
print("=" * 60)
print("\n1. Docker Compose services:")
self._run_command(['docker', 'compose', 'ps'], check=False)
print("\n2. Current environment configuration:")
if os.path.exists(self.env_file):
with open(self.env_file, 'r', encoding='utf-8') as f:
for line in f:
if line.startswith('ENVIRONMENT='):
print(f" {line.strip()}")
break
else:
print(" ENVIRONMENT not set (defaults to dev)")
print("\n3. Service health check:")
try:
import requests
response = requests.get('http://localhost:9380/api/v1/system/version', timeout=3)
if response.status_code == 200:
version = response.json().get('data', 'unknown')
print(f" ✓ Backend API: running (version {version})")
else:
print(f" ✗ Backend API: unhealthy (status {response.status_code})")
except Exception as e:
print(f" ✗ Backend API: not accessible ({e})")
try:
import requests
response = requests.get('http://localhost:8888', timeout=3)
if response.status_code == 200:
print(f" ✓ Frontend: running")
else:
print(f" ⚠ Frontend: status {response.status_code}")
except Exception as e:
print(f" ✗ Frontend: not accessible ({e})")
frontend_running = False
if os.path.exists(self.frontend_pid_file):
try:
with open(self.frontend_pid_file, 'r') as f:
pid = int(f.read().strip())
if psutil.pid_exists(pid):
frontend_running = True
print(f" Frontend process: PID {pid}")
except:
pass
if not frontend_running:
print(f" Frontend process: not found (PID file missing)")
return True
def main():
parser = argparse.ArgumentParser(
description='RAGFlow Service Management',
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
python scripts/manage_services.py start # Start with dev environment (default)
python scripts/manage_services.py start prod # Start with prod environment
python scripts/manage_services.py restart test # Restart with test environment
python scripts/manage_services.py stop # Stop all services
python scripts/manage_services.py status # Show service status
"""
)
parser.add_argument(
'action',
choices=['start', 'stop', 'restart', 'status'],
help='Action to perform'
)
parser.add_argument(
'environment',
nargs='?',
default='dev',
choices=['dev', 'test', 'prod'],
help='Environment to use (default: dev)'
)
args = parser.parse_args()
if args.action in ['start', 'restart']:
if args.environment not in ['dev', 'test', 'prod']:
print(f"Error: Invalid environment '{args.environment}'")
print("Valid environments: dev, test, prod")
sys.exit(1)
manager = RAGFlowServiceManager(args.environment)
try:
if args.action == 'start':
success = manager.start()
elif args.action == 'stop':
success = manager.stop()
elif args.action == 'restart':
success = manager.restart()
elif args.action == 'status':
success = manager.status()
else:
print(f"Unknown action: {args.action}")
success = False
sys.exit(0 if success else 1)
except KeyboardInterrupt:
print("\n\nOperation cancelled by user")
sys.exit(1)
except Exception as e:
print(f"\n❌ Error: {e}")
import traceback
traceback.print_exc()
sys.exit(1)
if __name__ == '__main__':
main()
#!/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
"""
Script to set up default ASR and TTS models for existing tenants.
This script updates all existing tenants in the database to use the default
ASR (Whisper) and TTS (CosyVoice) models configured in service_conf.yaml.
Usage:
python3 scripts/setup_default_asr_tts.py [--dry-run]
"""
import argparse
import sys
import os
# Add project root to path
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from api.db.db_models import Tenant
from api.db.joint_services.default_models_setup import setup_asr_model, setup_tts_model
def setup_all_tenants(dry_run: bool = False):
"""Set up default ASR/TTS models for all tenants."""
print("=" * 60)
print("Setting up default ASR/TTS models for existing tenants")
print("=" * 60)
tenants = Tenant.select()
total = tenants.count()
if total == 0:
print("No tenants found in database.")
return
print(f"Found {total} tenant(s)")
print()
for i, tenant in enumerate(tenants, 1):
print(f"[{i}/{total}] Processing tenant: {tenant.name} (ID: {tenant.id})")
if dry_run:
print(" [DRY RUN] Would set up ASR model")
print(" [DRY RUN] Would set up TTS model")
else:
asr_result = setup_asr_model(tenant.id)
if asr_result.get("success"):
print(f" ✓ ASR model: {asr_result.get('model', 'N/A')}")
else:
print(f" ✗ ASR model failed: {asr_result.get('message', 'Unknown error')}")
tts_result = setup_tts_model(tenant.id)
if tts_result.get("success"):
print(f" ✓ TTS model: {tts_result.get('model', 'N/A')}")
else:
print(f" ✗ TTS model failed: {tts_result.get('message', 'Unknown error')}")
print()
print("=" * 60)
print("Done!")
print("=" * 60)
def main():
parser = argparse.ArgumentParser(
description="Set up default ASR/TTS models for existing tenants"
)
parser.add_argument(
"--dry-run",
action="store_true",
help="Show what would be done without making changes"
)
args = parser.parse_args()
setup_all_tenants(dry_run=args.dry_run)
if __name__ == "__main__":
main()
......@@ -70,8 +70,12 @@ const fetchDocumentImage = (url: string, authorization: string) => {
return response.blob();
})
.then((blob) => {
if (blob.type.startsWith('image/')) {
item.objectUrl = URL.createObjectURL(blob);
return item.objectUrl;
} else {
throw new Error('Response is not an image');
}
})
.catch((error) => {
imageCache.delete(cacheKey);
......@@ -218,13 +222,23 @@ const Image = React.forwardRef<HTMLImageElement, IImage>(function Image(
ref,
) {
const src = useDocumentImageUrl(id, t);
const imageElement = (
const imageElement = src ? (
<img
{...props}
ref={ref}
src={src || undefined}
src={src}
className={classNames('max-w-[45vw] max-h-[40wh] block', className)}
/>
) : (
<div
className={classNames(
'max-w-[45vw] max-h-[40wh] block bg-gray-100 flex items-center justify-center text-gray-400 text-sm',
className
)}
>
Image not available
</div>
);
if (!label) {
......
......@@ -30,6 +30,10 @@ import { parseModelValue } from '@/utils/llm-util';
import { CircleQuestionMark } from 'lucide-react';
import { useCallback, useMemo } from 'react';
// Flag to control whether ASR/TTS settings are visible in the UI
// When true, ASR and TTS model selectors are hidden and use default values
const HIDE_ASR_TTS_SETTINGS = true;
interface ModelFieldItemProps {
id: string;
label: string;
......@@ -100,7 +104,7 @@ function SystemSetting() {
);
const llmList = useMemo(() => {
return [
const fields = [
{
id: 'llm_id',
label: t('chatModel'),
......@@ -120,25 +124,33 @@ function SystemSetting() {
value: defaultModelDictionary.img2txt_id ?? '',
tooltip: t('img2txtModelTip'),
},
{
id: 'asr_id',
label: t('sequence2txtModel'),
value: defaultModelDictionary.asr_id ?? '',
tooltip: t('sequence2txtModelTip'),
},
{
id: 'rerank_id',
label: t('rerankModel'),
value: defaultModelDictionary.rerank_id ?? '',
tooltip: t('rerankModelTip'),
},
];
// Only show ASR/TTS settings if not using default configuration
if (!HIDE_ASR_TTS_SETTINGS) {
fields.push(
{
id: 'asr_id',
label: t('sequence2txtModel'),
value: defaultModelDictionary.asr_id ?? '',
tooltip: t('sequence2txtModelTip'),
},
{
id: 'tts_id',
label: t('ttsModel'),
value: defaultModelDictionary.tts_id ?? '',
tooltip: t('ttsModelTip'),
},
];
}
);
}
return fields;
}, [defaultModelDictionary, t]);
return (
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑!
请 注册 或者 后发表评论