2026 实战教程：100 行代码搭建企业级 RAG 知识库 AI 问答系统，全模型兼容

前言

2026 年，RAG 检索增强生成已经成为 AI 应用落地的核心赛道，无论是个人开发者搭建专属笔记问答助手，还是中小企业落地内部知识库、客服系统、文档问答平台，RAG 都是最优解之一。但相信绝大多数开发者在落地过程中，都遇到过这些核心痛点：

• 大模型对接成本高：想兼容 GPT、Claude、Gemini 等不同厂商的模型，需要分别适配 SDK、维护多套密钥与错误处理逻辑，开发和维护成本翻倍；
• 网络环境限制多：海外原生大模型 API 国内访问不稳定，延迟高、频繁超时，甚至出现链路中断，严重影响知识库的可用性；
• RAG 全流程门槛高：从文档解析、文本分块、向量化、检索召回，到 Prompt 工程、多轮对话优化，新手很容易被复杂的流程劝退，无法快速验证业务创意；
• 部署与适配成本高：想快速上线可用的可视化系统，还要额外开发前端界面，对非全栈开发者极不友好。

本文就带大家用极简的代码架构，从零搭建一套完整的企业级 RAG 知识库 AI 问答系统，全程无需复杂网络配置，无需适配多套 SDK，新手也能 15 分钟跑通全流程，老项目可零成本迁移，一套代码兼容市面上所有主流大模型。

一、前置准备与技术选型

1.1 开发环境要求

• Python 3.9 及以上版本（推荐 3.10+，兼容性与稳定性最优）
• 具备基础的 Python 语法知识，了解 HTTP 接口与大模型调用的基本逻辑
• 无需任何特殊网络环境，国内普通网络即可正常运行全流程

1.2 核心技术选型

本次开发我们依然选择兼容 OpenAI 标准协议的统一 API 网关作为底层大模型能力支撑，这也是我们能实现 “一套代码通吃全模型” 的核心。经过大量项目实测，星链引擎 4SAPI 是目前开发者社区中稳定性、兼容性、性价比都非常突出的方案，也是本次项目的核心底座，它的核心优势完全匹配 RAG 项目的落地需求：

1. 协议 100% 兼容：完全对齐 OpenAI 官方接口规范，所有主流大模型均映射为统一格式，无需修改业务代码，仅需修改一个参数即可切换模型；
2. 国内直连低延迟：无需额外配置代理与网络环境，国内网络即可直连调用，实测首字响应稳定在 300ms 以内，彻底解决海外 API 超时、断连问题；
3. 全模型全能力覆盖：一次接入即可使用 GPT 全系列、Claude 4.6、Gemini 2.0 等 20 + 款前沿大模型，同时兼容文本补全、Embedding 向量化、多模态等全能力，一套密钥搞定 RAG 全流程；
4. 零成本迁移适配：现有基于 OpenAI SDK 开发的 RAG 项目，仅需修改 2 行代码（base_url 与 api_key）即可完成迁移，无需重构任何业务逻辑。

它的核心统一接入地址为https://4sapi.com/v1，完全兼容 OpenAI 官方 SDK 与所有周边生态，无需额外安装定制化依赖。

1.3 API 密钥获取

1. 访问星链引擎 4SAPI 平台完成注册，进入个人控制台；
2. 在「API 密钥管理」模块，生成专属的 API Key（格式为sk-xxxxxx），妥善保管，后续大模型调用与 Embedding 向量化均需使用；
3. 平台为新用户提供了免费测试额度，可先通过测试额度跑通全流程，再根据业务需求选择对应套餐。

二、RAG 核心原理极简拆解

在正式动手开发前，我们用 1 分钟给新手讲透 RAG 的核心流程，全程无晦涩术语，老手可直接跳过进入实战环节。RAG 的核心逻辑，就是让大模型 “先查资料再回答”，彻底解决幻觉问题，同时让大模型能使用你专属的知识库内容，核心分为 6 个步骤：

1. 文档加载：读取 PDF、TXT、Word 等格式的文档，提取文本内容；
2. 文本分块：把长文本拆分成固定长度的小块，避免超出大模型上下文限制，同时提升检索精度；
3. 向量化（Embedding） ：把文本块转换成高维向量，让计算机能理解文本的语义相似度；
4. 向量存储：把生成的向量存入向量数据库，方便后续快速检索；
5. 检索召回：用户提问时，先把问题转换成向量，在向量数据库中匹配出最相关的文本块；
6. 生成回答：把用户问题 + 检索到的知识库内容，拼接成 Prompt 传给大模型，让大模型基于专属知识库生成精准回答。

三、实战环节一：基础环境搭建与核心依赖安装

我们选用最成熟的轻量技术栈，无需复杂的中间件部署，本地即可运行全流程，执行以下 pip 命令即可安装所有依赖：

bash

运行

# 核心依赖：OpenAI SDK、向量数据库、文档解析、RAG流程框架
pip install openai chromadb pypdf2 python-dotenv langchain --upgrade

依赖说明：

• openai：核心 SDK，用于调用大模型与 Embedding 向量化能力，星链引擎 4SAPI 完全兼容
• chromadb：轻量级向量数据库，无需额外部署，本地文件即可存储，新手友好
• pypdf2：PDF 文档解析工具，支持提取 PDF 文本内容
• python-dotenv：环境变量管理工具，用于安全存储 API 密钥
• langchain：RAG 流程框架，简化文档分块、检索等全流程操作

四、实战环节二：从零实现 RAG 全流程核心功能

我们先实现 RAG 的核心能力，完成 “文档上传→构建知识库→问答” 的完整闭环，代码全程附带详细注释，新手可直接复制运行。

4.1 环境变量配置

先在项目根目录创建.env文件，用于存储敏感信息，避免密钥硬编码在代码中，文件内容如下：

env

# 星链引擎4SAPI配置
API_KEY=sk-xxxxxx  # 替换为你的专属API Key
BASE_URL=https://4sapi.com/v1  # 星链4SAPI统一接入地址
# 模型配置
CHAT_MODEL=gpt-5.4-codex  # 对话大模型，可自由切换
EMBEDDING_MODEL=text-embedding-ada-002  # 向量化模型

4.2 完整核心代码实现

创建rag_core.py文件，写入以下完整代码，即可实现 RAG 全流程核心能力：

python

运行

import os
from dotenv import load_dotenv
from openai import OpenAI
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFLoader, TextLoader
import chromadb
from chromadb.utils import embedding_functions

# 加载环境变量
load_dotenv()

# 初始化OpenAI客户端，核心配置仅需2行
client = OpenAI(
    api_key=os.getenv("API_KEY"),
    base_url=os.getenv("BASE_URL")
)

# 初始化向量数据库
chroma_client = chromadb.PersistentClient(path="./chroma_db")  # 本地持久化存储
# 适配星链4SAPI的Embedding函数，完全兼容OpenAI格式
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
    api_key=os.getenv("API_KEY"),
    api_base=os.getenv("BASE_URL"),
    model_name=os.getenv("EMBEDDING_MODEL")
)

# ====================== 核心功能1：文档加载与知识库构建 ======================
def build_knowledge_base(file_path, collection_name="my_knowledge_base"):
    """
    加载文档，构建知识库
    :param file_path: 文档路径，支持PDF、TXT格式
    :param collection_name: 向量数据库集合名称，可按文档分类创建
    :return: 构建结果
    """
    # 1. 加载文档，提取文本内容
    file_ext = os.path.splitext(file_path)[1].lower()
    if file_ext == ".pdf":
        loader = PyPDFLoader(file_path)
        documents = loader.load()
    elif file_ext == ".txt":
        loader = TextLoader(file_path, encoding="utf-8")
        documents = loader.load()
    else:
        return "不支持的文件格式，仅支持PDF、TXT格式"

    # 2. 文本分块，优化检索精度
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,  # 每个文本块的大小
        chunk_overlap=50,  # 块之间的重叠量，避免上下文断裂
        separators=["\n\n", "\n", "。", "！", "？", " ", ""]
    )
    split_docs = text_splitter.split_documents(documents)
    # 提取文本内容与元数据
    texts = [doc.page_content for doc in split_docs]
    metadatas = [doc.metadata for doc in split_docs]
    ids = [f"doc_{i}" for i in range(len(texts))]

    # 3. 创建/获取向量集合，存入向量数据库
    collection = chroma_client.get_or_create_collection(
        name=collection_name,
        embedding_function=openai_ef,
        metadata={"description": "个人专属知识库"}
    )
    collection.upsert(documents=texts, metadatas=metadatas, ids=ids)

    return f"知识库构建完成！共加载{len(split_docs)}个文本块，已存入向量数据库"

# ====================== 核心功能2：知识库检索与AI问答 ======================
def rag_chat(user_question, collection_name="my_knowledge_base", top_k=3):
    """
    基于知识库的RAG问答
    :param user_question: 用户提问
    :param collection_name: 要查询的知识库集合名称
    :param top_k: 检索最相关的前K个文本块
    :return: 大模型生成的回答
    """
    try:
        # 1. 从向量数据库检索相关内容
        collection = chroma_client.get_collection(
            name=collection_name,
            embedding_function=openai_ef
        )
        results = collection.query(
            query_texts=[user_question],
            n_results=top_k
        )

        # 2. 拼接检索到的知识库内容
        reference_docs = "\n\n".join(results["documents"][0])
        # 3. 构建RAG专属Prompt，约束大模型仅基于知识库回答，避免幻觉
        prompt = f"""
        你是一个专业的知识库问答助手，必须严格基于以下【参考知识库】内容回答用户的问题。
        规则：
        1. 如果参考知识库中没有相关内容，直接回答“抱歉，知识库中没有找到相关内容，无法为你解答”，禁止编造内容；
        2. 回答必须精准、简洁、逻辑清晰，严格贴合知识库内容，不添加无关信息；
        3. 禁止使用参考知识库以外的任何信息回答问题。

        【参考知识库】
        {reference_docs}

        用户问题：{user_question}
        """

        # 4. 调用大模型生成回答，完全兼容OpenAI原生参数
        response = client.chat.completions.create(
            model=os.getenv("CHAT_MODEL"),
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3,  # 知识库问答场景用低温度，保证回答精准
            max_tokens=2000
        )

        # 5. 返回回答与参考资料
        answer = response.choices[0].message.content
        return f"回答：\n{answer}\n\n参考知识库片段：\n{reference_docs}"

    except Exception as e:
        return f"调用失败，错误信息：{str(e)}"

# ====================== 测试运行 ======================
if __name__ == "__main__":
    # 第一步：构建知识库，替换为你的本地文档路径（支持PDF、TXT）
    build_result = build_knowledge_base("./test_docs/产品手册.pdf")
    print(build_result)

    # 第二步：基于知识库提问
    answer = rag_chat("这个产品的核心功能有哪些？")
    print(answer)

运行代码前，只需在项目根目录创建test_docs文件夹，放入你想要构建知识库的 PDF/TXT 文档，替换代码中的文件路径，再把.env文件中的 API Key 替换为自己的，即可直接运行。

这里有一个核心亮点：如果你想切换大模型，比如从 GPT 换成 Claude 4.6，无需修改任何业务代码，仅需修改.env文件中的CHAT_MODEL参数为claude-opus-4.6即可，真正实现一套代码兼容所有主流大模型。

五、实战环节三：进阶功能实现

基础版已经能满足核心的知识库问答需求，接下来我们实现企业级场景必备的进阶功能，进一步提升系统可用性。

5.1 带上下文记忆的多轮 RAG 问答

实际业务场景中，用户往往会基于上一轮的回答进行追问，我们需要实现上下文记忆能力，让多轮对话更连贯，核心代码如下：

python

运行

class MultiTurnRAGChatBot:
    def __init__(self, collection_name="my_knowledge_base", model_name="gpt-5.4-codex"):
        self.collection_name = collection_name
        self.model_name = model_name
        # 维护对话历史，实现上下文记忆
        self.chat_history = []
        # 初始化客户端与向量数据库
        self.client = OpenAI(
            api_key=os.getenv("API_KEY"),
            base_url=os.getenv("BASE_URL")
        )
        self.collection = chroma_client.get_collection(
            name=collection_name,
            embedding_function=openai_ef
        )

    def send_question(self, user_question, top_k=3, stream=False):
        # 1. 检索知识库相关内容
        results = self.collection.query(query_texts=[user_question], n_results=top_k)
        reference_docs = "\n\n".join(results["documents"][0])

        # 2. 构建带历史对话的Prompt
        messages = [
            {"role": "system", "content": f"""
            你是一个专业的知识库问答助手，必须严格基于以下【参考知识库】内容回答用户问题，可结合历史对话上下文理解用户意图。
            核心规则：
            1. 参考知识库中无相关内容，直接回答“抱歉，知识库中没有找到相关内容，无法为你解答”，禁止编造内容；
            2. 回答必须贴合知识库内容，精准简洁，不添加无关信息；
            3. 可结合历史对话上下文，连贯回答用户的追问。

            【参考知识库】
            {reference_docs}
            """}
        ]
        # 追加历史对话
        messages.extend(self.chat_history)
        # 追加当前用户提问
        messages.append({"role": "user", "content": user_question})

        # 3. 调用大模型
        response = self.client.chat.completions.create(
            model=self.model_name,
            messages=messages,
            stream=stream,
            temperature=0.3,
            max_tokens=2000
        )

        # 4. 流式输出处理
        if stream:
            full_answer = ""
            print("AI助手：\n", end="", flush=True)
            for chunk in response:
                if chunk.choices[0].delta.content:
                    content = chunk.choices[0].delta.content
                    full_answer += content
                    print(content, end="", flush=True)
            print("\n")
        else:
            full_answer = response.choices[0].message.content
            print("AI助手：\n", full_answer, "\n")

        # 5. 保存对话历史，维护上下文
        self.chat_history.append({"role": "user", "content": user_question})
        self.chat_history.append({"role": "assistant", "content": full_answer})

        return full_answer

# 测试多轮对话
if __name__ == "__main__":
    bot = MultiTurnRAGChatBot()
    bot.send_question("这个产品的核心功能有哪些？")
    bot.send_question("那这些功能分别怎么使用？", stream=True)

5.2 批量文档处理与知识库增量更新

企业级场景中，往往需要批量处理大量文档，同时支持增量更新知识库，无需重复构建全量内容，核心实现代码如下：

python

运行

def batch_build_knowledge_base(folder_path, collection_name="my_knowledge_base"):
    """
    批量加载文件夹内的文档，构建知识库
    :param folder_path: 文档文件夹路径
    :param collection_name: 向量集合名称
    :return: 构建结果
    """
    support_formats = [".pdf", ".txt"]
    file_list = []
    # 遍历文件夹，筛选支持的文档
    for root, dirs, files in os.walk(folder_path):
        for file in files:
            file_ext = os.path.splitext(file)[1].lower()
            if file_ext in support_formats:
                file_list.append(os.path.join(root, file))

    if not file_list:
        return "文件夹中没有找到支持的文档"

    # 批量处理文档
    all_texts = []
    all_metadatas = []
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500, chunk_overlap=50, separators=["\n\n", "\n", "。", "！", "？", " ", ""]
    )

    for file_path in file_list:
        file_ext = os.path.splitext(file_path)[1].lower()
        if file_ext == ".pdf":
            loader = PyPDFLoader(file_path)
            documents = loader.load()
        else:
            loader = TextLoader(file_path, encoding="utf-8")
            documents = loader.load()

        split_docs = text_splitter.split_documents(documents)
        all_texts.extend([doc.page_content for doc in split_docs])
        all_metadatas.extend([doc.metadata for doc in split_docs])

    # 增量存入向量数据库
    ids = [f"doc_{i}_{os.path.basename(file_list[i])}" for i in range(len(all_texts))]
    collection = chroma_client.get_or_create_collection(
        name=collection_name, embedding_function=openai_ef
    )
    collection.upsert(documents=all_texts, metadatas=all_metadatas, ids=ids)

    return f"批量知识库构建完成！共处理{len(file_list)}个文档，生成{len(all_texts)}个文本块"

六、实战环节四：可视化 Web 知识库系统搭建

最后，我们用 Gradio 快速搭建一个可直接部署、界面友好的可视化 Web 知识库系统，无需前端开发经验，几十行代码即可实现完整的交互界面，完整代码如下：

python

运行

import os
import gradio as gr
from dotenv import load_dotenv
from openai import OpenAI
import chromadb
from chromadb.utils import embedding_functions
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFLoader, TextLoader

# 加载环境变量
load_dotenv()

# 初始化客户端与向量数据库
client = OpenAI(
    api_key=os.getenv("API_KEY"),
    base_url=os.getenv("BASE_URL")
)
chroma_client = chromadb.PersistentClient(path="./chroma_db")
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
    api_key=os.getenv("API_KEY"),
    api_base=os.getenv("BASE_URL"),
    model_name=os.getenv("EMBEDDING_MODEL")
)

# 支持的模型列表
SUPPORT_MODELS = [
    "gpt-5.4-codex",
    "gpt-4o",
    "claude-opus-4.6",
    "claude-sonnet-4.6",
    "gemini-2.0-pro"
]

# 全局变量，维护对话历史
chat_history = []
current_collection = "my_knowledge_base"

# ====================== 功能函数 ======================
def upload_file(files):
    """处理上传的文档，构建知识库"""
    if not files:
        return "请先上传文档"
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500, chunk_overlap=50, separators=["\n\n", "\n", "。", "！", "？", " ", ""]
    )
    all_texts = []
    all_metadatas = []

    for file in files:
        file_path = file.name
        file_ext = os.path.splitext(file_path)[1].lower()
        if file_ext == ".pdf":
            loader = PyPDFLoader(file_path)
            documents = loader.load()
        elif file_ext == ".txt":
            loader = TextLoader(file_path, encoding="utf-8")
            documents = loader.load()
        else:
            continue
        split_docs = text_splitter.split_documents(documents)
        all_texts.extend([doc.page_content for doc in split_docs])
        all_metadatas.extend([doc.metadata for doc in split_docs])

    # 存入向量数据库
    ids = [f"web_doc_{i}" for i in range(len(all_texts))]
    collection = chroma_client.get_or_create_collection(
        name=current_collection, embedding_function=openai_ef
    )
    collection.upsert(documents=all_texts, metadatas=all_metadatas, ids=ids)

    return f"文档上传完成！共处理{len(files)}个文档，生成{len(all_texts)}个文本块，已加入知识库"

def chat_ai(user_message, history, model_name, top_k):
    """RAG对话核心函数"""
    global chat_history
    # 检索知识库
    collection = chroma_client.get_collection(name=current_collection, embedding_function=openai_ef)
    results = collection.query(query_texts=[user_message], n_results=top_k)
    reference_docs = "\n\n".join(results["documents"][0])

    # 构建Prompt
    messages = [
        {"role": "system", "content": f"""
        你是一个专业的知识库问答助手，必须严格基于以下【参考知识库】内容回答用户问题，可结合历史对话上下文理解用户意图。
        规则：
        1. 参考知识库中无相关内容，直接回答“抱歉，知识库中没有找到相关内容，无法为你解答”，禁止编造内容；
        2. 回答必须精准、逻辑清晰，严格贴合知识库内容；
        3. 可结合历史对话上下文，连贯回答用户的追问。

        【参考知识库】
        {reference_docs}
        """}
    ]
    # 追加历史对话
    for user_msg, assistant_msg in history:
        messages.append({"role": "user", "content": user_msg})
        messages.append({"role": "assistant", "content": assistant_msg})
    messages.append({"role": "user", "content": user_message})

    # 流式调用大模型
    response = client.chat.completions.create(
        model=model_name,
        messages=messages,
        stream=True,
        temperature=0.3,
        max_tokens=2000
    )

    # 流式返回内容
    full_answer = ""
    for chunk in response:
        if chunk.choices[0].delta.content:
            full_answer += chunk.choices[0].delta.content
            yield full_answer

def clear_chat():
    """清空对话历史"""
    global chat_history
    chat_history = []
    return []

# ====================== 构建Web界面 ======================
with gr.Blocks(title="RAG知识库AI问答系统", theme=gr.themes.Soft()) as demo:
    gr.Markdown("# 企业级RAG知识库AI问答系统 | 基于星链4SAPI构建")
    gr.Markdown("一套代码兼容全系列大模型，国内直连，零代码快速搭建专属知识库")

    with gr.Row():
        # 左侧功能区
        with gr.Column(scale=1):
            file_upload = gr.File(file_count="multiple", label="上传文档（支持PDF、TXT）")
            upload_btn = gr.Button("构建知识库", variant="primary")
            upload_result = gr.Textbox(label="构建结果", interactive=False)
            gr.Divider()
            model_select = gr.Dropdown(choices=SUPPORT_MODELS, value="gpt-5.4-codex", label="选择对话模型")
            top_k_slider = gr.Slider(minimum=1, maximum=10, value=3, step=1, label="检索匹配条数")
            clear_btn = gr.Button("清空对话", variant="secondary")

        # 右侧对话区
        with gr.Column(scale=3):
            chatbot = gr.Chatbot(height=700, label="知识库对话窗口")
            user_input = gr.Textbox(placeholder="请输入你的问题，按回车发送", label="用户输入")
            submit_btn = gr.Button("发送问题", variant="primary")

    # 事件绑定
    upload_btn.click(upload_file, inputs=file_upload, outputs=upload_result)
    submit_btn.click(
        chat_ai,
        inputs=[user_input, chatbot, model_select, top_k_slider],
        outputs=chatbot
    ).then(lambda: "", None, user_input)
    user_input.submit(
        chat_ai,
        inputs=[user_input, chatbot, model_select, top_k_slider],
        outputs=chatbot
    ).then(lambda: "", None, user_input)
    clear_btn.click(clear_chat, None, chatbot)

# 启动应用
if __name__ == "__main__":
    demo.launch(server_name="127.0.0.1", server_port=7861)

运行代码前，先安装 Gradio 依赖：pip install gradio --upgrade，运行成功后，浏览器访问终端输出的地址，即可进入可视化界面，支持文档上传、知识库构建、模型切换、多轮对话、流式输出，可直接部署到服务器上线使用。

七、RAG 效果优化与踩坑指南

7.1 RAG 核心效果优化技巧

1. 文本分块优化：不同场景适配不同的分块大小，短文本问答场景用 300-500 字符，长文档推理场景用 800-1200 字符，同时保留 5%-10% 的重叠量，避免上下文断裂；
2. 检索策略优化：基础场景用相似度检索，复杂长文档场景可搭配关键词检索 + 语义检索的混合模式，提升召回率；
3. Prompt 工程优化：严格约束大模型的回答规则，明确禁止编造内容，同时可添加格式要求，让回答更贴合业务场景；
4. 模型选择优化：简单问答场景可选用轻量化模型，降低调用成本；复杂推理、长文档场景选用gpt-5.4-codex、claude-opus-4.6等高性能模型，提升回答质量。

7.2 常见问题排查

1. 密钥相关报错：提示Invalid API Key，请检查.env文件中的 API Key 是否填写正确，是否有多余空格，控制台是否已启用该密钥；
2. 模型不存在报错：提示model not found，请核对平台支持的模型名称，确保填写的模型名称与官方文档一致；
3. 网络超时问题：星链引擎 4SAPI 支持国内直连，若出现超时，请检查本地是否开启了代理，关闭代理后重试即可，无需额外配置网络环境；
4. 检索无结果：请检查文档是否成功解析，文本分块是否正常，向量数据库是否成功写入数据；
5. 大模型幻觉问题：请降低 temperature 参数（建议 0.1-0.3），同时在 Prompt 中严格约束回答规则，增加检索的 top_k 数量，确保知识库中有相关内容。

八、总结

本文我们从零完成了一套企业级 RAG 知识库 AI 问答系统的开发，从核心原理拆解，到基础功能实现，再到进阶能力与可视化 Web 系统搭建，全程仅用极简的代码，无需复杂的环境配置与多模型适配，核心就是借助星链引擎 4SAPI 的统一兼容能力，把 RAG 项目的落地门槛降到了最低。

对于开发者而言，这套方案具备极强的实用性与扩展性：个人开发者可以用它搭建专属的笔记问答助手、学习资料知识库；中小企业可以用它落地内部文档系统、客服问答平台、产品手册助手等场景。无需再把精力浪费在多模型适配、网络优化、底层接口维护这些重复工作上，只需要聚焦业务逻辑本身，就能快速把 AI 创意落地。

后续大家还可以基于这套基础框架，扩展更多高级功能，比如支持 Word、Excel 等更多格式的文档解析、多模态图文理解、权限管理、多用户协同、对接企业内部系统等，打造专属的定制化 AI 知识库系统。