大家好！上一篇我们一起搭建了 RAG 个人私有知识库 v2.0，实现了 PDF/Word/TXT 本地文档的问答功能，但有很多初学者可能存在这样的想法：“不想用 OpenAI，需要 API Key 还要花钱”“没有外网，API 调用失败”“想完全离线运行，保护自己的私有数据”。

今天，我们就来升级 v3.0 版本——零成本接入本地大模型，彻底告别 OpenAI，实现 100% 离线私有知识库！

全程不需要 API Key、不需要外网、不需要花钱，只用一个免费工具（Ollama），就能把上一篇的代码“改 3 行”实现本地运行，初学者也能跟着一步步做完，看完就能跑通！

一、先搞懂：为什么要接入本地大模型？（初学者必看）

上一篇的 v2.0 版本，我们用的是 OpenAI 的 gpt-3.5-turbo 模型，虽然好用，但有 3 个致命问题，可能也是大家感受最多的：

• 需要 API Key：得去 OpenAI 官网申请，还要绑定银行卡，对新手不友好；

• 需要花钱：虽然 gpt-3.5 很便宜，但长期用还是有成本，零成本学习的新手不想额外支出；

• 需要外网：国内直接调用会失败，很多人不会搭代理，直接卡壳。

而本地大模型，就是把大模型“装在自己的电脑上”，完全离线运行，解决以上所有问题：

• 零成本：所有工具、模型全免费；

• 无外网：下载完模型后，断网也能正常使用；

• 更安全：私有文档、问答记录全在自己电脑上，不泄露；

• 门槛低：不用申请 API Key，不用搭代理，双击安装就能用。

💡 新手不用担心：本地大模型不用“高端电脑”，普通笔记本（8G 内存）就能跑，我们选的是轻量中文模型，运行流畅不卡顿！

二、前置准备：确认你的 v2.0 环境能正常运行（关键一步）

在升级 v3.0 之前，先确认你上一篇的 v2.0 代码能正常运行——不是要运行 OpenAI 模型，而是确认你的 Python 环境、依赖包、文档加载功能没问题。

如果还没搭建 v2.0，建议先看上一篇传送门：从零搭建个人私有知识库 RAG 实战（附完整代码）https://blog.csdn.net/weixin_42298314/article/details/158579587?fromshare=blogdetail&sharetype=blogdetail&sharerId=158579587&sharerefer=PC&sharesource=weixin_42298314&sharefrom=from_link，或者直接用本文末尾的 v3.0 完整代码（无需依赖 v2.0，直接新建项目也能跑）。

确认要点（新手必查）：

1. 电脑已安装 Python 3.8+（打开 cmd，输入 python --version，能显示版本号即可）；

2. 已安装 v2.0 的所有依赖包（requirements.txt 里的内容，忘记的话下文会重新给出）；

3. 能正常加载本地文档（比如 PDF），不会出现“文件不存在”“加载失败”的报错。

如果以上都没问题，直接进入下一步；如果有问题，先解决环境问题（下文有常见报错解决），再继续。

三、核心工具：Ollama 安装（零成本，双击完成）

我们这次用 Ollama 这个工具——它是目前最简单、最适合新手的本地大模型运行工具，能一键下载、运行各种大模型（比如 qwen、llama3、gemma 等），不用配置复杂的环境，双击安装就好。

全程分 3 步，每一步都有截图提示（新手跟着做，不会错）：

步骤 1：下载 Ollama（官网直接下，免费）

打开 Ollama 官网：https://ollama.com/（国内可直接访问，不用外网），根据自己的电脑系统下载：

• Windows：点击“Download for Windows”，下载 .exe 安装包；

• Mac：点击“Download for Mac”，下载 .dmg 安装包；

• Linux：复制官网给出的命令，在终端执行（新手暂时不用管，重点讲 Windows/Mac）。

✅ 新手提示：下载速度可能有点慢，耐心等几分钟，下载完成后，找到安装包（一般在“下载”文件夹）。

步骤 2：安装 Ollama（双击下一步，无需配置）

打开下载好的安装包，全程“下一步”即可，不需要手动修改任何配置：

• Windows：双击 .exe 文件，点击“下一步”，勾选“我接受协议”，再点击“下一步”，最后点击“安装”，等待 1-2 分钟，安装完成后会自动启动 Ollama（桌面可能没有图标，正常现象）；

• Mac：双击 .dmg 文件，将 Ollama 拖到“应用程序”文件夹，然后打开“终端”，输入 ollama，如果显示 Ollama 的命令提示，说明安装成功。

💡 安装后验证：打开“命令提示符”（Windows 按 Win+R，输入 cmd；Mac 打开终端），输入 ollama --version，如果显示版本号（比如 ollama version 0.1.29），说明安装成功！

步骤 3：下载本地中文大模型（一键命令，零配置）

Ollama 安装完成后，我们需要下载一个 轻量中文大模型——新手推荐 qwen:7b（阿里通义千问的 7B 模型，中文效果好、体积小、普通笔记本能跑）。

操作步骤：

1. 打开“命令提示符”（Windows）或“终端”（Mac）；

2. 输入命令：ollama pull qwen:7b，然后按回车；

3. 等待下载完成：模型大小约 3.8GB，下载速度取决于你的网络，一般 10-20 分钟（耐心等，不用管中间的进度条）；

4. 下载完成后，终端会显示“success”，说明模型已经下载到你的电脑上了。

✅ 新手备选：如果你的电脑内存较小（8G 内存），可以下载更小的模型 qwen:4b（约 2GB），命令改为 ollama pull qwen:4b；如果内存较大（16G+），可以下载 qwen:14b（效果更好）。

✅ 验证模型：输入命令 ollama run qwen:7b，然后输入“你好”，如果模型能回复你，说明模型能正常运行！（测试完输入 /exit 退出即可）

四、核心操作：修改 v2.0 代码，接入本地大模型（只改 3 行）

这一步是重点，但非常简单——我们不需要重写代码，只需要修改上一篇 v2.0 代码中的“大模型配置”部分，把 OpenAI 换成本地的 Ollama 模型，总共只改 3 行，新手也能轻松搞定。

先给大家说清楚：v2.0 和 v3.0 的核心区别，就在于“用哪个大模型”——v2.0 用 OpenAI 的在线模型，v3.0 用本地的 Ollama 模型，其他功能（文档加载、分块、向量库）完全不变，所以代码改动极小。

步骤 1：确认依赖包（新增 1 个依赖，其余不变）

v3.0 只需要在 v2.0 的基础上，新增一个依赖包 langchain-community（其实 v2.0 可能已经安装过，保险起见重新安装一次）。

新建/修改 requirements.txt 文件，内容如下（复制粘贴即可）：

# requirements.txt
langchain==0.1.0
langchain-community==0.0.20  # 用于对接 Ollama
sentence-transformers==2.2.2
chromadb==0.4.22
pypdf==3.17.4
python-docx==1.1.0
# openai==1.6.1  # 注释掉，不用 OpenAI 了

执行安装命令（打开 cmd/终端，进入代码所在文件夹，输入以下命令）：

pip install -r requirements.txt

✅ 新手提示：如果出现“pip 不是内部或外部命令”，把命令中的 pip 换成pip3 再试；如果安装失败，输入 pip install --upgrade pip 更新 pip 后再安装。

步骤 2：修改代码（只改 3 行，标注清晰）

打开你上一篇的 v2.0 代码（或者直接复制下文的 v3.0 完整代码），找到 build_rag_chain 函数（构建 RAG 问答链的函数），只需要修改 3 处：

先看 v2.0 的代码（需要修改的部分）：

def build_rag_chain(retriever):
    """构建 RAG 问答链"""
    print("\n初始化大模型...")
    # 以下是 v2.0 的 OpenAI 配置（需要删除/注释）
    llm = ChatOpenAI(
        model_name=RAGConfig.llm_model,
        temperature=RAGConfig.temperature
    )
    # 后面的 prompt 和 qa_chain 不变

再看 v3.0 的修改（替换成 Ollama 本地模型）：

def build_rag_chain(retriever):
    """构建 RAG 问答链（接入本地 Ollama 模型）"""
    print("\n初始化本地大模型...")
    # 第 1 处修改：导入 Ollama 相关包（放在函数内或文件开头都可以）
    from langchain_community.llms import Ollama
    # 第 2 处修改：替换成本地 Ollama 模型（qwen:7b 就是我们刚才下载的模型）
    llm = Ollama(
        model="qwen:7b",  # 模型名称，和我们下载的一致
        temperature=RAGConfig.temperature  # 温度不变，0 表示回答更精准
    )
    # 第 3 处修改：可选，增加超时设置（避免模型加载慢导致报错）
    llm.client.timeout = 600
    
    # 后面的 prompt 和 qa_chain 完全不变，直接保留！
    prompt_template = """
你是一个专业的问答助手，请严格基于以下【上下文内容】回答用户的问题。

【约束条件】
1. 如果上下文中包含答案，请用简洁准确的语言回答，并指出信息在文档中的位置。
2. 如果上下文中没有相关信息，请直接回答：根据现有知识库，无法回答该问题。
3. 严禁编造或使用外部知识。
4. 回答保持客观，不添加个人观点。

【上下文内容】
{context}

【用户问题】
{question}

【回答】：
"""
    prompt = PromptTemplate(template=prompt_template, input_variables=["context", "question"])

    qa_chain = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=retriever,
        return_source_documents=True,
        chain_type_kwargs={"prompt": prompt}
    )
    print("RAG问答链构建完成（本地模型已接入）")
    return qa_chain

💡 新手重点：

1. 导入 Ollama 包：可以放在函数内（如上面的代码），也可以放在文件开头（和其他 import 放在一起），两种方式都可以；

2. 模型名称必须和下载的一致：如果下载的是 qwen:4b，就改成 model="qwen:4b"，不能错；

3. 超时设置：增加 llm.client.timeout = 600，避免模型第一次加载慢导致报错，新手建议加上。

步骤 3：修改配置类（可选，优化中文效果）

为了让本地模型的中文问答效果更好，我们可以修改 RAGConfig 类中的向量模型（换成中文向量模型），虽然不是必须，但建议新手修改，步骤如下：

class RAGConfig:
    """统一配置项（v3.0 优化中文适配）"""
    chunk_size = 500
    chunk_overlap = 50
    k_retrieval = 3
    retrieval_score_threshold = 0.5
    persist_directory = "./chroma_db"
    # 修改：换成中文向量模型，比 all-MiniLM-L6-v2 中文效果更好
    embedding_model = "BAAI/bge-small-zh-v1.5"
    # llm_model 注释掉，不用 OpenAI 了
    # llm_model = "gpt-3.5-turbo"
    temperature = 0
    encoding = "utf-8"

✅ 说明：BAAI/bge-small-zh-v1.5 是免费的中文向量模型，第一次运行会自动下载（约 500MB），下载一次后后续会缓存，不用重复下载。

五、完整代码（v3.0 最终版，可直接复制运行）

为了方便新手，我把完整的 v3.0 代码整理好了，包含所有修改，大家可以直接复制到一个 Python 文件（比如 rag_v3.py），不用自己修改，直接运行即可。

# -*- coding: utf-8 -*-
"""
RAG 个人私有知识库 v3.0
核心升级：零成本接入本地大模型（Ollama），彻底告别 OpenAI
支持：PDF / Word / TXT、向量库缓存、MMR 检索、中文优化、编码兼容、100% 离线运行
适合初学者，全程零成本、无外网、无 API Key
"""
import os
from typing import List, Optional, Tuple
from langchain_community.document_loaders import PyPDFLoader, Docx2txtLoader, TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import SentenceTransformerEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.prompts import PromptTemplate
from langchain.chains import RetrievalQA
from langchain.schema.document import Document
# 导入 Ollama（v3.0 新增）
from langchain_community.llms import Ollama


class RAGConfig:
    """统一配置项（v3.0 优化中文适配）"""
    # 文本拆分参数
    chunk_size = 500  # 每个片段字符数（中文约250字）
    chunk_overlap = 50  # 片段重叠字符数
    # 检索参数
    k_retrieval = 3  # 召回最相关的片段数
    retrieval_score_threshold = 0.5  # 相似度阈值
    # 向量库参数
    persist_directory = "./chroma_db"  # 向量库存储路径
    embedding_model = "BAAI/bge-small-zh-v1.5"  # 中文向量模型（效果更好）
    # 大模型参数（本地模型，无需配置 API Key）
    temperature = 0  # 温度越低，回答越精准
    # 文件编码
    encoding = "utf-8"


def load_documents(file_path: str) -> Optional[List[Document]]:
    """加载单文档，支持 PDF / Word / TXT，自动兼容编码"""
    if not os.path.exists(file_path):
        print(f"文件不存在：{file_path}")
        return None

    try:
        if file_path.endswith('.pdf'):
            print("检测到 PDF 文件")
            loader = PyPDFLoader(file_path)
        elif file_path.endswith('.docx'):
            print("检测到 Word 文件")
            loader = Docx2txtLoader(file_path)
        elif file_path.endswith('.txt'):
            print("检测到 TXT 文件")
            # 自动兼容 utf-8 / gbk，解决中文乱码问题
            try:
                loader = TextLoader(file_path, encoding="utf-8")
            except UnicodeDecodeError:
                loader = TextLoader(file_path, encoding="gbk")
        else:
            print("不支持的文件格式")
            print("支持格式：.pdf, .docx, .txt")
            return None

        documents = loader.load()
        print(f"成功加载文档：{file_path}")
        total_len = sum(len(d.page_content) for d in documents)
        print(f"文档信息：共 {len(documents)} 页/段，总字符数：{total_len}")
        return documents

    except Exception as e:
        print(f"加载文档失败：{str(e)}")
        return None


def split_documents(documents: List[Document]) -> List[Document]:
    """文本分块，中文友好，避免拆分到句子中间"""
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=RAGConfig.chunk_size,
        chunk_overlap=RAGConfig.chunk_overlap,
        separators=["\n\n", "\n", "。", "！", "？", "；", "，", "、", " ", ""],
        length_function=len
    )
    splits = text_splitter.split_documents(documents)
    print("文本拆分完成")
    print(f"拆分信息：共拆分成 {len(splits)} 个片段")
    return splits


def get_or_create_vector_db(splits: List[Document]) -> Tuple[Chroma, SentenceTransformerEmbeddings]:
    """向量库创建或加载（带缓存，避免重复向量化）"""
    print(f"\n初始化向量化模型：{RAGConfig.embedding_model}")
    print("首次运行会自动下载模型，耐心等待...")

    embeddings = SentenceTransformerEmbeddings(model_name=RAGConfig.embedding_model)

    # 检查是否存在已有的向量库
    if os.path.exists(RAGConfig.persist_directory) and os.listdir(RAGConfig.persist_directory):
        print(f"检测到已存在的向量库，直接加载：{RAGConfig.persist_directory}")
        vectordb = Chroma(
            persist_directory=RAGConfig.persist_directory,
            embedding_function=embeddings
        )
        print(f"向量库信息：包含 {vectordb._collection.count()} 个向量")
    else:
        print(f"未检测到向量库，新建并保存：{RAGConfig.persist_directory}")
        vectordb = Chroma.from_documents(
            documents=splits,
            embedding=embeddings,
            persist_directory=RAGConfig.persist_directory
        )
        vectordb.persist()
        print(f"向量库信息：包含 {vectordb._collection.count()} 个向量")

    return vectordb, embeddings


def create_retriever(vectordb: Chroma):
    """MMR 检索器，兼顾相关性和结果多样性，避免重复回答"""
    retriever = vectordb.as_retriever(
        search_type="mmr",
        search_kwargs={
            "k": RAGConfig.k_retrieval,
            "fetch_k": RAGConfig.k_retrieval * 3,
            "lambda_mult": 0.7
        }
    )
    print(f"检索器创建完成，检索策略：MMR，召回数量：{RAGConfig.k_retrieval}")
    return retriever


def build_rag_chain(retriever):
    """构建 RAG 问答链（v3.0 核心：接入本地 Ollama 模型）"""
    print("\n初始化本地大模型...")
    # 配置本地大模型（Ollama），模型名称和下载的一致
    llm = Ollama(
        model="qwen:7b",  # 这里换成你下载的模型（qwen:4b / qwen:7b 等）
        temperature=RAGConfig.temperature,
        client_kwargs={"timeout": 600}  # 超时设置，避免加载慢报错
    )

    # 提示词模板（和 v2.0 一致，确保模型只基于本地文档回答）
    prompt_template = """
你是一个专业的问答助手，请严格基于以下【上下文内容】回答用户的问题。

【约束条件】
1. 如果上下文中包含答案，请用简洁准确的语言回答，并指出信息在文档中的位置。
2. 如果上下文中没有相关信息，请直接回答：根据现有知识库，无法回答该问题。
3. 严禁编造或使用外部知识。
4. 回答保持客观，不添加个人观点，语言通俗易懂。

【上下文内容】
{context}

【用户问题】
{question}

【回答】：
"""
    prompt = PromptTemplate(template=prompt_template, input_variables=["context", "question"])

    # 构建问答链，和 v2.0 完全一致
    qa_chain = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="stuff",
        retriever=retriever,
        return_source_documents=True,
        chain_type_kwargs={"prompt": prompt}
    )
    print("RAG问答链构建完成（本地模型已接入，可离线运行）")
    return qa_chain


def rag_qa(qa_chain, question: str):
    """执行问答，美化输出格式（和 v2.0 一致，新手易读）"""
    print(f"\n正在检索：'{question}'")
    result = qa_chain.invoke({"query": question})
    answer = result["result"]
    sources = result["source_documents"]

    # 美化输出，和 v2.0 保持一致，方便对比
    print("\n" + "="*60)
    print("回答：")
    print("-"*60)
    print(answer)
    print("\n答案来源：")
    print("-"*60)
    for i, doc in enumerate(sources, 1):
        source_info = f"{i}. {doc.metadata.get('source', '未知来源')}"
        if 'page' in doc.metadata:
            source_info += f" (第 {doc.metadata['page'] + 1} 页)"
        # 片段预览，避免过长
        preview = doc.page_content[:120] + "..." if len(doc.page_content) > 120 else doc.page_content
        print(source_info)
        print(f"   预览：{preview}")
    print("="*60)


def load_folder_documents(folder_path: str) -> List[Document]:
    """批量加载文件夹内所有支持的文档（批量处理，新手可选）"""
    if not os.path.exists(folder_path):
        print(f"文件夹不存在：{folder_path}")
        return []

    all_docs = []
    supported = ('.pdf', '.docx', '.txt')
    print(f"\n扫描文件夹：{folder_path}")
    for file in os.listdir(folder_path):
        fp = os.path.join(folder_path, file)
        if os.path.isfile(fp) and fp.lower().endswith(supported):
            print(f"发现文档：{file}")
            docs = load_documents(fp)
            if docs:
                all_docs.extend(docs)
    print(f"\n文件夹加载完成，共加载 {len(all_docs)} 页/段")
    return all_docs


def main():
    """主函数，一键运行，新手直接执行即可"""
    print("个人私有知识库 RAG 系统 v3.0")
    print("="*60)
    print("核心特性：零成本、本地大模型、100% 离线、中文友好")
    print("="*60)
    print()

    # ====================== 新手必改：修改你的文档路径 ======================
    # 单文件（推荐新手先试单文件，容易成功）
    DOC_PATH = "./docs/RAG教程.pdf"  # 替换成你的本地文档路径（PDF/Word/TXT）
    documents = load_documents(DOC_PATH)

    # 批量文件夹（熟练后再试，注释掉上面一行，取消下面一行注释）
    # documents = load_folder_documents("./docs")  # 批量加载 docs 文件夹下的所有文档
    # ======================================================================

    if not documents:
        print("文档加载失败，程序退出")
        return

    # 执行完整流程（和 v2.0 一致，无需修改）
    splits = split_documents(documents)
    vectordb, embeddings = get_or_create_vector_db(splits)
    retriever = create_retriever(vectordb)
    qa_chain = build_rag_chain(retriever)

    # 问答交互（和 v2.0 一致）
    print("\n问答交互已启动（输入 q 退出，断网也能使用）")
    while True:
        q = input("\n请输入你的问题：")
        if q.lower() in ['q', 'quit', 'exit']:
            print("感谢使用，再见！")
            break
        if not q.strip():
            print("问题不能为空，请重新输入")
            continue
        # 执行问答，捕获异常，避免崩溃
        try:
            rag_qa(qa_chain, q)
        except Exception as e:
            print(f"问答执行失败：{str(e)}")
            print("建议：检查 Ollama 是否正常运行，或模型是否下载成功")


if __name__ == "__main__":
    main()

六、一步一步运行测试（新手必看，确保成功）

代码复制完成后，按照以下步骤运行，每一步都有提示，确保首次能成功：

步骤 1：准备测试文档

1. 在代码所在的文件夹，新建一个 docs 文件夹（小写，不要改名字）；

2. 找一个 PDF/Word/TXT 文档（比如你的学习笔记、技术文档），复制到docs 文件夹；

3. 修改代码中的 DOC_PATH（主函数里），改成你的文档路径，比如 DOC_PATH = "./docs/我的笔记.pdf"（确保路径正确，不要有中文空格）。

步骤 2：运行代码

1. 打开“命令提示符”（Windows）或“终端”（Mac）；

2. 进入代码所在的文件夹（比如代码放在桌面的 rag 文件夹，输入 cd 桌面/rag，按回车）；

3. 输入命令：python rag_v3.py（如果报错，换成 python3 rag_v3.py）；

4. 第一次运行会自动下载两个东西（耐心等）：

   1. 中文向量模型（BAAI/bge-small-zh-v1.5，约 500MB）；

   2. Ollama 模型加载（第一次加载会慢一点，后续会缓存）。

5. 当终端显示“问答交互已启动（输入 q 退出，断网也能使用）”，说明运行成功！

步骤 3：测试问答（断网也能行）

1. 输入你文档中的相关问题（比如你的文档是 RAG 教程，就输入“RAG 的核心步骤有哪些？”）；

2. 按回车，系统会检索本地文档，然后用本地大模型生成回答，输出格式和 v2.0 完全一致；

3. 测试完成后，输入 q 退出即可。

✅ 新手验证：运行成功后，断开电脑的网络，再输入问题，依然能正常回答，说明已经完全离线运行了！

七、新手常见报错及解决方案（必看，避免卡壳）

新手运行时可能会遇到一些报错，不用慌，以下是最常见的 5 个报错，对应解决方案，照着做就能解决：

报错 1：Ollama 相关报错（比如“Ollama not found”“model not found”）

可能原因：Ollama 没安装成功，或者模型没下载完成。

解决方案：

• 打开 cmd/终端，输入 ollama --version，确认 Ollama 安装成功；

• 输入ollama run qwen:7b，确认模型能正常运行（能回复“你好”）；

• 如果模型没下载完成，重新输入 ollama pull qwen:7b，等待下载完成。

报错 2：文档加载失败（比如“文件不存在”“编码错误”）

可能原因：文档路径错误，或者 TXT 文档编码不兼容。

解决方案：

• 检查 DOC_PATH 路径是否正确，比如 ./docs/我的笔记.pdf，确保 docs 文件夹和代码在同一目录；

• TXT 文档乱码/加载失败：代码已自动兼容 utf-8/gbk，无需手动修改，重新运行即可。

报错 3：依赖包安装失败（比如“No module named 'langchain_community'”）

可能原因：requirements.txt 没安装，或者安装不完整。

解决方案：重新执行 pip install -r requirements.txt，如果还是失败，输入 pip install langchain_community 单独安装。

报错 4：运行缓慢、卡顿，甚至崩溃

可能原因：电脑内存不足，模型太大（比如用了 qwen:14b）。

解决方案：

• 换成更小的模型，比如 qwen:4b（输入 ollama pull qwen:4b，然后修改代码中的 model="qwen:4b"）；

• 关闭电脑上的其他软件，释放内存；

• 减小 chunk_size（比如改成 300），减少模型处理的内容。

报错 5：回答“根据现有知识库，无法回答该问题”

可能原因：问题和文档无关，或者检索参数设置不当。

解决方案：

• 换一个和文档相关的问题（比如文档是 RAG 教程，就问 RAG 相关的问题）；

• 修改 RAGConfig 中的 k_retrieval，改成 5（增加召回数量）。

八、v3.0 升级总结 + 新手后续学习建议

1. v3.0 核心升级亮点（新手必记）

• 零成本：Ollama 和所有模型全免费，不用花一分钱；

• 全离线：下载完模型和文档后，断网也能正常使用；

• 易操作：代码只改 3 行，新手也能轻松搞定；

• 更安全：私有数据全在本地，不泄露、不依赖第三方。

2. 新手后续学习建议（循序渐进）

如果你已经成功运行了 v3.0，接下来可以尝试这些进阶操作，难度都不高，跟着做就能学会：

• 尝试其他本地模型：比如 llama3:8b、gemma:7b，只需修改代码中的 model 名称，再用 Ollama 下载即可；

• 批量加载文档：把多个文档放在 docs 文件夹，修改代码启用批量加载功能；

• 优化问答效果：调整 chunk_size、k_retrieval 等参数，让回答更精准；

九、文末互动（新手必看）

到这里，你已经成功搭建了 RAG 个人私有知识库 v3.0，实现了零成本、全离线的本地文档问答，彻底告别了 OpenAI！

如果在运行过程中遇到任何问题，比如：

• Ollama 安装失败、模型下载慢；

• 代码运行报错，不知道怎么解决；

• 想换其他本地模型，但不知道怎么操作；

• 想优化问答效果，不知道怎么调参数。

欢迎在评论区留言，我会一一回复，帮你解决问题，确保每个新手都能学会！

下一篇

《RAG 知识库 v4.0：给检索结果 “二次排位”，答案精准度飙升》