❝Ragflow是目前团队化部署大模型+RAG的优质方案，不过其仍不适合直接部署使用，本文将从实际使用的角度，对其进行二次开发。
1. Ragflow 存在问题
Ragflow 开源仓库地址：https://github.com/infiniflow/ragflowRagflow 当前版本： v0.17.0
Ragflow 目前主要存在以下问题：
登录页开放注册
当前版本，在login页面，用户可直接进行注册，在小规模私有化部署中，开放注册接口，易对用户产生困扰，甚至存在被频繁调用攻击的风险。
知识库共享问题
当前版本，团队成员进行知识库共享需要知识库的创建者邀请其它成员进团队，发出邀请时，需要其它成员点击接受才行，较为繁琐。
模型设置问题
当前版本，所有团队成员的模型设置是独立的，如需共用同一套模型配置，需要每个用户单独进行设置，不利于团队化协作。
可视化管理
当前版本，未存在超级管理员的后台界面，无法直观的对用户账户进行可视化管理。
本文将围绕以上四点问题，对Ragflow进行二次开发解决。
2. 开源协议
Ragflow采用的是较为宽松的Apache License 2.0 ，这意味着其允许进行二次开发和商用，且修改后可无需开源。
3. 技术栈分析
3.1 容器组件分析
通过docker启动该服务时，docker-compose-base.yml包含了部分基础配置参数，可以看到整个服务共包含5个容器组件：
services:
es01:
container_name: ragflow-es-01
infinity:
container_name: ragflow-infinity
mysql:
container_name: ragflow-mysql
minio:
container_name: ragflow-minio
redis:
container_name: ragflow-redis
各组件功能如下：
Elasticsearch
主要用作文档引擎，负责存储和检索文本及向量数据，作为系统的知识库存储后端，用以支持向量存储和相似度搜索
ragflow-infinity
前端系统，包含基本的界面显示、数据交互、路由跳转等功能
MySQL
关系型数据库，存储系统的结构化数据，包括管理用户账户、权限等基础信息、存储知识库的元数据信息等
MinIO
对象存储服务，用于存储原始文档及文档切片图像信息
Redis
内存数据库， 采用Valkey版本，缓存大模型的响应结果，处理异步任务，临时保存对话上下文
3.2 前后端框架分析
该系统前端框架使用React+Typescript，代码统一在web文件夹。 后端框架使用Flask+Python，代码分好几部分，具体内容如下：
- agentic_reasoning：对应前端搜索相关模块功能
- api：核心后端程序，用来与前端进行数据对接，并提供后端服务和其它各组件连接及数据交互功能
- sdk：拓展型功能，用来提供系统的外部调用，目前不太完善，可忽略。
3.3 前后端可视化分析
3.3.1 前端可视化分析
前端代码全部集成在web文件夹下，因此可直接在web路径下直接启动查看。
先安装依赖：
yarn instsall
依赖安装完成，生成node_modules再启动：
yarn start
访问http://localhost:9222 即可进入登录界面。
考虑到登录需要和后端交互，密码验证通过后，才能进入主界面。如需直接进入主界面预览，可修改web/src/utils/request.ts： 这里的逻辑是：本来响应结果为504，弹出error，这里直接改成成功响应。
request.interceptors.response.use(async (response: Response, options) => {
if (response?.status === 413 || response?.status === 504) {
// 原代码
// message.error(RetcodeMessage[response?.status as ResultCode]);
// 修改
return new Response(JSON.stringify({
code: 0,
message: 'Success',
data: {}
}));
}
3.3.2 mysql可视化分析
下面再可视化查看其它组件信息，在docker/.env文件中，包含了各组件的密码。
启动docker服务，首先查看mysql数据库信息。
使用DBeaver进行连接，连接参数如下，默认用户名为root，密码为infini_rag_flow。
可以看到，该数据库中包含多张数据表，后续在解决实际问题时，会进一步分析。
3.3.3 Elasticsearch可视化分析
Elasticsearch需要通过Kibana进行可视化分析。虽然.env文件中写了Kibana的初始用户名和密码，但实际服务中，并未启用Kibana。看到仓库中有人提出过该问题，具体可参考该pr：https://github.com/infiniflow/ragflow/pull/548/files
3.3.4 MinIO可视化分析
MinIO自带了可视化管理的控制台，访问http://localhost:9001/即可进入，默认用户名为rag_flow，默认密码为infini_rag_flow。
进入可看见，里面的容器包含了原始上传的pdf文件和切块分页的图像数据。
3.3.5 Redis可视化分析
使用Rdis insight连接Redis数据库，默认地址为127.0.0.1:6379，默认用户名为default，默认密码为infini_rag_flow。
进入可看见，里面存储了一些缓存数据。
4. 问题解决方法
分析完了，开始解决开头提到的一些具体问题。
4.1 关闭注册通道
关闭注册通道，可直接将前端界面上的注册元素注释掉。
具体方法是修改src\pages\login\index.tsx文件，注释掉以下内容：
{ <div>
{title === 'login' && (
<div>
{t('signInTip')}
<Button type="link" onClick={changeTitle}>
{t('signUp')}
</Button>
</div>
)}
{title === 'register' && (
<div>
{t('signUpTip')}
<Button type="link" onClick={changeTitle}>
{t('login')}
</Button>
</div>
)}
</div>}
这样修改，用户直接通过浏览器访问/register也是无法注册的，因为注册功能并不是一个单独界面，而是在login中，post到后端进行处理。
4.2 后台添加用户
阻止用户自己注册之后，管理员还需要为用户进行注册。可直接采用修改数据库内容的方式进行实现。
连接mysql数据库，用户信息存储在user表中。该表包含以下字段，核心字段是email和password。
email比较容易理解，存储的就是登陆明文邮箱，但密码是哈希字符串，为了防止被人攻击泄露，不能存储明文密码，因此，要解决注册问题，首先需要理清楚密码的加密逻辑。
通过仔细阅读源代码，我理清楚了注册阶段，密码的加密存储过程： 首先，前端获取到用户原始输入密码后，先进行Base64编码，防止特殊字符造成解析失败，编码后利用公钥进行RSA加密； 后端接收到加密密码后，利用私钥进行RSA解密，最后通过Hash处理，存储到数据库。
❝A[原始密码] --> B[前端Base64编码] --> C[RSA加密] --> D[后端RSA解密] --> E[hash存储]
为了让这个过程更容易理解，我写了个python代码，模拟了该过程，其中，私钥数据可以在文件中找到，路径为 conf/private.pem：
import base64
from Cryptodome.PublicKey import RSA
from Cryptodome.Cipher import PKCS1_v1_5
from werkzeug.security import generate_password_hash, check_password_hash
def rsa_decrypt(encrypted_password: str, private_key_path: str, passphrase: str) -> str:
# 从文件中读取私钥
with open(private_key_path, "r") as key_file:
private_key = key_file.read()
# 导入私钥
rsa_key = RSA.importKey(private_key, passphrase=passphrase)
cipher = PKCS1_v1_5.new(rsa_key)
# Base64 解码加密数据
encrypted_data = base64.b64decode(encrypted_password)
# 解密数据
decrypted_data = cipher.decrypt(encrypted_data, "Fail to decrypt password!")
# Base64 解码解密后的数据
return base64.b64decode(decrypted_data).decode('utf-8')
def rsa_psw(password: str) -> str:
# 公钥
pub_key = """-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArq9XTUSeYr2+N1h3Afl/z8Dse/2yD0ZGrKwx+EEEcdsBLca9Ynmx3nIB5obmLlSfmskLpBo0UACBmB5rEjBp2Q2f3AG3Hjd4B+gNCG6BDaawuDlgANIhGnaTLrIqWrrcm4EMzJOnAOI1fgzJRsOOUEfaS318Eq9OVO3apEyCCt0lOQK6PuksduOjVxtltDav+guVAA068NrPYmRNabVKRNLJpL8w4D44sfth5RvZ3q9t+6RTArpEtc5sh5ChzvqPOzKGMXW83C95TxmXqpbK6olN4RevSfVjEAgCydH6HN6OhtOQEcnrU97r9H0iZOWwbw3pVrZiUkuRD1R56Wzs2wIDAQAB
-----END PUBLIC KEY-----"""
# 导入公钥
rsa_key = RSA.import_key(pub_key)
cipher = PKCS1_v1_5.new(rsa_key)
# 对密码进行 Base64 编码
password_base64 = base64.b64encode(password.encode('utf-8'))
# 使用 RSA 公钥加密
encrypted_data = cipher.encrypt(password_base64)
# 对加密结果进行 Base64 编码并返回
return base64.b64encode(encrypted_data).decode('utf-8')
if __name__ == "__main__":
# 注册流程
# 1. 获取到用户输入的密码
password = "test"
# 2. Base64编码
base64_password = base64.b64encode(password.encode()).decode()
print("Base64:", base64_password)
# 3. RSA加密
encrypted_password = rsa_psw(base64_password)
print("RSA:", encrypted_password)
# 4. 后端解密(使用private.pem)
private_key_path = "private.pem"# 私钥文件路径
passphrase = "Welcome"# 私钥的密码
decrypted_password = rsa_decrypt(encrypted_password, private_key_path, passphrase)
print("Decrypted:", decrypted_password)
# 5. 生成最终的hash
hash_password = generate_password_hash(decrypted_password)
print("hash_password:", hash_password)
# 登录验证匹配过程
is_match = check_password_hash(hash_password, decrypted_password)
print(is_match)
理解完这一过程之后，就可以通过python脚本插入一条用户数据：
import mysql.connector
import uuid
import base64
from datetime import datetime
from Cryptodome.PublicKey import RSA
from Cryptodome.Cipher import PKCS1_v1_5
from werkzeug.security import generate_password_hash
# 数据库连接配置
db_config = {
"host": "localhost", # 数据库地址
"port": 5455, # 数据库端口
"user": "root", # 数据库用户名
"password": "infini_rag_flow", # 数据库密码
"database": "rag_flow", # 数据库名称
}
# 生成随机的 UUID 作为 id
def generate_uuid():
return str(uuid.uuid4()).replace("-", "")
def rsa_decrypt(encrypted_password: str, private_key_path: str, passphrase: str) -> str:
# 从文件中读取私钥
with open(private_key_path, "r") as key_file:
private_key = key_file.read()
# 导入私钥
rsa_key = RSA.importKey(private_key, passphrase=passphrase)
cipher = PKCS1_v1_5.new(rsa_key)
# Base64 解码加密数据
encrypted_data = base64.b64decode(encrypted_password)
# 解密数据
decrypted_data = cipher.decrypt(encrypted_data, "Fail to decrypt password!")
# Base64 解码解密后的数据
return base64.b64decode(decrypted_data).decode('utf-8')
def encrypt_password(raw_password: str) -> str:
# 1. Base64编码
base64_password = base64.b64encode(raw_password.encode()).decode()
# 2. RSA加密
encrypted_password = rsa_psw(base64_password)
# 3. 后端解密(使用private.pem)
private_key_path = "private.pem"# 私钥文件路径
passphrase = "Welcome"# 私钥的密码
decrypted_password = rsa_decrypt(encrypted_password, private_key_path, passphrase)
# 4. 生成最终的hash
return generate_password_hash(decrypted_password)
# RSA 加密密码
def rsa_psw(password: str) -> str:
pub_key = """-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArq9XTUSeYr2+N1h3Afl/z8Dse/2yD0ZGrKwx+EEEcdsBLca9Ynmx3nIB5obmLlSfmskLpBo0UACBmB5rEjBp2Q2f3AG3Hjd4B+gNCG6BDaawuDlgANIhGnaTLrIqWrrcm4EMzJOnAOI1fgzJRsOOUEfaS318Eq9OVO3apEyCCt0lOQK6PuksduOjVxtltDav+guVAA068NrPYmRNabVKRNLJpL8w4D44sfth5RvZ3q9t+6RTArpEtc5sh5ChzvqPOzKGMXW83C95TxmXqpbK6olN4RevSfVjEAgCydH6HN6OhtOQEcnrU97r9H0iZOWwbw3pVrZiUkuRD1R56Wzs2wIDAQAB
-----END PUBLIC KEY-----"""
rsa_key = RSA.import_key(pub_key)
cipher = PKCS1_v1_5.new(rsa_key)
encrypted_data = cipher.encrypt(base64.b64encode(password.encode()))
return base64.b64encode(encrypted_data).decode()
if __name__ == '__main__':
# 插入数据的 SQL 语句
insert_query = """
INSERT INTO user (
id, create_time, create_date, update_time, update_date, access_token,
nickname, password, email, avatar, language, color_schema, timezone,
last_login_time, is_authenticated, is_active, is_anonymous, login_channel,
status, is_superuser
) VALUES (
%s, %s, %s, %s, %s, %s,
%s, %s, %s, %s, %s, %s, %s,
%s, %s, %s, %s, %s,
%s, %s
)
"""
# 对密码进行加密
raw_password = "123"# 原始密码
hash_encrypted = encrypt_password(raw_password)
# 学号
student_id = "123456789"
student_email = student_id + "@xidian.cn"
# 数据值
data = (
generate_uuid(), # id
1741361741738, # create_time
datetime.strptime("2025-03-07 23:35:41", "%Y-%m-%d %H:%M:%S"), # create_date
1741416354403, # update_time
datetime.strptime("2025-03-08 14:45:54", "%Y-%m-%d %H:%M:%S"), # update_date
None, # access_token (默认为空)
student_id, # nickname
hash_encrypted, # password
student_email, # email
None, # avatar (默认为空)
"Chinese", # language
"Bright", # color_schema
"UTC+8 Asia/Shanghai", # timezone
datetime.strptime("2025-03-07 23:35:41", "%Y-%m-%d %H:%M:%S"), # last_login_time
1, # is_authenticated
1, # is_active
0, # is_anonymous
"password", # login_channel
1, # status
0, # is_superuser
)
# 连接数据库并插入数据
try:
# 建立数据库连接
conn = mysql.connector.connect(**db_config)
cursor = conn.cursor()
# 执行插入操作
cursor.execute(insert_query, data)
conn.commit() # 提交事务
print("数据插入成功！")
except mysql.connector.Error as err:
print(f"数据库错误: {err}")
finally:
# 关闭连接
if conn.is_connected():
cursor.close()
conn.close()
print("数据库连接已关闭。")
注：这段代码实际上，可以再进行优化，获取到密码后，未涉及前后端传输，可以直接将base64编码的密码进行哈希操作，而省略RSA步骤。
4.3 设置用户模型
添加完用户，下面要设置用户模型配置。 模型配置涉及到tenant和tenant_llm两张数据表。
tenant记录了每个用户的模型配置，对应前端界面如下：
tenant_llm记录了每个模型的基本信息，对应前端界面如下：
具体插入操作，后续将和用户团队表格一块进行更新。
4.4 设置用户团队
用户团队涉及的表格名为user_tenant。 设置用户团队需要插入两条记录，首先，用户自己注册时，单独有一个自己的团队，这样方便用户可以后续再组小团体。其次，需要将新用户的团队记录插入到老用户底下。
结合4.2、4.3、4.4的内容，一次性批量插入用户的脚本如下：
import mysql.connector
import uuid
import base64
import json
from datetime import datetime
from Cryptodome.PublicKey import RSA
from Cryptodome.Cipher import PKCS1_v1_5
from werkzeug.security import generate_password_hash
# 数据库连接配置
db_config = {
"host": "localhost",
"port": 5455,
"user": "root",
"password": "infini_rag_flow",
"database": "rag_flow",
}
# 生成随机的 UUID 作为 id
def generate_uuid():
return str(uuid.uuid4()).replace("-", "")
# RSA 加密密码
def rsa_psw(password: str) -> str:
pub_key = """-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArq9XTUSeYr2+N1h3Afl/z8Dse/2yD0ZGrKwx+EEEcdsBLca9Ynmx3nIB5obmLlSfmskLpBo0UACBmB5rEjBp2Q2f3AG3Hjd4B+gNCG6BDaawuDlgANIhGnaTLrIqWrrcm4EMzJOnAOI1fgzJRsOOUEfaS318Eq9OVO3apEyCCt0lOQK6PuksduOjVxtltDav+guVAA068NrPYmRNabVKRNLJpL8w4D44sfth5RvZ3q9t+6RTArpEtc5sh5ChzvqPOzKGMXW83C95TxmXqpbK6olN4RevSfVjEAgCydH6HN6OhtOQEcnrU97r9H0iZOWwbw3pVrZiUkuRD1R56Wzs2wIDAQAB
-----END PUBLIC KEY-----"""
rsa_key = RSA.import_key(pub_key)
cipher = PKCS1_v1_5.new(rsa_key)
encrypted_data = cipher.encrypt(base64.b64encode(password.encode()))
return base64.b64encode(encrypted_data).decode()
# 加密密码
def encrypt_password(raw_password: str) -> str:
base64_password = base64.b64encode(raw_password.encode()).decode()
encrypted_password = rsa_psw(base64_password)
return generate_password_hash(base64_password)
# 处理批量注册
def batch_register_students():
# 从 JSON 文件加载学生数据
with open("add.json", "r", encoding="utf-8") as json_file:
student_groups = json.load(json_file)
try:
# 建立数据库连接
conn = mysql.connector.connect(**db_config)
cursor = conn.cursor()
for group in student_groups:
tenant_id = group["tenant_id"]
student_ids = group["student_id"]
for student_id in student_ids:
# 生成 ID 和时间戳
user_id = generate_uuid()
create_time = 1741361741738
create_date = datetime.strptime("2025-03-07 23:35:41", "%Y-%m-%d %H:%M:%S")
update_time = 1741416354403
update_date = datetime.strptime("2025-03-08 14:45:54", "%Y-%m-%d %H:%M:%S")
# 用户信息
student_email = student_id + "@xidian.cn"
raw_password = student_id
hash_encrypted = encrypt_password(raw_password)
# 插入 user 表数据
user_insert_query = """
INSERT INTO user (
id, create_time, create_date, update_time, update_date, access_token,
nickname, password, email, avatar, language, color_schema, timezone,
last_login_time, is_authenticated, is_active, is_anonymous, login_channel,
status, is_superuser
) VALUES (
%s, %s, %s, %s, %s, %s,
%s, %s, %s, %s, %s, %s, %s,
%s, %s, %s, %s, %s,
%s, %s
)
"""
user_data = (
user_id, create_time, create_date, update_time, update_date, None,
student_id, hash_encrypted, student_email, None, "Chinese", "Bright", "UTC+8 Asia/Shanghai",
create_date, 1, 1, 0, "password",
1, 0
)
cursor.execute(user_insert_query, user_data)
# 插入 tenant 表数据
tenant_insert_query = """
INSERT INTO tenant (
id, create_time, create_date, update_time, update_date, name,
public_key, llm_id, embd_id, asr_id, img2txt_id, rerank_id, tts_id,
parser_ids, credit, status
) VALUES (
%s, %s, %s, %s, %s, %s,
%s, %s, %s, %s, %s, %s, %s,
%s, %s, %s
)
"""
tenant_data = (
user_id, create_time, create_date, update_time, update_date, student_id + "'s Kingdom",
None, "deepseek-r1:1.5b@Ollama", "BAAI/bge-large-zh-v1.5@BAAI", "", "", "", None,
"naive:General,qa:Q&A,resume:Resume,manual:Manual,table:Table,paper:Paper,book:Book,laws:Laws,presentation:Presentation,picture:Picture,one:One,audio:Audio,email:Email,tag:Tag",
512, 1
)
cursor.execute(tenant_insert_query, tenant_data)
# 插入 user_tenant 表的第一条记录
user_tenant_insert_query = """
INSERT INTO user_tenant (
id, create_time, create_date, update_time, update_date, user_id,
tenant_id, role, invited_by, status
) VALUES (
%s, %s, %s, %s, %s, %s,
%s, %s, %s, %s
)
"""
user_tenant_data_owner = (
generate_uuid(), create_time, create_date, update_time, update_date, user_id,
user_id, "owner", user_id, 1
)
cursor.execute(user_tenant_insert_query, user_tenant_data_owner)
# 插入 user_tenant 表的第二条记录
user_tenant_data_normal = (
generate_uuid(), create_time, create_date, update_time, update_date, user_id,
tenant_id, "normal", tenant_id, 1
)
cursor.execute(user_tenant_insert_query, user_tenant_data_normal)
# 插入 tenant_llm 表数据
tenant_llm_insert_query = """
INSERT INTO tenant_llm (
create_time, create_date, update_time, update_date, tenant_id,
llm_factory, model_type, llm_name, api_key, api_base, max_tokens, used_tokens
) VALUES (
%s, %s, %s, %s, %s,
%s, %s, %s, %s, %s, %s, %s
)
"""
tenant_llm_data = (
create_time, create_date, update_time, update_date, user_id,
"Ollama", "chat", "deepseek-r1:1.5b", "xxxxxxxxxxxxxxx", "http://10.195.140.47:11434", 88888888, 0
)
cursor.execute(tenant_llm_insert_query, tenant_llm_data)
# 提交事务
conn.commit()
print("批量用户数据添加成功！")
except mysql.connector.Error as err:
print(f"数据库错误: {err}")
finally:
if conn.is_connected():
cursor.close()
conn.close()
print("数据库连接已关闭。")
if __name__ == '__main__':
batch_register_students()
这里我将需要插入的用户写在json文件中，格式示例如下：
[
{
"student_id": [
"123456789",
"1234567810"
],
"tenant_id": "d3de1596fb6911efa0f40242ac120006"
}
]
student_id为需要插入的用户学号，密码默认和id一致，tenant_id对应的是团队队长的id，即需要共享数据库用户的id。代码中，模型名用的是deepseek-r1:1.5b型号的测试模型，如需配置其它型号，对应修改名称即可。
4.5 其它外观修改
主要问题已全部解决。最后，再进行一些外观上的调整。
1.移除Agent菜单
Agent目前比较复杂，也不实用。可以考虑移除。 具体修改方式是修改web\src\layouts\components\header\index.tsx，注释以下内容：
{ path: '/flow', name: t('flow'), icon: GraphIcon },
2.移除登陆页描述
登录页描述有点花哨，进行移除。 修改web\src\pages\login\right-panel.tsx，注释以下内容：
<Text className={classNames(styles.pink, styles.loginDescription)}>
{t('description')}
</Text>
<Flex align="center" gap={16}>
<Avatars></Avatars>
<Flex vertical>
<Space>
<Rate disabled defaultValue={5} />
<span
className={classNames(styles.white, styles.loginRateNumber)}
>
5.0
</span>
</Space>
<span className={classNames(styles.pink, styles.loginRateReviews)}>
{t('review')}
</span>
</Flex>
</Flex> }
3.修改用户默认头像
用户默认头像文件位置在web\src\layouts\components\user\index.tsx，可将https://zos.alipayobjects.com/rmsportal/jkjgkEfvpUPVyRjUImniVslZfWPnJuuZ.png修改为其它图像超链接，例如：https://picx.zhimg.com/v2-aaf12b68b54b8812e6b449e7368d30cf_l.jpg。
5. 前端修改文件上传
对于前端修改的文件，在docker里修改也不会生效。
观察docker/nginx/ragflow.conf文件，不难发现，网页默认的访问的root路径为 /ragflow/web/dist。
因此，需要让前端修改内容生效，需要先将web文件进行打包。
进入到web路径下，执行
npm run build
执行完之后，会在同级目录下生成dist文件。
进入到容器，删除容器中已有的/ragflow/web/dist文件
docker exec -it ragflow-server /bin/sh
rm -rf /ragflow/web/dist
将本地新生成的打包文件上传到容器：
docker cp dist ragflow-server:/ragflow/web/
重启容器，即可看到修改效果。
总结
作为高度团队协作的产品，ragflow用到的技术挺多。在此之前，我没接触过react和typescript，起初看起来有些费力。不过技术是相通的，慢慢看就能逐渐理解。这个系统代码规范性做的很好，即使拿来学习，也是一份不错的材料。
粤ICP备14082021号
免费POC，
零成本试错
