linying

文章目录

基于 LangChain 的知识库问答系统构建与优化

发布日期: 2025-04-16
分类: 大模型 AI
标签: 大模型 AI

引言

在信息爆炸的时代，快速从海量文档中提取答案是一项关键能力。LangChain 是一个强大的开源框架，犹如一位“智能图书管理员”，帮助开发者轻松构建知识库问答系统，结合大型语言模型（LLM）和外部数据源，回答用户提问。本文将深入探讨：

  1. 使用 LangChain 构建知识库问答系统的关键技术组件及实现步骤，带您从零开始搭建一个实用系统。
  2. 如何实现多路召回结果的动态权重分配，提升检索精准度。
  3. 处理 PDF 文档中的表格数据召回问题，解决 RAG 系统的常见痛点。

通过通俗的比喻、详细的代码示例和流程图，我将为您提供一份清晰的“施工蓝图”，无论您是想开发企业知识库、学术问答系统还是个人文档助手，这篇文章都能为您指点迷津。

相关资源：

一、使用 LangChain 构建知识库问答系统的关键技术组件及实现步骤

1. 什么是知识库问答系统？

知识库问答系统是一个智能工具，能从文档、数据库或网页等数据源中检索信息，并结合 LLM 生成自然、准确的回答。想象它像一个“超级档案管理员”：您提出问题，它迅速翻阅“档案”（数据源），找到相关内容，再用流利的语言总结答案。

在 LangChain 中，这种系统通常基于 RAG（检索增强生成） 架构，结合检索（Retrieval）和生成（Generation）两大步骤，确保回答既基于真实数据又符合上下文。

2. 关键技术组件

LangChain 提供了一套模块化工具，像“积木”一样组合成知识库问答系统。以下是核心组件：

  • 文档加载器（Document Loaders）：从 PDF、网页、CSV 等加载原始数据。
  • 文本分割器（Text Splitters）：将长文档切分为小块，适配 LLM 的上下文长度限制。
  • 嵌入模型（Embeddings）：将文本转化为向量表示，用于语义搜索。
  • 向量存储（Vector Stores）：存储文本向量，支持高效检索（如 FAISS、Chroma）。
  • 检索器（Retrievers）：根据用户查询，从向量存储中召回相关文档。
  • 提示词模板（Prompt Templates）：引导 LLM 生成符合预期的回答。
  • 语言模型（LLM/Chat Model）：负责理解查询和生成回答。
  • 记忆（Memory）：保存对话历史，确保多轮对话的上下文连贯。
  • 链（Chains）：如 RetrievalQA 或 ConversationalRetrievalChain，串联检索和生成步骤。

比喻：这些组件就像一个“智能厨房”：

  • 文档加载器是“采购员”，收集食材（数据）。
  • 文本分割器是“刀工”，把食材切成合适的大小。
  • 嵌入模型和向量存储是“冰箱”，把食材分类存放，便于查找。
  • 检索器是“助手”，快速找到所需食材。
  • 提示词和 LLM 是“厨师”，根据食谱（提示）烹饪美味佳肴（答案）。
  • 记忆是“记事本”，记录之前的口味偏好（对话历史）。
  • 链是“流水线”，协调整个烹饪过程。

3. 实现步骤

以下是构建一个基于 LangChain 的知识库问答系统的详细步骤，以企业文档（PDF 格式）为例：

步骤 1：加载文档

使用 PyPDFLoader 从 PDF 文件加载文本内容。

步骤 2：分割文档

使用 RecursiveCharacterTextSplitter 将长文档切分为小块（chunk），确保每个块适合 LLM 的上下文窗口。

步骤 3：向量化文档

使用嵌入模型（如 OpenAI Embeddings）将文本转化为向量，存储在向量数据库（如 FAISS）。

步骤 4：构建检索器

将向量存储转为检索器，基于用户查询召回相关文档。

步骤 5：设置提示词和 LLM

定义提示词模板，调用 LLM（如 GPT-3.5）生成答案。

步骤 6：创建问答链

使用 RetrievalQA 或 ConversationalRetrievalChain，整合检索器、LLM 和记忆。

步骤 7：测试与优化

测试系统效果，优化提示词、分割策略或检索参数。

Mermaid 流程图：

graph TD
    A[用户提问: “2024年公司销售目标？”] --> B[加载 PDF 文档]
    B --> C[分割文档为小块]
    C --> D[向量化并存储到 FAISS]
    D --> E[检索相关文档]
    E --> F[构造提示词]
    F --> G[调用 LLM 生成回答]
    G --> H[保存对话历史]
    H --> I[返回答案: “5000万元”]

4. 代码示例：企业文档问答系统

以下是一个完整的实现，基于公司 PDF 文档回答销售目标相关问题：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.llms import OpenAI
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
import os

# 设置 OpenAI API 密钥
os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

# 步骤 1：加载 PDF 文档
loader = PyPDFLoader("company_docs/report_2024.pdf")
documents = loader.load()

# 步骤 2：分割文档
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,  # 每块最大 1000 字符
    chunk_overlap=200  # 块间重叠 200 字符
)
split_docs = text_splitter.split_documents(documents)

# 步骤 3：向量化文档
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(split_docs, embeddings)

# 步骤 4：构建检索器
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})  # 返回 top-3 文档

# 步骤 5：设置 LLM 和记忆
llm = OpenAI(model_name="gpt-3.5-turbo")
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

# 步骤 6：创建问答链
qa_chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=retriever,
    memory=memory,
    chain_type="stuff"
)

# 步骤 7：测试
query = "2024年的公司销售目标是多少？"
response = qa_chain({"question": query})
print(response["answer"])  # 输出：2024年销售目标是5000万元。

# 多轮对话测试
follow_up = "这个目标比去年高多少？"
response = qa_chain({"question": follow_up})
print(response["answer"])  # 输出：比去年高 10%。

代码解析：

  • 加载与分割：PyPDFLoader 读取 PDF，RecursiveCharacterTextSplitter 按 1000 字符切分，保留 200 字符重叠以保持上下文。
  • 向量化：使用 OpenAI 嵌入模型和 FAISS 存储向量。
  • 检索与生成：ConversationalRetrievalChain 结合检索器、LLM 和记忆，支持多轮对话。
  • 运行准备：
    • 安装依赖： 
      1

      pip install langchain openai pypdf2 faiss-cpu
    • 替换 YOUR_API_KEY 和 PDF 路径。

优化建议：

  • 调整 chunk 大小：根据文档内容调整 chunk_size（500-2000 字符）。
  • 增加检索文档数：修改 search_kwargs={"k": 5} 召回更多文档。
  • 优化提示词：自定义提示词模板，明确要求答案简洁或详细。

资源参考：

二、如何实现多路召回结果的动态权重分配？

1. 什么是多路召回？

多路召回（Multi-Vector Retrieval）是指从多个检索路径（如关键词搜索、语义搜索、BM25）召回候选文档，然后对结果进行融合，以提高召回的全面性和精准度。动态权重分配则是根据查询特点或上下文，自动调整各路召回结果的权重。

比喻：多路召回像在超市采购食材：

  • 每条“通道”（检索方法）提供不同的食材（文档）。
  • 动态权重是“采购清单”的优先级调整，根据需求（查询）决定哪条通道的食材更重要。

2. 为什么需要动态权重？

  • 查询多样性：不同查询对检索方法的需求不同。例如，“公司历史”适合语义搜索，“2024年财报”适合关键词匹配。
  • 结果质量：单一检索可能遗漏关键信息，多路召回更全面，但需合理排序。
  • 上下文相关性：对话历史或用户意图可能影响权重分配。

3. 实现多路召回与动态权重分配

LangChain 支持多种检索器（如 VectorStoreRetriever、BM25Retriever），可以通过 EnsembleRetriever 组合多路召回，并动态调整权重。

关键步骤：

  1. 创建多种检索器（如语义搜索、BM25）。
  2. 使用 EnsembleRetriever 融合结果，设置初始权重。
  3. 根据查询或上下文动态调整权重（通过自定义逻辑或模型预测）。

Mermaid 流程图：

graph TD
    A[用户查询: “2024年销售目标”] --> B[语义搜索: VectorStoreRetriever]
    A --> C[关键词搜索: BM25Retriever]
    B --> D[召回文档集 A]
    C --> E[召回文档集 B]
    D --> F[动态权重分配]
    E --> F
    F --> G[融合排序文档]
    G --> H[输入 LLM 生成答案]
    H --> I[最终答案]

4. 代码示例：多路召回与动态权重

以下是一个结合语义搜索和 BM25 的多路召回系统，动态调整权重：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.retrievers import BM25Retriever, EnsembleRetriever
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
import os

# 设置 OpenAI API 密钥
os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

# 加载和分割文档
loader = PyPDFLoader("company_docs/report_2024.pdf")
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
split_docs = text_splitter.split_documents(documents)

# 创建语义检索器
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(split_docs, embeddings)
semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# 创建 BM25 检索器
bm25_retriever = BM25Retriever.from_documents(split_docs)
bm25_retriever.k = 3

# 动态权重分配逻辑
def get_dynamic_weights(query: str) -> list:
    # 简单示例：如果查询包含年份，增加 BM25 权重
    if any(str(year) in query for year in range(2020, 2026)):
        return [0.3, 0.7]  # [语义, BM25]
    return [0.7, 0.3]  # 默认更依赖语义搜索

# 创建融合检索器
query = "2024年销售目标是多少？"
weights = get_dynamic_weights(query)
ensemble_retriever = EnsembleRetriever(
    retrievers=[semantic_retriever, bm25_retriever],
    weights=weights
)

# 创建问答链
llm = OpenAI(model_name="gpt-3.5-turbo")
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=ensemble_retriever
)

# 测试
response = qa_chain.run(query)
print(response)  # 输出：2024年销售目标是5000万元。

代码解析：

  • 多路召回：VectorStoreRetriever（语义）召回基于嵌入的文档，BM25Retriever 召回基于关键词的文档。
  • 动态权重：get_dynamic_weights 根据查询是否包含年份调整权重（年份查询更依赖 BM25）。
  • 融合：EnsembleRetriever 按权重融合两路结果，输出排序后的文档。
  • 运行准备：需安装 rank_bm25： 
    1

    pip install rank_bm25

进阶优化：

  • 复杂权重逻辑：使用 LLM 或机器学习模型预测权重，基于查询类型（事实性、概括性）。
  • 上下文权重：结合对话历史调整权重，例如连续提问时增加语义权重。
  • 评估指标：使用精确率（Precision）和召回率（Recall）评估融合效果。

资源参考：

三、处理 PDF 文档中的表格数据召回问题

1. 为什么表格数据召回困难？

PDF 文档中的表格数据（如财务报表、产品规格）通常以结构化格式存储，但提取和检索时面临以下挑战：

  • 文本化丢失结构：标准 PDF 解析器（如 PyPDF2）将表格转为纯文本，丢失行列关系。
  • 语义不完整：表格内容（如数字、短语）缺乏上下文，嵌入向量难以捕捉语义。
  • 查询匹配困难：用户查询可能涉及表格的特定单元格（如“第一季度收入”），但检索器召回整页文本。

比喻：表格数据像一张“藏宝图”，信息密集但难以直接解读。标准检索像用放大镜粗略扫描，难以精准定位“宝藏”（单元格）。

2. 解决方案

为解决表格数据召回问题，可以结合以下策略：

  • 表格提取：使用专门的表格解析工具（如 pdfplumber）提取结构化表格。
  • 表格转文本：将表格转为语义友好的文本描述，增强嵌入效果。
  • 混合检索：结合关键词和语义检索，召回表格相关文档。
  • 后处理：对召回文档进行表格解析，提取精确答案。

3. 实现步骤

以下是处理 PDF 表格数据的具体步骤：

步骤 1：提取表格

使用 pdfplumber 提取 PDF 中的表格，保存为结构化数据。

步骤 2：表格转描述

将表格数据转为自然语言描述（如“2024年第一季度收入为1000万元”），便于嵌入和检索。

步骤 3：向量化与索引

将描述文本与原始文档一起向量化，存储在向量数据库。

步骤 4：混合检索

使用 EnsembleRetriever 结合语义和关键词检索。

步骤 5：后处理答案

从召回文档中解析表格，提取精确信息。

Mermaid 流程图：

graph TD
    A[PDF 文档] --> B[提取表格: pdfplumber]
    B --> C[表格转自然语言描述]
    C --> D[与原文一起向量化]
    D --> E[存储到 FAISS]
    E --> F[用户查询: “Q1收入？”]
    F --> G[混合检索: 语义+BM25]
    G --> H[召回文档]
    H --> I[解析表格提取答案]
    I --> J[生成最终答案]

4. 代码示例：处理表格数据的 RAG 系统

以下是一个处理 PDF 表格的 RAG 系统实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from langchain.retrievers import BM25Retriever, EnsembleRetriever
import pdfplumber
import os

# 设置 OpenAI API 密钥
os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

# 步骤 1：提取表格并转为描述
def extract_tables_to_text(pdf_path):
    descriptions = []
    with pdfplumber.open(pdf_path) as pdf:
        for page in pdf.pages:
            tables = page.extract_tables()
            for table in tables:
                # 假设表格第一行是表头
                headers = table[0]
                for row in table[1:]:
                    # 转为描述，如“2024年Q1收入为1000万元”
                    desc = f"{row[0]} {headers[1]}为{row[1]}"
                    descriptions.append(desc)
    return descriptions

# 步骤 2：加载 PDF 和表格描述
pdf_path = "company_docs/report_2024.pdf"
loader = PyPDFLoader(pdf_path)
documents = loader.load()
table_descriptions = extract_tables_to_text(pdf_path)

# 合并文档和表格描述
from langchain.schema import Document
table_docs = [Document(page_content=desc) for desc in table_descriptions]
all_docs = documents + table_docs

# 步骤 3：分割和向量化
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
split_docs = text_splitter.split_documents(all_docs)
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(split_docs, embeddings)

# 步骤 4：创建混合检索器
semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
bm25_retriever = BM25Retriever.from_documents(split_docs)
bm25_retriever.k = 3
ensemble_retriever = EnsembleRetriever(
    retrievers=[semantic_retriever, bm25_retriever],
    weights=[0.5, 0.5]
)

# 步骤 5：创建问答链
llm = OpenAI(model_name="gpt-3.5-turbo")
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=ensemble_retriever
)

# 步骤 6：测试
query = "2024年第一季度收入是多少？"
response = qa_chain.run(query)
print(response)  # 输出：2024年第一季度收入为1000万元。

# 后处理（可选）：直接从表格提取精确数据
def extract_table_answer(query, pdf_path):
    with pdfplumber.open(pdf_path) as pdf:
        for page in pdf.pages:
            tables = page.extract_tables()
            for table in tables:
                for row in table[1:]:
                    if "Q1" in row[0] and "收入" in query:
                        return row[1]
    return None

table_answer = extract_table_answer(query, pdf_path)
if table_answer:
    print(f"精确答案：{table_answer}")  # 输出：1000万元

代码解析：

  • 表格提取：pdfplumber 解析 PDF 表格，extract_tables_to_text 转为描述。
  • 混合检索：EnsembleRetriever 结合语义和 BM25 检索，召回包含表格描述的文档。
  • 后处理：extract_table_answer 直接从表格提取精确值，增强答案准确性。
  • 运行准备： 
    1

    pip install pdfplumber rank_bm25 langchain openai faiss-cpu

优化建议：

  • 表格结构化存储：将表格存入数据库（如 SQLite），支持精确查询。
  • 增强描述：为表格添加上下文（如“财务报表”），提高语义匹配。
  • 多模态支持：结合 OCR 或多模态 LLM 处理复杂表格。

资源参考：

四、总结与进阶学习建议

总结

  • 知识库问答系统：通过文档加载、分割、向量化、检索和生成，LangChain 提供了一站式 RAG 解决方案。
  • 多路召回：EnsembleRetriever 结合语义和关键词检索，动态权重分配提升精准度。
  • 表格数据召回：使用 pdfplumber 提取表格，转化为描述并结合混合检索，解决结构化数据召回难题。

进阶学习建议

  1. 优化 RAG 性能：实验不同的 chunk_size、检索器参数和提示词。
  2. 集成外部工具：结合 LangChain 代理，添加搜索或计算功能。
  3. 探索 LangGraph：对于复杂问答场景，使用 LangGraph 编排动态工作流。
  4. 关注社区：

希望这篇文章为您构建知识库问答系统提供清晰指引！如有问题，欢迎留言交流。

评论 0