检索增强生成（Retrieval-Augmented Generation ，RAG ）是一种将外部知识检索与大型语言模型生成能力相结合的技术。它允许模型在生成答案时动态引用外部数据源（如文档、数据库），解决LLM 的静态知识局限和幻觉问题。本节将展现RAG 的核心实现步骤和技术细节。

检索增强生成介绍

RAG 是一种结合外部知识检索与大语言模型生成的技术。

（1 ）RAG 的核心目的是解决LLM 的两大痛点：

① 知识时效性不足：LLM 的训练数据有截止时间，无法回答最新信息（如今年的新政策）。

② 幻觉问题：LLM 可能生成错误但看似合理的内容（如虚构学术论文并引用）。

（2 ）RAG 的工作逻辑是：当用户提出问题时，先从外部知识库（如文档、网页、数据库等）中检索与问题相关的信息，再将这些信息作为“上下文”输入LLM ，让LLM 基于检索到的事实生成回答。

（3 ）与微调的区别：微调是通过更新模型参数让LLM “记住”新知识，而RAG 是让LLM “参考”外部知识，更灵活（无须重新训练）、成本更低（适合动态更新的知识库）。

（4 ）应用场景：智能问答（如企业内部文档查询）、客服系统（产品手册检索）、法律/ 医疗咨询（案例库参考）等。

【示例 8.12 】LangChain 框架RAG 流程（LangChain+Qwen ）。

# 安装依赖（终端执行）

# pip install langchain langchain-community chromadb dashscope

# 访问阿里云 DashScope 控制台，创建 API Key ，替换代码中的 your-dashscope-api-key-here

from langchain _ community.document _ loaders import TextLoader

from langchain.text _ splitter import CharacterTextSplitter

from langchain _ community.embeddings import DashScopeEmbeddings  # 👈 替换 QwenEmbeddings

from langchain _ community.vectorstores import Chroma

from langchain.chains import RetrievalQA

from langchain _ community.llms import Tongyi     # Qwen

import os

 

# 设置阿里云 DashScope API Key （必需）

api _ key=os.getenv("DASHSCOPE _ API _ KEY")          # 👈 替换为你自己的 API Key

 

def basic _ rag _ flow():

    # 1. 加载文档 —— 修复编码问题

    loader = TextLoader("example.txt", encoding='utf-8')

    documents = loader.load()

   

    # 2. 分割文档

    text _ splitter = CharacterTextSplitter(chunk _ size=1000, chunk _ overlap=0)

    texts = text _ splitter.split _ documents(documents)

   

    # 3. 创建嵌入和向量存储（使用通义千问的 Embedding 模型）

    embeddings = DashScopeEmbeddings(

        model="text-embedding-v1",  # 阿里云提供的嵌入模型

        api _ key=api _ key,

        dashscope _ api _ key=os.environ["DASHSCOPE _ API _ KEY"]

    )

    vectorstore = Chroma.from _ documents(texts, embeddings)

   

    # 4. 构建检索器

    retriever = vectorstore.as _ retriever()

   

    # 5. 创建 RAG 链（使用通义千问大模型）

    llm = Tongyi(

        model _ name="qwen-max",  # 也可以用 "qwen-plus" "qwen-turbo" 等

        dashscope _ api _ key=os.environ["DASHSCOPE _ API _ KEY"],

        temperature=0.1

    )

   

    qa _ chain = RetrievalQA.from _ chain _ type(

        llm=llm,

        chain _ type="stuff",

        retriever=retriever,

        return _ source _ documents=True  # 可选：返回参考文档

    )

   

    # 6. 执行查询并输出结果

    query = " 请总结文档的主要内容 "

    result = qa _ chain.invoke({"query": query})  # 👈 注意：新版推荐用 invoke

    print(" 问题： ", query)

    print(" 回答： ", result["result"])

   

    # 可选：打印参考文档

    # for doc in result["source _ documents"]:

    #     print(" 参考文档片段： ", doc.page _ content[:200], "...")

   

    return qa _ chain

 

# 调用函数以执行流程

if __ name __ == " __ main __ ":

    basic _ rag _ flow()

运行示例代码，输出如下：

问题： 请总结文档的主要内容

回答： 文档讲述了张伟从贵州山村孩子成长为大学生，并最终回乡致力于改善家乡教育的故事。主要内容包括：  

 

1. 张伟小时候上学条件艰苦，每天要走两小时山路。  

2. 他通过努力考上大学，成为村里第一个大学生。  

3. 毕业后在城市找到高薪工作，但始终关心家乡教育问题。  

4. 五年后辞职回乡当老师，并筹集资金建了一所小学。  

5. 他希望通过自己的努力让山里的孩子不再经历他当年的困难。  

6. 如今学校已有 200 多名学生，教学质量也在逐年提升。

索引、检索和生成

RAG 的完整流程可拆解为索引（Indexing ）、检索（Retrieval ）和生成（Generation ）三个阶段，LangChain 框架对这三个阶段提供了完整的支持。

（1 ）索引（Indexing ）：将原始文档转换为可高效检索的格式。

① 流程：加载文档→分割文本→生成嵌入向量→存储到向量库。

② 目的：让后续检索能快速找到与查询相关的内容。

（2 ）检索（Retrieval ）：根据用户查询从索引中提取相关信息。

① 逻辑：将用户查询转换为向量，与向量库中的文档向量进行相似性计算，返回最相关的片段。

② 关键：确保检索结果的准确性（避免无关信息干扰生成）。

（3 ）生成（Generation ）：结合检索结果与LLM 生成回答。

流程：将“用户查询+ 检索到的上下文”拼接为提示词（Prompt ），输入LLM ，让其基于上下文生成符合事实的回答。

【示例 8.13 】RAG 核心阶段实现（输出依赖于外部文件state_of_the_union.txt ，LangChain+Qwen ）。

# 安装依赖 pip install langchain langchain-community faiss-cpu dashscope

# 获取 DashScope API Key 替换代码中的 "your _ dashscope _ api _ key _ here"

from langchain.indexes import VectorstoreIndexCreator

from langchain _ community.document _ loaders import TextLoader

from langchain.text _ splitter import CharacterTextSplitter

from langchain _ community.embeddings import DashScopeEmbeddings

from langchain _ community.llms import Tongyi

from langchain _ community.vectorstores import FAISS

 

import os

 

# 设置 DashScope API Key （通义千问）

os.environ["DASHSCOPE _ API _ KEY"] = "your _ dashscope _ api _ key _ here"  # 替换为你的真实 API Key

 

def create _ index _ and _ query():

    # 1. 加载文档

    loader = TextLoader("state _ of _ the _ union.txt", encoding="utf-8")  # 确保编码正确

    documents = loader.load()

 

    # 2. 分割文档（可选， VectorstoreIndexCreator 内部也会处理）

    text _ splitter = CharacterTextSplitter(chunk _ size=1000, chunk _ overlap=100)

    texts = text _ splitter.split _ documents(documents)

 

    # 3. 初始化 Qwen 的嵌入模型和 LLM

    embeddings = DashScopeEmbeddings(model="text-embedding-v1")  # Qwen 的嵌入模型

    llm = Tongyi(model="qwen-plus", temperature=0)  # 可选 qwen-turbo, qwen-plus, qwen-max

 

    # 4. 创建向量索引（使用自定义嵌入）

    # 注意： VectorstoreIndexCreator 默认使用 OpenAI ，需传入 embedding 参数

    index _ creator = VectorstoreIndexCreator(

        vectorstore _ cls=FAISS,

        embedding=embeddings,

        text _ splitter=text _ splitter

    )

    index = index _ creator.from _ loaders([loader])

 

    # 5. 查询

    query = "What did the president say about Ketanji Brown Jackson"

    result = index.query _ with _ sources(query, llm=llm)  # 使用 Qwen 生成答案

 

    return result

 

# 运行程序

if __ name __ == " __ main __ ":

    try:

        answer = create _ index _ and _ query()

        print(" ✅ 查询结果： ")

        print(answer)

    except FileNotFoundError:

        print(" ❌ 错误：请确保当前目录下有 'state _ of _ the _ union.txt' 文件。 ")

    except Exception as e:

        print(f" ❌ 运行出错： {e}")

运行代码，输出如下：

✅ 查询结果：

{'question': 'What did the president say about Ketanji Brown Jackson', 'answer': 'The president stated that Judge Ketanji Brown Jackson is an extraordinary legal mind with a deep commitment to justice and fairness, and that her credentials are impeccable and her character beyond reproach. He also noted that she will be the first Black woman ever to sit on the Supreme Court, calling it a historic moment for the nation.\n\n', 'sources': 'state _ of _ the _ union.txt'}

文档和文档加载器

在RAG 中，“文档”是外部知识的载体，通常指包含结构化或非结构化信息的文本片段（如PDF 中的一页、网页中的一段文字）。

（1 ）LangChain 中用Document 类表示文档，包含以下两个核心属性。

① page_content ：文档的文本内容。

② metadata ：文档的附加信息（如来源、页码、作者等，用于后续过滤或溯源）。

（2 ）文档加载器（Document Loaders ）是LangChain 中用于将外部数据源（如本地文件、网页、数据库）转换为Document 对象的工具。其核心功能是：

① 读取数据源（如解析PDF 的二进制内容、爬取网页HTML ）。

② 提取文本（去除格式标签、保留有效内容）。

③ 生成Document （附加元数据，如文件路径、网页URL ）。

LangChain 支持数百种数据源，包括本地文件（TXT 、PDF 、Word ）、网页（URL ）、数据库（SQL 、MongoDB ）、云存储（S3 、Google Drive ）等。

【示例 8.14 】 文档加载器示例。

当前目录存在：

l   example.txt （文本文件）。

l   example.pdf （PDF 文件）。

l   example.csv （CSV 文件）。

l   网络可访问https://example.com 。

实际输出中的Document 对象包含：

l   page_content ：加载的文本内容。

l   metadata ：包含来源信息的字典（文件路径、URL 、页码等）。

from langchain _ community.document _ loaders import (

    TextLoader,

    WebBaseLoader,

    PyPDFLoader,

    CSVLoader,

    UnstructuredFileLoader

)

 

def load _ documents _ examples():

    # 文本文件加载器

    text _ loader = TextLoader("example.txt")

    text _ docs = text _ loader.load()

 

    # 网页加载器

    web _ loader = WebBaseLoader(["https://example.com"])

    web _ docs = web _ loader.load()

 

    # PDF 加载器

    pdf _ loader = PyPDFLoader("example.pdf")

    pdf _ docs = pdf _ loader.load()

 

    # CSV 加载器

    csv _ loader = CSVLoader("example.csv")

    csv _ docs = csv _ loader.load()

 

    return {

        "text": text _ docs,

        "web": web _ docs,

        "pdf": pdf _ docs,

        "csv": csv _ docs

    }

8.5.4  TextLoader 、WebBaseLoader 和pypdfLoader

LangChain 提供了多种具体的文档加载器，以下是三种常用类型。

（1 ）TextLoader ：用于加载纯文本文件（如.txt ）。

① 功能：直接读取文本文件内容，忽略格式（因TXT 本身无复杂格式）。

② 使用示例：

from langchain.document _ loaders import TextLoader 

loader = TextLoader("example.txt", encoding="utf-8")  # 指定文件路径和编码  

documents = loader.load()  # 返回包含 1 个 Document 的列表  

# 若文本包含特殊字符，需指定正确编码（如 GBK ），避免乱码

（2 ）WebBaseLoader ：用于加载网页内容（通过URL ）。

①   功能：爬取网页HTML ，提取正文（自动去除广告、导航等无关内容）。

②   底层依赖：默认使用Requests 爬取+BeautifulSoup 解析，支持处理JavaScript 渲染的页面（需额外安装playwright ）。

③   使用示例：

from langchain.document _ loaders import WebBaseLoader 

loader = WebBaseLoader("https://example.com/article")  # 网页 URL 

documents = loader.load()  # 返回包含网页正文的 Document 

# 部分网站有反爬机制，可能需要设置请求头（ headers ）或使用代理

（3 ）PyPDFLoader ：用于加载PDF 文件（支持多页PDF ）。

①   功能：解析PDF 的每一页，将每页内容转换为一个Document 对象（元数据包含页码）。

②   底层依赖：基于PyPDF2 库，支持提取文本（无法直接处理扫描件PDF ，需先将OCR 转换为     文本）。

③   使用示例：

from langchain.document _ loaders import PyPDFLoader 

loader = PyPDFLoader("report.pdf")  # PDF 文件路径  

documents = loader.load() # 若 PDF 有 5 页，返回包含 5 个 Document 的列表（每页 1 个）

分割器和递归字符文本分割器

原始文档（如100 页PDF ）通常过长（远超LLM 的Token 限制，如GPT-4 的12.8k Token ），且直接检索整段文本精度低。因此，需要使用文本分割器（Text Splitters ）将文档拆分为更小的“片段（Chunk ）”。

1. 分割原则

（1 ）片段长度（Token 数）需适配LLM 的上下文窗口（如拆分为500~1000 Token 的片段）。

（2 ）保留语义完整性（如避免将一句话拆成两段）。

递归字符文本分割器（RecursiveCharacterTextSplitter ）是LangChain 中最常用的分割器，因其能平衡“长度控制”和“语义完整”。

2. 工作步骤

（1 ）预设一组分割符（按优先级排序，如["\n\n","\n"," ",""] ）。

（2 ）尝试用最高优先级分割符拆分文本，若拆分后的片段仍过长，则用下一优先级分隔符。

（3 ）重复步骤（2 ），直到片段长度符合预设值（chunk_size ）。

3. 核心参数

l   chunk_size ：片段的最大长度（默认按字符数，可通过length_function 改为Token 数）。

l   chunk_overlap ：相邻片段的重叠长度（如重叠50 字符，避免拆分语义连贯的内容）。

l   separators ：自定义分隔符（默认适用于英文，中文可添加[" 。"," ；"," ，"] ）。

4. 使用示例

from langchain.text _ splitter import RecursiveCharacterTextSplitter 

splitter = RecursiveCharacterTextSplitter( 

    chunk _ size=500,  # 每个片段最多 500 字符  

    chunk _ overlap=50,  # 重叠 50 字符  

    separators=[" 。 ", " ； ", " ， ", " "]  # 中文分隔符  

) 

chunks = splitter.split _ documents(documents)  # 将 Document 列表拆分为小片段  

嵌入模型

文本片段需转换为向量（Vector ）才能被向量库存储和检索，这个转换过程由嵌入模型（Embedding Model ）完成。

（1 ）嵌入的本质：将文本（如“猫是哺乳动物”）转换为固定长度的数字数组（向量），且语义相似的文本对应的向量距离更近（如“猫”和“狗”的向量比“猫”和“汽车”更接近）。

（2 ）LangChain 支持的嵌入模型：

l   闭源模型：如Qwen 的text-embedding-v1 （精度高，需API 密钥）。

l   开源模型：如HuggingFace 的all-MiniLM-L6-v2 （可本地部署，适合隐私敏感场景）。

（3 ）使用示例（Qwen 嵌入）：

from langchain.embeddings import DashScopeEmbeddings

 

# 初始化通义文本嵌入模型（如 text-embedding-v1 ）

embedding _ model = DashScopeEmbeddings(

    model="text-embedding-v1",  # 或 "text-embedding-v2"

    dashscope _ api _ key="your-dashscope-api-key"  # 替换为你的 DashScope API Key

)

 

# 将查询转换为向量

vector = embedding _ model.embed _ query(" 什么是 RAG ？ ")

 

# 将文本片段转换为向量

chunk _ vectors = embedding _ model.embed _ documents([chunk.page _ content for chunk in chunks])

向量存储库

向量存储库（Vector Store ）是用于存储文本片段向量的数据库，核心功能是高效相似性搜索（给定查询向量，快速找到最相似的文档向量）。轻量级本地向量存储库包括FAISS 、Chroma 等；企业级向量存储库包括Weaviate 、Milvus 、Pinecone 等。

【示例 8.15 】 向量存储实现（LangChain+Qwen ）。

# 安装依赖： pip install langchain langchain-community faiss-cpu chromadb dashscope

# 前往阿里云 DashScope 控制台 → 申请 API Key 替换代码中的： "your _ dashscope _ api _ key _ here"

from langchain _ community.vectorstores import FAISS, Chroma

from langchain _ community.embeddings import DashScopeEmbeddings  # 使用通义千问 Embedding

from langchain _ community.document _ loaders import TextLoader

from langchain.text _ splitter import RecursiveCharacterTextSplitter

import os

 

# 设置 DashScope API Key （请替换为你自己的）

os.environ["DASHSCOPE _ API _ KEY"] = "sk-0d69ee9f99454db9aebb8d50ed16733e"

 

def vector _ store _ example():

    # 加载和分割文档

    loader = TextLoader("state _ of _ the _ union.txt", encoding="utf-8")

    documents = loader.load()

    text _ splitter = RecursiveCharacterTextSplitter(chunk _ size=1000, chunk _ overlap=200)

    texts = text _ splitter.split _ documents(documents)

 

    # 初始化通义千问 Embedding 模型

    embeddings = DashScopeEmbeddings(

        model="text-embedding-v1",  # 通义千问 Embedding 模型名称

        dashscope _ api _ key=os.getenv("DASHSCOPE _ API _ KEY")

    )

 

    # FAISS 向量存储

    faiss _ db = FAISS.from _ documents(texts, embeddings)

    faiss _ db.save _ local("faiss _ index")

   

    # Chroma 向量存储

    chroma _ db = Chroma.from _ documents(texts, embeddings, persist _ directory="./chroma _ db")

 

    # 检索示例

    query = "What did the president say about Ketanji Brown Jackson"

    faiss _ docs = faiss _ db.similarity _ search(query)

    chroma _ docs = chroma _ db.similarity _ search(query)

 

    # 返回前 100 字符作为示例输出

    result = {

        "faiss": [doc.page _ content[:100] + "..." for doc in faiss _ docs] if faiss _ docs else [],

        "chroma": [doc.page _ content[:100] + "..." for doc in chroma _ docs] if chroma _ docs else []

    }

 

    print(" 🔍 FAISS 检索结果 :")

    for i, doc in enumerate(result["faiss"], 1):

        print(f"  {i}. {doc}")

 

    print("\n 🔍 Chroma 检索结果 :")

    for i, doc in enumerate(result["chroma"], 1):

        print(f"  {i}. {doc}")

 

    return result

 

# 运行示例

if __ name __ == " __ main __ ":

    try:

        results = vector _ store _ example()

    except Exception as e:

        print(f" ❌ 错误 : {e}")

运行代码，输出如下：

🔍 FAISS 检索结果 :

  1. My fellow Americans,

 

Tonight, I want to talk about the soul of America — what we believe, what we v...

 

🔍 Chroma 检索结果 :

  1. My fellow Americans,

 

Tonight, I want to talk about the soul of America — what we believe, what we v...

检索器

检索器（Retriever ）是LangChain 中连接“向量存储”与“生成步骤”的接口，负责根据用户的查询从向量存储中提取相关文本片段。

（1 ）核心功能：接收用户查询（文本），返回最相关的文档片段（Document 对象列表）。

（2 ）常用检索方法：

l   相似性搜索（Similarity Search ）：返回与查询向量最相似的top_k 个片段（默认方法）。

l   带分数的相似性搜索：返回片段及相似度分数（0~1 ，分数越高越相关）。

l   最大边际相关性搜索（Maximal Marginal Relevance Search ，MMR ）：在保证相关性的同时，增加片段多样性（避免返回重复内容）。

（3 ）使用示例：

# 从向量存储创建检索器  

retriever = vector _ store.as _ retriever( 

    search _ type="similarity",           # 检索方式  

    search _ kwargs={"k": 3}             # 返回最相关的 3 个片段  

) 

 

# 检索相关片段  

query = "RAG 如何解决 LLM 幻觉问题？ " 

relevant _ chunks = retriever.get _ relevant _ documents(query)  # 返回 3 个相关片段  

【示例 8.16 】 检索器实现。

from langchain.retrievers import (

    MultiQueryRetriever,

    ContextualCompressionRetriever,

    EnsembleRetriever

)

from langchain _ community.retrievers import BM25Retriever

from langchain.retrievers.document _ compressors import LLMChainExtractor

from langchain _ community.vectorstores import FAISS

from langchain _ community.embeddings import HuggingFaceEmbeddings

from langchain _ community.llms import Tongyi

from langchain _ community.document _ loaders import TextLoader

from langchain.text _ splitter import RecursiveCharacterTextSplitter

 

import os

 

# ===== 设置通义千问 API Key =====

os.environ["DASHSCOPE _ API _ KEY"] = "your _ dashscope _ api _ key _ here"  # 请替换为你自己的 API Key

 

def retriever _ examples():

    # 检查文件是否存在

    file _ path = "state _ of _ the _ union.txt"

    if not os.path.exists(file _ path):

        # 如果文件不存在，创建一个示例英文内容（避免程序中断）

        sample _ text = """

        Tonight, I come to talk about unity and resilience.

        Ketanji Brown Jackson is an outstanding nominee for the Supreme Court.

        Her qualifications are impeccable, her character beyond reproach.

        She will make history as the first Black woman on the Supreme Court.

        Let us come together to confirm her with bipartisan support.

        """

        with open(file _ path, 'w', encoding='utf-8') as f:

            f.write(sample _ text)

        print(f" 已自动创建示例文件： {file _ path}")

 

    # 加载文档

    loader = TextLoader(file _ path, encoding='utf-8')

    documents = loader.load()

 

    # 分块

    text _ splitter = RecursiveCharacterTextSplitter(chunk _ size=500, chunk _ overlap=100)

    texts = text _ splitter.split _ documents(documents)

 

    # 初始化 Embedding 模型（中文优化）

    print(" 正在加载 Embedding 模型 BAAI/bge-small-zh-v1.5 ...")

    embeddings = HuggingFaceEmbeddings(

        model _ name="BAAI/bge-small-zh-v1.5",

        model _ kwargs={'device': 'cpu'},

        encode _ kwargs={'normalize _ embeddings': True},

    )

 

    # 创建向量数据库

    print(" 正在构建 FAISS 向量库 ...")

    db = FAISS.from _ documents(texts, embeddings)

 

    # 基础检索器

    base _ retriever = db.as _ retriever(search _ kwargs={"k": 3})

 

    # 初始化通义千问大模型（用于生成和压缩）

    print(" 正在初始化通义千问模型 qwen-plus...")

    llm = Tongyi(temperature=0, model _ name="qwen-plus")

 

    # 1. 多查询检索器

    print(" 构建 MultiQueryRetriever...")

    multi _ retriever = MultiQueryRetriever.from _ llm(

        retriever=base _ retriever, llm=llm

    )

 

    # 2. 上下文压缩检索器

    print(" 构建 ContextualCompressionRetriever...")

    compressor = LLMChainExtractor.from _ llm(llm)

    compression _ retriever = ContextualCompressionRetriever(

        base _ compressor=compressor,

        base _ retriever=base _ retriever

    )

 

    # 3. BM25 稀疏检索器

    print(" 构建 BM25Retriever...")

    bm25 _ retriever = BM25Retriever.from _ documents(texts)

    bm25 _ retriever.k = 2

 

    # 4. 集成检索器（稠密 + 稀疏）

    print(" 构建 EnsembleRetriever...")

    ensemble _ retriever = EnsembleRetriever(

        retrievers=[base _ retriever, bm25 _ retriever],

        weights=[0.5, 0.5]

    )

 

    # 测试查询（英文示例，也可改为中文）

    query = "What did the president say about Ketanji Brown Jackson?"

    print(f"\n 🔍 正在检索 : '{query}'\n")

 

    # 执行检索

    base _ results = base _ retriever.get _ relevant _ documents(query)

    multi _ results = multi _ retriever.get _ relevant _ documents(query)

    compression _ results = compression _ retriever.get _ relevant _ documents(query)

    ensemble _ results = ensemble _ retriever.get _ relevant _ documents(query)

 

    # 格式化输出（截取前 150 字符）

    results = {

        "base": [doc.page _ content[:150].replace('\n', ' ') for doc in base _ results],

        "multi _ query": [doc.page _ content[:150].replace('\n', ' ') for doc in multi _ results],

        "compression": [doc.page _ content[:150].replace('\n', ' ') for doc in compression _ results],

        "ensemble": [doc.page _ content[:150].replace('\n', ' ') for doc in ensemble _ results]

    }

 

    return results

 

 

# 主程序入口

if __ name __ == " __ main __ ":

    try:

        print(" 🚀 开始运行 LangChain 检索器对比示例 ...\n")

 

        results = retriever _ examples()

 

        # 输出结果

        for key, value in results.items():

            print(f"\n{'='*20} {key.upper()} RESULTS {'='*20}")

            if not value:

                print(" ⚠️ 无结果返回 ")

            for i, snippet in enumerate(value, 1):

                print(f"{i}. {snippet}...")

 

        print("\n ✅ 程序运行完成！ ")

 

    except Exception as e:

        print(f" ❌ 程序运行出错 : {e}")

        import traceback

        traceback.print _ exc()

运行代码，输出如下：

🚀 开始运行 LangChain 检索器对比示例 ...

 

已自动创建示例文件： state _ of _ the _ union.txt

正在加载 Embedding 模型 BAAI/bge-small-zh-v1.5 ...

正在构建 FAISS 向量库 ...

正在初始化通义千问模型 qwen-plus...

构建 MultiQueryRetriever...

构建 ContextualCompressionRetriever...

构建 BM25Retriever...

构建 EnsembleRetriever...

 

🔍 正在检索 : 'What did the president say about Ketanji Brown Jackson?'

 

==================== BASE RESULTS ====================

1. Tonight, I come to talk about unity and resilience.  Ketanji Brown Jackson is an outstanding nominee for the Supreme Court.  Her qualifications are impecca...

 

==================== MULTI _ QUERY RESULTS ====================

1. Tonight, I come to talk about unity and resilience.  Ketanji Brown Jackson is an outstanding nominee for the Supreme Court.  Her qualifications are impecca...

 

==================== COMPRESSION RESULTS ====================

1. Ketanji Brown Jackson is an outstanding nominee... Her qualifications are impeccable... first Black woman on the Supreme Court...

 

==================== ENSEMBLE RESULTS ====================

1. Tonight, I come to talk about unity and resilience.  Ketanji Brown Jackson is an outstanding nominee for the Supreme Court.  Her qualifications are impecca...

 

✅ 程序运行完成！

注意事项：

l   API Key ：请替换为你自己的通义千问API Key （从DashScope 控制台获取）。

l   文件：程序会自动创建state_of_the_union.txt 示例文件，如你有自己的文本，可替换它。

l   中文支持：虽然示例查询是英文，但模型和Embedding 支持中文，你可以把query 改为中文    测试。

l   首=次运行较慢：因为要下载BAAI/bge-small-zh-v1.5 模型（约100MB ），请保持网络畅通。

本文节选自《AI Agent智能体开发实践》，获出版社和作者授权发布。