LangChain 数据连接与检索：构建企业级知识库应用

@[toc]

前置知识：Python 基础、了解 LLM 的基本用法 环境：Python 3.10+ | langchain>=0.3 | OpenAI API 或兼容接口 你能学到：RAG 架构原理 → 文档加载与处理 → 向量检索实战 → 性能调优技巧

1. 为什么需要数据连接与检索？

你写了一个调用 LLM 的脚本，但它只能回答训练数据截止日期前的问题。当用户询问"今天股市行情如何？"或"公司最新的产品发布信息"时，模型要么回答"我不知道"，要么基于过时信息给出错误答案。

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

LangChain 的数据连接与检索模块（通常称为 RAG - Retrieval Augmented Generation）提供了完整的解决方案，将外部知识库与 LLM 智能结合，构建出真正实用的 AI 应用。

2. 核心架构：四步构建知识库系统

graph TD
    A[原始文档] --> 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:#e1f5fe
    style H fill:#f3e5f5
    style K fill:#e8f5e8

2.1 文档加载器：统一数据入口

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

为什么需要统一格式？

• 标准化处理：后续的文本分割、嵌入、检索都基于统一的数据结构
• 元数据保留：保留来源、创建时间、作者等关键信息
• 扩展性：新增数据源只需实现对应的加载器接口

# 示例：加载多种格式的文档
from langchain_community.document_loaders import (
    TextLoader,
    PyPDFLoader,
    UnstructuredWordDocumentLoader,
    WebBaseLoader
)

# 加载本地文本文件
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 中的加载器而不是自己实现，因为：

1. 社区维护的加载器经过充分测试
2. 支持自动处理编码、格式转换等复杂问题
3. 统一的错误处理机制

2.2 文本分割器：智能分块的艺术

文本分割器将长文档切割为较小的块（chunks），这是 RAG 系统中最关键也最容易出错的环节。

为什么需要分块？

1. 上下文限制：LLM 有固定的上下文窗口（如 GPT-4 的 128K），但单个文档可能超过这个限制
2. 检索精度：过大的文本块包含太多信息，降低检索相关性
3. 计算效率：小块的嵌入计算和存储更高效

from langchain.text_splitter import RecursiveCharacterTextSplitter

# 创建文本分割器 - 这是最常用的分割策略
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,      # 每个块的最大字符数
    chunk_overlap=200,    # 块之间的重叠字符数
    length_function=len,  # 计算长度的函数
    separators=["\n\n", "\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 以为能保留更多上下文，结果发现：

1. 检索相关性下降 30%（块太大，包含不相关信息）
2. 嵌入计算时间增加 3 倍
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])  # 苹果 vs iPhone
sim2 = cosine_similarity(embeddings[0], embeddings[2])  # 苹果 vs 汽车
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 向量存储：高效检索的基石

向量存储负责保存嵌入向量和元数据，并提供高效的相似性搜索功能。你可以把它想象成一个语义搜索引擎的数据库。

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.save_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 嵌入
sentence-transformers>=2.2.0  # HuggingFace 嵌入

# 其他工具
python-dotenv>=1.0.0  # 环境变量管理

# 安装命令
pip install -r requirements.txt

# 设置环境变量（创建 .env 文件）
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

# 加载环境变量
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. 加载文档（支持多种格式）
        loader = DirectoryLoader(
            self.data_dir,
            glob="**/*.pdf",  # 可以扩展为 **/*.txt, **/*.docx 等
            loader_cls=PyPDFLoader,
            show_progress=True
        )
        documents = loader.load()
        print(f"✅ 加载了 {len(documents)} 个文档")
        
        # 2. 文本分割
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200,
            separators=["\n\n", "\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):
        """向知识库提问"""
        if not self.vectorstore:
            print("❌ 请先构建或加载知识库")
            return None
            
        # 创建检索链
        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