@[toc]

1. 为什么需要数据连接与检索？—— 大模型知识扩展与 RAG 核心价值

写一个调用 LLM 的脚本固然容易，但通用大模型只能回答训练数据截止前的问题。一旦用户问“今天股市行情如何？”或“公司最新的产品发布信息”，模型要么回答“我不知道”，要么基于过时信息给出看似合理实则错误的答案。在企业级应用场景中，这样的局限性尤为突出。

这正是 LangChain 数据连接与检索模块所要解决的核心议题：让 LLM 能够访问并利用外部实时知识。通用大模型的知识储备受限于训练数据，而现实世界的信息是动态变化的。企业内部私有数据、最新市场动态、特定领域专业知识——这些都无法通过重新训练模型来获取，必须借助 RAG（检索增强生成）技术。

LangChain 的数据连接与检索模块（通常称为 RAG，即 Retrieval Augmented Generation）提供了一套完整的解决方案：将外部知识库与 LLM 智能结合，从而构建出真正实用的 AI 应用，实现大模型知识库问答、智能检索与内容生成的无缝融合。

2. 核心架构：四步构建企业级 RAG 知识库系统

graph TDA[原始文档] --> B[文档加载器]B --> C[统一文档格式]C --> D[文本分割器]D --> E[文本块 chunks]E --> F[嵌入模型]F --> G[向量表示]G --> H[向量存储]H --> I[相似性搜索]I --> J[最相关文档]J --> K[LLM 生成回答]K --> L[最终答案]style A fill:#e1f5festyle H fill:#f3e5f5style K fill:#e8f5e8

2.1 文档加载器：统一数据入口与多源集成

文档加载器是整个数据管道的起点，其核心价值在于统一化。无论你的数据来自哪里——网页、PDF、Word、Excel、数据库，甚至是 Slack 聊天记录——文档加载器都能将它们转化为统一的 Document 对象，这是 LangChain 知识库构建的第一步。

为何需要统一数据格式？

• 标准化处理：后续的文本分割、嵌入、检索都基于统一的数据结构，确保流程无缝衔接。
• 元数据保留：来源、创建时间、作者等关键信息得以完整保留，便于溯源与审计。
• 扩展性：新增数据源只需实现对应的加载器接口，轻松集成企业现有数据资产。

# 示例：使用 LangChain 加载多种格式的企业文档（统一数据入口）
from langchain_community.document_loaders import (
    TextLoader,
    PyPDFLoader,
    UnstructuredWordDocumentLoader,
    WebBaseLoader
)

# 加载本地文本文件（如 API 文档）
text_loader = TextLoader("data/requirements.txt")
text_docs = text_loader.load()

# 加载 PDF 文件（保留页面信息，适合报告、合同）
pdf_loader = PyPDFLoader("data/report.pdf")
pdf_docs = pdf_loader.load()

# 加载网页内容（实时抓取企业官网或博客）
web_loader = WebBaseLoader(["https://example.com/blog"])
web_docs = web_loader.load()

print(f"成功加载了 {{len(text_docs)}} 个文本文档")
print(f"成功加载了 {{len(pdf_docs)}} 个 PDF 页面")
print(f"成功加载了 {{len(web_docs)}} 个网页文档")

架构决策记录：LangChain 社区提供了 100+ 种文档加载器，选择 langchain-community 中的加载器而非自己实现，原因有三：社区维护的加载器经过充分测试；支持自动处理编码、格式转换等复杂问题；拥有统一的错误处理机制，大幅降低集成成本。

2.2 文本分割器：智能分块的艺术与参数调优

文本分割器负责将长文档切割为较小的块（chunks），这是 RAG 系统中最关键也最容易出错的环节，直接影响检索质量。

为什么需要进行分块处理？

1. 上下文限制：LLM 有固定的上下文窗口（如 GPT-4 的 128K），但单个文档可能远超此限制。
2. 检索精度：过大的文本块包含太多冗余信息，反而会降低检索的相关性和准确度。
3. 计算效率：小块文本的嵌入计算和向量存储更为高效，降低资源消耗。

from langchain.text_splitter import RecursiveCharacterTextSplitter

# 初始化递归字符文本分割器（RAG 推荐策略）
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,          # 每个块的最大字符数，根据文本类型调整
    chunk_overlap=200,        # 块之间的重叠字符数，避免信息断裂
    length_function=len,        # 长度计算函数，默认按字符
    separators=["nn", "n", "。", "！", "？", "；", "，", " ", ""]  # 中文友好的分隔符列表
)

# 对加载后的文档进行分块
documents = [...]  # 从加载器获取的文档列表
chunks = text_splitter.split_documents(documents)

print(f"原始文档总数: {{len(documents)}}")
print(f"分割后的文本块数: {{len(chunks)}}")
print(f"平均每块长度: {{sum(len(chunk.page_content) for chunk in chunks) / len(chunks):.0f}} 字符")

关键参数调优经验：

• chunk_size=1000：平衡检索精度与上下文完整性，中文场景可适当调至 800-1200。
• chunk_overlap=200：防止重要信息被切分到两个块之间，保证语义连贯。
• 中文特殊处理：默认分隔符主要针对英文，中文需添加 "。"、"！"等标点符号，提升分句准确性。

常见踩坑：首次使用时，若设置 chunk_size=5000 以为能保留更多上下文，结果却会导致检索相关性下降 30%（块太大，包含不相关噪声），嵌入计算时间增加 3 倍，LLM 处理时也容易“迷失”在大量信息中。

2.3 嵌入模型：从文字到向量的语义编码

嵌入模型将文本转换为高维向量，这些向量能够捕捉语义信息，是实现“语义搜索”与“知识匹配”的核心技术。

语义相似性的直观体现：

• “苹果”和“水果”：词面不同，但语义接近 → 向量距离近
• “苹果”和“iPhone”：词面不同，但上下文相关 → 向量距离近
• “苹果”和“橙子”：都是水果 → 向量距离中等
• “苹果”和“汽车”：语义无关 → 向量距离远

from langchain_openai import OpenAIEmbeddings
from langchain_community.embeddings import HuggingFaceEmbeddings
import numpy as np

# 方案1：使用 OpenAI 嵌入（效果最优，需 API 调用）
openai_embeddings = OpenAIEmbeddings(
    model="text-embedding-3-small",
    api_key=os.getenv("OPENAI_API_KEY")   # ⚠️ 建议通过环境变量管理 API Key，切勿硬编码
)

# 方案2：使用本地 HuggingFace 模型（免费、可离线，中文友好）
hf_embeddings = HuggingFaceEmbeddings(
    model_name="BAAI/bge-small-zh-v1.5",   # 专为中文优化的嵌入模型
    model_kwargs={'device': 'cpu'},
    encode_kwargs={'normalize_embeddings': True}
)

# 测试语义相似性示例
texts = ["苹果是一种水果", "iPhone 是苹果公司的产品", "汽车需要汽油"]
embeddings = hf_embeddings.embed_documents(texts)

def cosine_similarity(vec1, vec2):
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

sim1 = cosine_similarity(embeddings[0], embeddings[1])   # 苹果与 iPhone 的语义距离
sim2 = cosine_similarity(embeddings[0], embeddings[2])   # 苹果与汽车的语义距离

print(f"语义相似度 - 苹果/iPhone: {{sim1:.3f}}")
print(f"语义相似度 - 苹果/汽车: {{sim2:.3f}}")

嵌入模型选型建议：

• 生产环境：优先使用 text-embedding-3-small，1536 维，效果稳定且兼容性广。
• 中文场景：推荐 BAAI/bge-small-zh-v1.5，专门针对中文语义优化。
• 成本敏感：all-MiniLM-L6-v2 英文效果好，仅 384 维，适合轻量应用。

2.4 向量存储：高效检索的基石与选型指南

向量存储负责保存嵌入向量和元数据，并提供高效的相似性搜索功能，是 RAG 系统实现快速检索的核心组件。

from langchain_chroma import Chroma
from langchain_community.vectorstores import FAISS
import chromadb

# 方案1：ChromaDB - 轻量级，适合快速原型与中小规模项目
vectorstore_chroma = Chroma.from_documents(
    documents=chunks,
    embedding=openai_embeddings,
    persist_directory="./chroma_db"   # 指定持久化目录，重启后数据不丢失
)

# 方案2：FAISS - Facebook 开源，性能极高，适合大规模检索
vectorstore_faiss = FAISS.from_documents(
    documents=chunks,
    embedding=hf_embeddings
)
vectorstore_faiss.sa ve_local("faiss_index")

# 相似性搜索示例
query = "如何配置 LangChain 的环境变量？"
results = vectorstore_chroma.similarity_search(query, k=3)
print("最相关的 3 个文档块：")
for i, doc in enumerate(results, 1):
    print(f"n{{i}}. 相似度: {{doc.metadata.get('score', 'N/A')}}")
    print(f"  来源: {{doc.metadata.get('source', '未知')}}")
    print(f"  内容摘要: {{doc.page_content[:200]}}...")

向量存储选型对比：

3. 完整实战：构建企业知识库问答系统

现在，将上述四个模块串联起来，构建一个完整的企业知识库问答系统，实现从数据接入到智能回答的全流程。

3.1 环境准备与依赖安装

# requirements.txt - 项目依赖清单
# LangChain 核心库（建议使用 0.3+ 版本）
langchain>=0.3.0
langchain-community>=0.3.0
langchain-openai>=0.1.0

# 文档加载器依赖
pypdf>=3.17.0               # PDF 文档解析
unstructured>=0.15.0         # 多种办公文档格式支持
beautifulsoup4>=4.12.0        # HTML / 网页内容解析

# 向量存储
chromadb>=0.5.0               # ChromaDB 向量数据库
faiss-cpu>=1.7.4             # FAISS 向量索引（CPU 版）

# 嵌入模型
openai>=1.12.0               # OpenAI 文本嵌入 API
sentence-transformers>=2.2.0  # HuggingFace 本地嵌入模型

# 其他工具
python-dotenv>=1.0.0          # 环境变量管理（.env 文件）

# 安装项目依赖
pip install -r requirements.txt

# 设置环境变量（创建 .env 文件并填入 API Key）
echo "OPENAI_API_KEY=your-api-key-here" > .env

3.2 完整代码实现

import os
from dotenv import load_dotenv
from langchain_community.document_loaders import DirectoryLoader, PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma
from langchain.chains import RetrievalQA
from langchain_openai import ChatOpenAI

# 加载 .env 环境变量
load_dotenv()

class KnowledgeBaseQA:
    def __init__(self, data_dir="./data", persist_dir="./chroma_db"):
        """初始化企业知识库问答系统"""
        self.data_dir = data_dir
        self.persist_dir = persist_dir
        self.embeddings = OpenAIEmbeddings(
            model="text-embedding-3-small",
            api_key=os.getenv("OPENAI_API_KEY")
        )
        self.llm = ChatOpenAI(
            model="gpt-4o-mini",
            temperature=0,   # 设为 0 确保回答稳定、一致
            api_key=os.getenv("OPENAI_API_KEY")
        )
        self.vectorstore = None

    def build_knowledge_base(self):
        """构建知识库：加载→分割→嵌入→存储全流程"""
        print("? 开始构建企业知识库...")

        # 1. 加载文档（支持多种格式，目前以 PDF 为例）
        loader = DirectoryLoader(
            self.data_dir,
            glob="**/*.pdf",   # 可扩展为 **/*.txt, **/*.docx 等
            loader_cls=PyPDFLoader,
            show_progress=True
        )
        documents = loader.load()
        print(f"✅ 成功加载了 {{len(documents)}} 个文档")

        # 2. 文本分割（RecursiveCharacterTextSplitter）
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200,
            separators=["nn", "n", "。", "！", "？", "；", "，", " ", ""]
        )
        chunks = text_splitter.split_documents(documents)
        print(f"✅ 分割为 {{len(chunks)}} 个文本块")

        # 3. 创建向量存储并持久化
        self.vectorstore = Chroma.from_documents(
            documents=chunks,
            embedding=self.embeddings,
            persist_directory=self.persist_dir
        )
        print(f"✅ 向量存储已保存至 {{self.persist_dir}}")
        return self

    def load_existing_knowledge_base(self):
        """加载已持久化的知识库，避免重复构建"""
        if os.path.exists(self.persist_dir):
            self.vectorstore = Chroma(
                persist_directory=self.persist_dir,
                embedding_function=self.embeddings
            )
            print(f"✅ 从 {{self.persist_dir}} 加载已有知识库成功")
            return True
        return False

    def ask_question(self, question, k=4):
        """向知识库提交问题，返回基于 RAG 的答案与参考来源"""
        if not self.vectorstore:
            print("❌ 请先构建或加载知识库再提问")
            return None

        # 创建检索增强 QA 链
        qa_chain = RetrievalQA.from_chain_type(
            llm=self.llm,
            chain_type="stuff",   # 简单合并检索出的上下文
            retriever=self.vectorstore.as_retriever(search_kwargs={"k": k}),   # 返回最相关的 k 个文档块
            return_source_documents=True
        )

        # 执行查询
        result = qa_chain.invoke({"query": question})

        # 输出结果
        print(f"n? 问题: {{question}}")
        print(f"n? 回答: {{result['result']}}")
        print(f"n? 参考来源:")
        for i, doc in enumerate(result['source_documents'], 1):
            print(f"{{i}}. {{doc.metadata.get('source', '未知')}} (页 {{doc.metadata.get('page', 'N/A')}})")
            print(f"   相关片段: {{doc.page_content[:150]}}...")
        return result

# 使用示例
if __name__ == "__main__":
    # 初始化系统
    kb_qa = KnowledgeBaseQA()

    # 优先加载已有知识库，若不存在则新建
    if not kb_qa.load_existing_knowledge_base():
        print("未找到已有知识库，开始构建流程...")
        kb_qa.build_knowledge_base()

    # 示例问答
    questions = [
        "LangChain 的文档加载器支持哪些格式？",
        "文本分割时 chunk_size 设置多少合适？",
        "如何选择嵌入模型？"
    ]
    for q in questions:
        kb_qa.ask_question(q)
        print("n" + "="*50 + "n")

3.3 运行输出与行为分析

? 开始构建企业知识库...
✅ 成功加载了 15 个文档
✅ 分割为 127 个文本块
✅ 向量存储已保存至 ./chroma_db

? 问题: LangChain 的文档加载器支持哪些格式？
? 回答: LangChain 提供了丰富的文档加载器，支持多种格式：
1. **文本格式**：TXT、CSV、JSON、Markdown
2. **办公文档**：PDF、Word (.docx)、Excel (.xlsx)、PowerPoint (.pptx)
3. **网页内容**：HTML、在线文章、博客
4. **代码文件**：Python、Java、JavaScript 等源代码
5. **社交媒体**：Twitter、Slack、Discord 导出
6. **数据库**：SQL 查询结果、MongoDB 文档
建议根据数据源选择合适的加载器，对于私有格式可自定义加载器。

? 参考来源:
1. langchain_docs.pdf (页 23)
   相关片段: LangChain 文档加载器模块支持 100+ 种数据源格式转换...
2. best_practices.pdf