企业官网建设流程全解析

Atom-7B-Chat 接入 LangChain 搭建本地知识库助手：从向量库构建到 Gradio Web 部署全流程

【免费下载链接】self-llm《开源大模型食用指南》针对中国宝宝量身打造的基于Linux环境快速微调（全参数/Lora）、部署国内外开源大模型（LLM）/多模态大模型（MLLM）教程项目地址: https://gitcode.com/GitHub_Trending/se/self-llm

导读

本文基于《开源大模型食用指南》项目中 Atom 系列教程，完整演示如何将本地部署的 Atom-7B-Chat 模型接入 LangChain 框架，从零搭建一个可运行的 RAG（检索增强生成）知识库问答助手。文章覆盖知识库语料加载与向量化、自定义 LLM 类封装、RetrievalQA 检索问答链构建以及 Gradio Web Demo 部署四个环节，读者完成后将掌握一套可复用的"开源大模型 + LangChain + 本地知识库"工程化方案。

项目背景与文件结构

在开始之前，先明确本项目在仓库中的位置。Atom-7B-Chat 接入 LangChain 搭建知识库助手的完整代码位于 models/Atom/03-Atom-7B-Chat 接入langchain搭建知识库助手/，该目录下的 readme.md 清晰地说明了三个核心脚本的职责：

三者构成了一个完整的 RAG 应用闭环：creat_db.py负责把本地文档"离线"处理成可检索的向量库，LLM.py解决"如何让 LangChain 调用本地模型"的接入问题，run_gradio.py则把问答能力以 Web 界面的形式提供给用户。此外，同目录下的 03-Atom-7B-Chat 接入langchain搭建知识库助手.md 是配套的完整教程文档，前置的模型部署与环境准备可参考 01-Atom-7B-chat-WebDemo.md。

本文所涉及的代码与教程均面向 Linux 环境（以 AutoDL 云平台的 3090 等 24G 显存机器为例），读者需先完成 Atom-7B-Chat 的本地部署。

环境准备与依赖安装

本教程基于 AutoDL 平台上的 3090 等 24G 显存显卡机器。在创建实例时，镜像选择PyTorch --> 2.0.0 --> 3.8(ubuntu20.04) --> 11.8：

打开 JupyterLab 中的终端，先完成 pip 换源并安装基础依赖：

# 升级pip python -m pip install --upgrade pip # 更换 pypi 源加速库的安装 pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple pip install modelscope==1.9.5 pip install "transformers>=4.32.0" accelerate tiktoken einops scipy transformers_stream_generator==0.0.4 peft deepspeed pip install -U huggingface_hub pip install -i https://test.pypi.org/simple/ bitsandbytes

在已完成 Atom-7B-chat 部署的基础上，接入 LangChain 还需要安装以下依赖：

pip install langchain==0.0.292 pip install gradio==4.4.0 pip install chromadb==0.4.15 pip install sentence-transformers==2.2.2 pip install unstructured==0.10.30 pip install markdown==3.3.7

这些库各自承担明确职责：langchain是应用框架主体，chromadb是向量数据库，sentence-transformers用于加载开源词向量模型，unstructured负责解析 markdown/txt 等非结构化文档，gradio用于构建 Web 界面。

模型与词向量模型下载

下载开源词向量模型

知识库检索需要将文本转换为向量，本教程选用开源词向量模型 Sentence Transformer（paraphrase-multilingual-MiniLM-L12-v2），该模型对中文等多语言支持较好。这里通过 huggingface 镜像将其下载到本地/root/autodl-tmp/embedding_model，也可以选择其它下载方式。

在/root/autodl-tmp路径下新建download.py并写入以下内容，保存后运行python /root/autodl-tmp/download.py：

import os # 设置环境变量 os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com' # 下载模型 os.system('huggingface-cli download --resume-download sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2 --local-dir /root/autodl-tmp/embedding_model')

下载 Atom-7B-Chat 模型

使用modelscope中的snapshot_download函数下载模型，第一个参数为模型名称，参数cache_dir为模型的下载路径。在/root/autodl-tmp路径下新建download.py并写入以下内容，运行python /root/autodl-tmp/download.py执行下载。模型大小约 13 GB，下载耗时约 10~20 分钟：

import torch from modelscope import snapshot_download, AutoModel, AutoTokenizer import os model_dir = snapshot_download('FlagAlpha/Atom-7B-Chat', cache_dir='/root/autodl-tmp', revision='master')

知识库建设：语料加载与向量化

知识库来源

本教程选用以下两个开源仓库作为知识库来源：

• Atom-7B-Chat 模型仓库（FlagAlpha/Atom-7B-Chat）
• Llama2-Chinese 项目仓库

首先将远程开源仓库 Clone 到本地：

# 进入到数据库盘 cd /root/autodl-tmp # 打开学术资源加速 source /etc/network_turbo # clone 开源仓库 git clone https://github.com/FlagAlpha/Llama2-Chinese # 关闭学术资源加速 unset http_proxy && unset https_proxy

为语料处理方便，我们将选用上述仓库中所有的 markdown、txt 文件作为示例语料库。注意，也可以选用其中的代码文件加入知识库，但需要针对代码文件格式进行额外处理。

递归获取语料文件路径

我们定义一个函数，递归遍历指定文件夹路径，返回其中所有满足条件（后缀名为.md或.txt）的文件路径：

import os def get_files(dir_path): # args：dir_path，目标文件夹路径 file_list = [] for filepath, dirnames, filenames in os.walk(dir_path): # os.walk 函数将递归遍历指定文件夹 for filename in filenames: # 通过后缀名判断文件类型是否满足要求 if filename.endswith(".md"): # 如果满足要求，将其绝对路径加入到结果列表 file_list.append(os.path.join(filepath, filename)) elif filename.endswith(".txt"): file_list.append(os.path.join(filepath, filename)) return file_list

加载文件为纯文本对象

得到所有目标文件路径后，使用 LangChain 提供的 FileLoader 对象加载目标文件，得到由目标文件解析出的纯文本内容。由于不同类型的文件需要对应不同的 FileLoader，我们判断目标文件类型并针对性调用对应类型的 FileLoader，同时调用load()方法得到加载后的纯文本对象：

from tqdm import tqdm from langchain.document_loaders import UnstructuredFileLoader from langchain.document_loaders import UnstructuredMarkdownLoader def get_text(dir_path): # args：dir_path，目标文件夹路径 # 首先调用上文定义的函数得到目标文件路径列表 file_lst = get_files(dir_path) # docs 存放加载之后的纯文本对象 docs = [] # 遍历所有目标文件 for one_file in tqdm(file_lst): file_type = one_file.split('.')[-1] if file_type == 'md': loader = UnstructuredMarkdownLoader(one_file) elif file_type == 'txt': loader = UnstructuredFileLoader(one_file) else: # 如果是不符合条件的文件，直接跳过 continue docs.extend(loader.load()) return docs

docs即一个纯文本对象对应的列表。得到该列表后，就可以引入 LangChain 框架构建向量数据库——流程分为两步：先对文本分块，再对文本块进行向量化。

文本分块

LangChain 提供了多种文本分块工具，此处使用字符串递归分割器，分块大小设置为 500，块重叠长度为 150：

from langchain.text_splitter import RecursiveCharacterTextSplitter text_splitter = RecursiveCharacterTextSplitter( chunk_size=500, chunk_overlap=150) split_docs = text_splitter.split_documents(docs)

chunk_size=500控制每个文本块的最大字符数，chunk_overlap=150让相邻块保留 150 字符的重叠，从而缓解"跨块语义被切断"的问题，保证检索时能召回完整上下文。

文本向量化与向量数据库构建

选用开源词向量模型 Sentence Transformer 进行文本向量化。LangChain 提供了直接引入 HuggingFace 开源社区模型的接口：

from langchain.embeddings.huggingface import HuggingFaceEmbeddings embeddings = HuggingFaceEmbeddings(model_name="/root/autodl-tmp/embedding_model")

同时选择 Chroma 作为向量数据库，基于分块后的文档与开源向量化模型，将语料加载到指定路径下的向量数据库：

from langchain.vectorstores import Chroma # 定义持久化路径 persist_directory = 'data_base/vector_db/chroma' # 加载数据库 vectordb = Chroma.from_documents( documents=split_docs, embedding=embeddings, persist_directory=persist_directory # 允许我们将persist_directory目录保存到磁盘上 ) # 将加载的向量数据库持久化到磁盘上 vectordb.persist()

完整的知识库构建脚本

将上述代码整合在一起，就是仓库中 creat_db.py 的完整实现：

# 首先导入所需第三方库 from langchain.document_loaders import UnstructuredFileLoader from langchain.document_loaders import UnstructuredMarkdownLoader from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain.vectorstores import Chroma from langchain.embeddings.huggingface import HuggingFaceEmbeddings from tqdm import tqdm import os import nltk nltk.download('punkt') # 获取文件路径函数 def get_files(dir_path): # args：dir_path，目标文件夹路径 file_list = [] for filepath, dirnames, filenames in os.walk(dir_path): # os.walk 函数将递归遍历指定文件夹 for filename in filenames: # 通过后缀名判断文件类型是否满足要求 if filename.endswith(".md"): # 如果满足要求，将其绝对路径加入到结果列表 file_list.append(os.path.join(filepath, filename)) elif filename.endswith(".txt"): file_list.append(os.path.join(filepath, filename)) return file_list # 加载文件函数 def get_text(dir_path): # args：dir_path，目标文件夹路径 # 首先调用上文定义的函数得到目标文件路径列表 file_lst = get_files(dir_path) # docs 存放加载之后的纯文本对象 docs = [] # 遍历所有目标文件 for one_file in tqdm(file_lst): file_type = one_file.split('.')[-1] if file_type == 'md': loader = UnstructuredMarkdownLoader(one_file) elif file_type == 'txt': loader = UnstructuredFileLoader(one_file) else: # 如果是不符合条件的文件，直接跳过 continue docs.extend(loader.load()) return docs # 目标文件夹 tar_dir = [ "/root/autodl-tmp/Llama2-Chinese", ] # 加载目标文件 docs = [] for dir_path in tar_dir: docs.extend(get_text(dir_path)) # 对文本进行分块 text_splitter = RecursiveCharacterTextSplitter( chunk_size=500, chunk_overlap=150) split_docs = text_splitter.split_documents(docs) # 加载开源词向量模型 embeddings = HuggingFaceEmbeddings(model_name="/root/autodl-tmp/embedding_model") # 构建向量数据库 # 定义持久化路径 persist_directory = 'data_base/vector_db/chroma' # 加载数据库 vectordb = Chroma.from_documents( documents=split_docs, embedding=embeddings, persist_directory=persist_directory # 允许我们将persist_directory目录保存到磁盘上 ) # 将加载的向量数据库持久化到磁盘上 vectordb.persist()

运行上述脚本即可在本地构建已持久化的向量数据库，后续直接导入该数据库即可，无需重复构建。从源码结构看，整个流程的关键链路为：os.walk 递归收集文件 --> UnstructuredMarkdownLoader/UnstructuredFileLoader 解析文档 --> RecursiveCharacterTextSplitter 分块 --> HuggingFaceEmbeddings 向量化 --> Chroma.from_documents 入库并持久化，这也是 LangChain 早期版本（0.0.292）构建本地知识库的标准范式。

Atom 接入 LangChain：自定义 LLM 类

为便捷构建 LLM 应用，需要基于本地部署的 Atom 自定义一个 LLM 类，将 Atom 接入 LangChain 框架。完成自定义 LLM 类后，可以以完全一致的方式调用 LangChain 的接口，而无需考虑底层模型调用的不一致。

基于本地部署的 Atom 自定义 LLM 类并不复杂，只需从langchain.llms.base.LLM类继承一个子类，并重写构造函数与_call函数。这正是仓库中 LLM.py 的实现：

from langchain.llms.base import LLM from typing import Any, List, Optional from langchain.callbacks.manager import CallbackManagerForLLMRun from transformers import AutoTokenizer, AutoModelForCausalLM import torch class Atom(LLM): # 基于本地 Atom 自定义 LLM 类 tokenizer : AutoTokenizer = None model: AutoModelForCausalLM = None def __init__(self, model_path :str): # model_path: Atom 模型路径 # 从本地初始化模型 super().__init__() print("正在从本地加载模型...") model_dir = '/root/autodl-tmp/FlagAlpha/Atom-7B-Chat' self.tokenizer = AutoTokenizer.from_pretrained(model_dir, trust_remote_code=True) self.model = AutoModelForCausalLM.from_pretrained(model_dir, device_map="auto", trust_remote_code=True,torch_dtype=torch.float16).eval() print("完成本地模型的加载") def _call(self, prompt: str, stop: Optional[List[str]] = None, run_manager: Optional[CallbackManagerForLLMRun] = None, **kwargs: Any): input_ids = self.tokenizer([f'<s>Human: {prompt}\n</s><s>Assistant: '], return_tensors="pt", add_special_tokens=False).input_ids.to('cuda') generate_input = { "input_ids": input_ids, "max_new_tokens": 512, "do_sample": True, "top_k": 50, "top_p": 0.95, "temperature": 0.3, "repetition_penalty": 1.3, "eos_token_id": self.tokenizer.eos_token_id, "bos_token_id": self.tokenizer.bos_token_id, "pad_token_id": self.tokenizer.pad_token_id } generate_ids = self.model.generate(**generate_input) text = self.tokenizer.decode(generate_ids[0]) return text @property def _llm_type(self) -> str: return "Atom"

在上述类定义中，我们分别重写了构造函数和_call函数：

• 构造函数：在对象实例化的一开始加载本地部署的 Atom 模型，从而避免每一次调用都需要重新加载模型导致耗时过长。这里使用trust_remote_code=True信任远端代码，device_map="auto"自动分配设备，torch_dtype=torch.float16以半精度加载以节省显存。
• _call函数：这是 LLM 类的核心函数，LangChain 会调用该函数来调用 LLM。在该函数中，我们调用已实例化模型的generate方法，实现对模型的调用并返回调用结果。注意 Prompt 被构造成 Atom 的对话模板格式'<s>Human: {prompt}\n</s><s>Assistant: '，并设置了max_new_tokens=512、top_k=50、top_p=0.95、temperature=0.3、repetition_penalty=1.3等采样参数——较低的 temperature 与较高的 repetition_penalty 有助于在知识库问答场景下生成更稳定、更少重复的答案。

在整体项目中，上述代码被封装为 LLM.py，后续直接从该文件引入自定义的 LLM 类。同时，_llm_type属性返回字符串"Atom"，供 LangChain 内部标识该 LLM 的类型。

构建检索问答链：RAG 全流程封装

LangChain 通过提供检索问答链对象实现对 RAG 全流程的封装，即调用一个RetrievalQA对象，在初始化时填入已构建的数据库和自定义 LLM 作为参数，即可简便地完成检索增强问答的全流程。LangChain 会自动完成"基于用户提问进行检索、获取相关文档、拼接为合适的 Prompt、交给 LLM 问答"的完整链路。

导入已构建的向量数据库

通过Chroma以及上文定义的词向量模型加载已构建的数据库：

from langchain.vectorstores import Chroma from langchain.embeddings.huggingface import HuggingFaceEmbeddings import os # 定义 Embeddings embeddings = HuggingFaceEmbeddings(model_name="/root/autodl-tmp/embedding_model") # 向量数据库持久化路径 persist_directory = 'data_base/vector_db/chroma' # 加载数据库 vectordb = Chroma( persist_directory=persist_directory, embedding_function=embeddings )

得到的vectordb对象即为我们已构建的向量数据库对象，该对象可以针对用户的 query 进行语义向量检索，得到与用户提问相关的知识片段。

实例化自定义 LLM 对象

接着实例化一个基于 Atom 自定义的 LLM 对象，并通过predict方法进行单轮对话测试：

from LLM import Atom llm = Atom(model_path = "/root/autodl-tmp/FlagAlpha/Atom-7B-Chat") llm.predict("你是谁")

运行效果如下图所示，模型会以 Atom 的人设进行自我介绍：

构建 Prompt Template

构建检索问答链还需要一个 Prompt Template。该 Template 本质上是一个带变量的字符串，检索之后，LangChain 会将检索到的相关文档片段填入 Template 的变量中，从而实现带知识的 Prompt 构建：

from langchain.prompts import PromptTemplate # 我们所构造的 Prompt 模板 template = """使用以下上下文来回答最后的问题。如果你不知道答案，就说你不知道，不要试图编造答案。尽量使答案简明扼要。总是在回答的最后说"谢谢你的提问！"。 {context} 问题: {question} 有用的回答:""" # 调用 LangChain 的方法来实例化一个 Template 对象，该对象包含了 context 和 question 两个变量，在实际调用时，这两个变量会被检索到的文档片段和用户提问填充 QA_CHAIN_PROMPT = PromptTemplate(input_variables=["context","question"],template=template)

该模板通过{context}和{question}两个占位变量，把"检索到的知识片段"与"用户问题"组装进同一条 Prompt，并明确约束模型"不知道就说不知道、不要编造"，这直接决定了知识库问答的忠实度。需要说明的是，仓库中 run_gradio.py 实际使用的模板相对精简，而完整教程文档中给出了带更强约束的模板，读者可根据实际效果自行选用。

构建 RetrievalQA 检索问答链

最后调用 LangChain 提供的检索问答链构造函数，基于自定义 LLM、Prompt Template 和向量知识库构建基于 Atom 的检索问答链：

from langchain.chains import RetrievalQA qa_chain = RetrievalQA.from_chain_type(llm,retriever=vectordb.as_retriever(),return_source_documents=True,chain_type_kwargs={"prompt":QA_CHAIN_PROMPT})

得到的qa_chain对象即实现核心功能：基于 Atom 模型的专业知识库助手。其中vectordb.as_retriever()将向量库转换为检索器，return_source_documents=True会在回答中附带检索到的源文档，便于追溯答案出处。

对比检索问答链与纯 LLM 的问答效果

question = "什么是Atom" result = qa_chain({"query": question}) print("检索问答链回答 question 的结果：") print(result["result"]) # 仅 LLM 回答效果 result_2 = llm(question) print("大模型回答 question 的结果：") print(result_2)

从图中可以看到，使用检索问答链生成的答案更接近知识库里的内容——这正是 RAG 的核心价值：让模型的回答有据可依，而不是完全依赖模型自身的预训练知识。

部署 Web Demo：基于 Gradio 的交互界面

在完成上述核心功能后，可以基于 Gradio 框架将其部署到 Web 网页，搭建一个小型 Demo，便于测试与使用。

封装检索问答链加载函数

首先将上文的代码内容封装为一个返回检索问答链对象的函数，并在启动 Gradio 的第一时间调用该函数得到检索问答链对象，后续直接使用该对象进行问答对话，从而避免重复加载模型：

# 导入必要的库 import gradio as gr from langchain.vectorstores import Chroma from langchain.embeddings.huggingface import HuggingFaceEmbeddings import os from LLM import Atom from langchain.prompts import PromptTemplate def load_chain(): # 加载问答链 # 定义 Embeddings embeddings = HuggingFaceEmbeddings(model_name="/root/autodl-tmp/embedding_model") # 向量数据库持久化路径 persist_directory = 'data_base/vector_db/chroma' # 加载数据库 vectordb = Chroma( persist_directory=persist_directory, # 允许我们将persist_directory目录保存到磁盘上 embedding_function=embeddings ) llm = Atom(model_path = "/root/autodl-tmp/FlagAlpha") template = """使用以下上下文来回答最后的问题。如果你不知道答案，就说你不知道，不要试图编造答案。尽量使答案简明扼要。总是在回答的最后说"谢谢你的提问！"。 {context} 问题: {question} 有用的回答:""" QA_CHAIN_PROMPT = PromptTemplate(input_variables=["context","question"], template=template) # 运行 chain from langchain.chains import RetrievalQA qa_chain = RetrievalQA.from_chain_type(llm, retriever=vectordb.as_retriever(), return_source_documents=True, chain_type_kwargs={"prompt":QA_CHAIN_PROMPT}) return qa_chain

定义问答响应类

接着定义一个类，负责加载并存储检索问答链，并响应 Web 界面里调用检索问答链进行回答的动作：

class Model_center(): """ 存储问答 Chain 的对象 """ def __init__(self): self.chain = load_chain() def qa_chain_self_answer(self, question: str, chat_history: list = []): """ 调用不带历史记录的问答链进行回答 """ if question == None or len(question) < 1: return "", chat_history try: chat_history.append( (question, self.chain({"query": question})["result"])) return "", chat_history except Exception as e: return e, chat_history def clear_history(self): self.chain.clear_history()

Model_center类将问答链的加载与调用隔离：__init__中加载一次问答链供全程复用；qa_chain_self_answer接收用户问题与聊天历史，返回(更新后的输入框, 聊天历史)二元组供 Gradio 更新组件；clear_history用于清空历史记录。

构建 Gradio 界面

然后按照 Gradio 的框架使用方法，实例化一个 Web 界面并将点击动作绑定到上述类的回答方法即可：

import gradio as gr model_center = Model_center() block = gr.Blocks() with block as demo: with gr.Row(equal_height=True): with gr.Column(scale=15): gr.Markdown("""<h1><center>Atom</center></h1> <center>Llama2-chinese(教程来自DataWhale Self-LM团队)</center> """) with gr.Row(): with gr.Column(scale=4): chatbot = gr.Chatbot(height=450, show_copy_button=True) # 创建一个文本框组件，用于输入 prompt。 msg = gr.Textbox(label="Prompt/问题") with gr.Row(): # 创建提交按钮。 db_wo_his_btn = gr.Button("Chat") with gr.Row(): # 创建一个清除按钮，用于清除聊天机器人组件的内容。 clear = gr.ClearButton( components=[chatbot], value="Clear console") # 设置按钮的点击事件。当点击时，调用上面定义的 qa_chain_self_answer 函数，并传入用户的消息和聊天历史记录，然后更新文本框和聊天机器人组件。 db_wo_his_btn.click(model_center.qa_chain_self_answer, inputs=[msg, chatbot], outputs=[msg, chatbot]) # 点击后清空后端存储的聊天记录 clear.click(model_center.clear_history) gr.Markdown("""提醒：<br> 1. 初始化数据库时间可能较长，请耐心等待。 2. 使用中如果出现异常，将会在文本输入框进行展示，请不要惊慌。 <br> """) # threads to consume the request gr.close_all() # 启动新的 Gradio 应用，设置分享功能为 True，并使用环境变量 PORT1 指定服务器端口。 # demo.launch(share=True, server_port=int(os.environ['PORT1'])) # 直接启动 demo.launch()

界面采用gr.Blocks()布局：顶部展示 "Atom (Llama2-chinese)" 标题，主体是高度 450 的聊天机器人组件（支持复制按钮）与输入框，配以 "Chat" 提交按钮和 "Clear console" 清除按钮。db_wo_his_btn.click将按钮点击事件绑定到qa_chain_self_answer，实现一问一答；底部还给出了两条使用提醒。

启动与访问

通过将上述代码封装为 run_gradio.py 脚本，直接在终端运行python run_gradio.py，即可在本地启动知识库助手的 Web Demo。默认在 7860 端口运行，使用类似于部署的方式将服务器端口映射到本地端口即可访问：

总结

至此，我们完成了从零构建 Atom-7B-Chat 知识库助手的全部流程：先通过 creat_db.py 将本地语料分块、向量化并持久化为 Chroma 向量数据库；再通过 LLM.py 将本地 Atom 模型封装为 LangChain 自定义 LLM；随后用RetrievalQA串联"检索-拼接-生成"形成带知识依据的问答链；最终以 run_gradio.py 提供可交互的 Web 界面。

这套方案的核心价值在于：其一，知识库内容完全由用户掌控，模型回答有据可循、可溯源（return_source_documents=True）；其二，LangChain 的抽象让本地模型、向量库、Prompt 三者可以灵活替换，例如将 Atom 换成其他模型、将 Chroma 换成其他向量数据库、将语料换成任意业务文档，即可快速复用同一套工程框架。读者可在此基础上进一步扩展：替换更大规模或领域适配的语料、接入多轮对话历史、调整分块参数与检索策略，或将其接入 02-Atom-7B-Chat-Lora 等微调后的模型，构建更贴合业务场景的专属知识库助手。

【免费下载链接】self-llm《开源大模型食用指南》针对中国宝宝量身打造的基于Linux环境快速微调（全参数/Lora）、部署国内外开源大模型（LLM）/多模态大模型（MLLM）教程项目地址: https://gitcode.com/GitHub_Trending/se/self-llm