知识库

Ragflow技术栈分析及二次开发指南

2025 年 3 月 28 日

Ragflow技术栈深度解析与优化实践，助力团队化部署大模型+RAG。核心内容： 1. Ragflow现存问题及其解决方案 2. Ragflow开源协议详解 3. 容器组件与前后端框架的技术剖析

❝
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，代码分好几部分，具体内容如下：

agent：对应前端agent相关模块功能
agentic_reasoning：对应前端搜索相关模块功能
api：核心后端程序，用来与前端进行数据对接，并提供后端服务和其它各组件连接及数据交互功能
deepdoc：提供文件ocr等解析相关功能
graphrag：知识图谱相关功能
rag：主要用以和大模型相关接口进行交互
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，起初看起来有些费力。不过技术是相通的，慢慢看就能逐渐理解。这个系统代码规范性做的很好，即使拿来学习，也是一份不错的材料。

立即咨询 JOTO

JOTO 提供覆盖企业智能体规划与搭建、AI 平台私有化部署、RAG 知识工程、AI 安全治理、FDE 驻场共创及持续运营优化的全周期 AI 落地服务，帮助企业把验证中的 AI 能力转化为安全、可控、可持续迭代的生产力。联系 JOTO 获取 AI 落地咨询

想把这些做法用到你的业务里?

留下你的场景和痛点,我们帮你判断从哪一步开始。

联系我们