ARTICLE DETAIL

资讯详情

深耕网站建设、视觉设计与SEO优化的一线实战洞察。

工作流04——代理式 RAG(检索增强生成)系统

工作流04——代理式 RAG(检索增强生成)系统

4.1 案例介绍

还记得我们在 LangChain 篇章中,编写过 LCEL 链式的RAG系统。整个系统就是一条直线:
它适合初学者,因为:
  • 概念少:只需要理解 Runnable,StrOutputParser 等基础概念
  • 逻辑简单:线性流程,易于理解和调试
  • 代码直观:一眼就能看懂数据流动
  • 快速上手:几分钟就能跑通整个流程
而在 LangGraph 篇章中,我们将会构建一个智能的文档问答系统 (复杂版),它能够根据检索结果的质量、动态调整查询策略。逻辑如下图所示:
举个例子:这里我们提供相关的几篇课程宣传文档,作为知识库。

可以支持我们询问:

  • "比特提供了哪些课程"
  • "Java开发方向的课程安排"
  • "测试开发方向的主线课程有哪些"
  • "C++开发方向的项目列表"
  • "Redis课程内容是什么"

当用户询问 "比特提供了哪些课程" 时,根据要求,会经历:

  1. 模型决定调用检索工具,搜索"比特课程"
  2. 检索到相关文档后进行评估
  3. 如果文档相关,直接生成答案
  4. 如果文档不相关,重写问题后重新检索

这个设计确保了即使初次检索不成功,系统也能通过重写查询来改进结果质量,比传统RAG系统更加鲁棒。
鲁棒性:是指系统在面对各种内外部干扰时,仍能保持其性能稳定的能力。
具体来说:它描述了系统在不确定性、噪声、误差或其他不利因素下的表现。
鲁棒性与稳定性不同,稳定性关注系统在扰动消失后的恢复,而鲁棒性关注在持续扰动下的表现。
在模型中,鲁棒性指的是模型在陌生环境或噪声干扰下,依旧能够完成预期任务的能力。在控制系统中,鲁棒性是指系统在一定参数摄动下维持性能的特性,是现代控制系统设计的重要指标。
因此,相较于 LangChain 篇章中链式的RAG:"怎么让RAG跑起来",该案例将学习"怎么让RAG跑得更好、更智能"!

4.2 编码思路

构建一个智能文档问答系统,我们要将复杂流程分解为离散步骤,且通过共享状态连接各个节点。
核心设计思路如下:
  1. 模块化设计:每个节点只做一件事,职责清晰
  2. 质量闭环:检索 >检查 >优化 >再检索,确保答案质量
  3. 智能路由:AI自主决定下一步行动,无需人工干预
因此,我们需要:
第一步:准备"知识库"(数据加载与处理)
第二步:创建"检索工具"
第三步:设计"工作流程节点"
  • 节点1: 决策节点 generate_query_or_respond
  • 节点2:检索器工具节点 retrieve
  • 节点3:问题优化节点 rewrite_question
  • 节点4:答案生成节点 generate_answer
第四步:组装"工作流水线”
条件边1:LLM决策是否需要进行知识库检索
条件边2:检测【检索到的文档】是否与【问题】相关
最终Graph示意图:

4.3 代码实现

4.3.1 步骤一:准备”知识库”并创建"检索工具”

1、聊天模型与嵌入模型

model = init_chat_model("gpt-4o-mini") embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

2、读取 4 个文件,用 LangChain 加载成文档对象,然后把「每个文件各自一组 Document」的嵌套列表,摊平成一整个文档对象列表,后面一般紧接着做文本切分、向量化、存入向量库,用于 RAG 检索。

# 加载文档列表 paths = [ "../bit/企业介绍.md", "../bit/C++开发方向.md", "../bit/Java开发方向.md", "../bit/测试开发方向.md" ] # .load() 返回的是 `List[Document]`(文档对象列表) docs = [UnstructuredMarkdownLoader(path).load() for path in paths] docs_list = [item for sublist in docs for item in sublist]

Python 嵌套列表推导式

docs_list = [item for sublist in docs for item in sublist] # 相当于: docs_list = [] # 第一层循环:遍历docs里面的每一个子列表sublist for sublist in docs: # 第二层循环:遍历子列表里面每一个Document对象item for item in sublist: docs_list.append(item) # sublist:就是每个文件加载出来的文档列表 # item:就是单个Document对象 # 把多个文件各自加载出来的文档列表,合并成一个只有 Document 对象的一维列表,方便后面一次性做文本切分。 # 模拟docs,两个文件,每个文件加载得到一组文档 docs = [["文件1文档A","文件1文档B"], ["文件2文档C"]] docs_list = [item for sublist in docs for item in sublist] print(docs_list) #输出:['文件1文档A', '文件1文档B', '文件2文档C']

3、基于tiktoken的cl100k_base编码,以token数量为标准,把文档对象列表切分成块大小1000、重叠50的文本分片,得到分割后的文档分片列表doc_splits。

# 使用 tiktoken 编码器来计算长度的文本分割器。 # 基于 token 数量来切分文本,而不是单纯按字符个数切 text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder( encoding_name="cl100k_base", chunk_size=1000, chunk_overlap=50 ) doc_splits = text_splitter.split_documents(docs_list)

4、把分割好的文档分片通过embedding向量化存入内存向量库

# 使用内存中向量存储和 OpenAI 嵌入 vectorstore = InMemoryVectorStore.from_documents( documents=doc_splits, embedding=embeddings )

5、构建取2条最相关结果的检索器,并封装成名为 retrieve_bit 、用于查询比特就业课信息的 LangChain 检索工具。

# 使用 LangChain 的预构建 create_retriever_tool 创建检索器工具: retriever = vectorstore.as_retriever(search_kwargs={"k": 2}) retriever_tool = create_retriever_tool( retriever, "retrieve_bit", "搜索并返回有关比特就业课的信息。", )
.as_retriever():把向量库包装成检索器(Retriever),专门做向量相似度检索。

search_kwargs={"k":2}:检索时返回相似度最高的 2 个文档片段 (chunk)

create_retriever_tool():这是 LangChain 内置工具函数:把 Retriever 检索器,包装成 Agent 可以调用的工具(Tool)用于创建一个基于文档检索的工具,参数说明:

  • retriever:BaseRetriever-检索器实例,负责实际的文档检索
  • name:str-工具名称,传递给语言模型,需要唯一且具有描述性
  • description:str-工具描述,帮助语言模型理解何时使用该工具

该方法返回 Tool 对象,其继承了 BaseTool。 BaseTool 是所有 LangChain 工具的基础类。执行工具时可使用 invoke() 方法,而执行参数则是检索器执行参数。

6、定义工具返回结构

return Tool( name=name, description=description, func=func, coroutine=afunc, args_schema-RetrieverInput, response_format=response_format, )

6、准备 5 条测试查询,循环调用检索工具检索比特课程信息,打印查询、结果预览(截断至 100 字符)与结果字符长度。

# 测试 test_queries = [ "比特提供了哪些课程", "Java开发方向的课程安排", "测试开发方向的主线课程有哪些", "C++开发方向的项目列表", "Redis课程内容是什么" ] for query in test_queries: print("-" * 50) print(f"查询: {query}\n") result = retriever_tool.invoke({"query": query}) # 只显示前100个字符,避免输出过长 content_preview = result[:100] + "..." if len(result) > 100 else result print(f"结果预览: {content_preview}") print(f"结果长度: {len(result)} 字符")

4.3.2 步骤二:设计"工作流程节点”

根据Graph示意图,设计出以下四个节点:
节点1:决策节点 generate_query_or_respond
节点2:检索器工具节点 retrieve
节点3:问题优化节点 rewrite_question
节点4:答案生成节点 generate_answer


4.3.2.1 节点1:决策节点 _ generate_query_or_respond
该节点核心设计:
  • 决定是llm直接回答还是检索文档
  • 可以使用 model.bind_tools([retriever_tool]),让模型能够调用检索工具
def generate_query_or_respond(state: MessagesState): """调用模型以基于当前状态生成响应。 给定问题,它将决定使用检索工具检索,或者简单地响应用户。""" response = ( model.bind_tools([retriever_tool]).invoke(state["messages"]) ) return {"messages": [response]}
其中 MessagesState 是 LangGraph 中给我们写好只包含 messages 的 State,可以直接使用。
class MessagesState(TypedDict): messages: Annotated[list[AnyMessage], add_messages]

测试 generate_query_or_respond 方法返回值:

input_messages = { "messages": [ { "role": "user", "content": "比特提供了哪些课程?", } ] } # 拿到返回消息列表的最后一条消息,美化打印输出。 generate_query_or_respond(input_messages)["messages"][-1].pretty_print() # 输出: # ================================== Ai Message ================================== # Tool Calls: # retrieve_bit (call_hNvMsOUD3MFKEXwX1Tzqahw1) # Call ID: call_hNvMsOUD3MFKEXwX1Tzqahw1 # Args: # query: 比特课程

从结果看来,根据我们的输入:比特提供了哪些课程?,LLM决定继续检索文档,且设置好了初次的查询字符串 query!


4.3.2.2 节点2:检索器工具节点 _ retrieve
前面已经创建好了检索器工具。对于节点,可以使用ToolNode类来定义:
from langgraph.prebuilt import ToolNode retrieve_node = ToolNode([retriever_tool])
ToolNode 用于创建 LangGraph 工作流程中执行工具的节点。

4.3.2.3 节点3:问题优化节点 _ rewrite_question
该节点主要负责:当文档不相关时,重写问题以改进检索效果。
REWRITE_PROMPT = ( "查看输入并尝试推断潜在的语义意图/含义。\n" "这是最初的问题:\n" "----\n" "{question}" "\n\n" "提出一个改进后的问题:" ) def rewrite_question(state: MessagesState): """重写原始用户问题""" messages = state["messages"] question = messages[0].content prompt = REWRITE_PROMPT.format(question=question) response = model.invoke([HumanMessage(content=prompt)]) return {"messages": [{"role": "user", "content": response.content}]}
模拟【检索内容与原本问题不相关】的情况,测试一下:
from langchain_core.messages import convert_to_messages input_messages = { "messages": convert_to_messages( [ { "role": "user", "content": "比特提供了哪些课程?", }, { "role": "assistant", "content": "", "tool_calls": [ { "id": "1", "name": "retrieve_bit", "args": {"query": "比特课程"}, } ], }, {"role": "tool", "content": "你好", "tool_call_id": "1"}, ] ) } response = rewrite_question(input_messages) print(response["messages"][-1]["content"]) # 打印结果如下: # 改进后的问题可以是: "我想了解比特所提供的课程有哪些,包括课程内容、目标和学习时长。"

原始用户问句很短:比特提供了哪些课程? 重写后把问题扩写,增加更多检索关键词(课程内容、目标、学习时长),更容易命中向量库里面相关文档片段,属于 RAG 里查询改写(Query Rewrite)优化手段。


4.3.2.4 节点4:答案生成节点 _generate_answer
该节点将基于相关文档生成最终答案,代码如下:
#生成答案 GENERATE_PROMPT = ( "你是负责回答问题的助手。使用以下检索到的上下文片段来回答问题。如果你不知道答案,就说你不知道。最多只用三句话,回答要简明扼要。\n" "Question: {question} \n" "Context: {context}" ) def generate_answer(state: MessagesState): """生成答案""" # 最原始问题 question = state["messages"][0].content # 最新问题的检索结果(保证参考答案准确) context = state["messages"][-1].content prompt = GENERATE_PROMPT.format(question=question, context=context) response = model.invoke([HumanMessage(content=prompt)]) return {"messages": [response]}

4.3.3 步骤三:组装"工作流水线”

4.3.3.1 添加节点与入口点
# 组装Graph workflow = StateGraph(MessagesState) workflow.add_node(generate_query_or_respond) # 名为`retrieve`的节点,绑定检索工具`retriever_tool` workflow.add_node("retrieve", ToolNode([retriever_tool])) workflow.add_node(rewrite_question) workflow.add_node(generate_answer) workflow.add_edge(START, "generate_query_or_respond")
4.3.3.2 条件边1:LLM决策是否需要进行知识库检索
第一条分支用来判断是否需要调用工具,如下图所示:

“是否需要调用工具”的判断,可以使用 `tools_condition()` 方法来决定工作流的路由(等价于手动写的 `should_continue` 方法),规则如下:

  • 如果最后一条 AI 消息包含工具调用,则路由到工具执行节点;
  • 否则,请结束工作流。

该方法返回类型为 `Literal["tools", "__end__"]`,表示:

  • 当最后一条 AI 消息包含工具调用,则返回 `"tools"`
  • 否则返回 `"__end__"`
# 从generate_query_or_respond节点出发,用tools_condition判断 LLM 是否要调用工具; # 需要检索就跳转到retrieve节点,否则就直接结束图流程。 workflow.add_conditional_edges( "generate_query_or_respond", # 评估 LLM 决策 tools_condition, { "tools": "retrieve", # 将条件输出转换为图中的节点 "__end__": END, }, )
4.3.3.3 条件边2:检测【检索到的文档】是否与【问题】相关
该条件边核心在于:
  • 评估检索到的文档与问题的相关性
  • 可以使用【结构化输出】模型返回二元评分
yes:表示检索到的文档与问题相关
no:表示检索到的文档与问题不相关
  • 返回下一步路由决策:generate_answer" 或 "rewrite_question"
# 对文档进行评估 GRADE_PROMPT = ( "你是一个评分员,评估检索到的文档与用户问题的相关性。 \n" "以下是检索到的文档: \n\n {context} \n\n" "以下是用户的问题: {question} \n" "如果文档包含与用户问题相关的关键字或语义,则将其评为相关。 \n" "给出一个二元分数“yes”或“no”,以表明该文档是否与问题相关。" ) class GradeDocuments(BaseModel): """使用二值评分进行相关性检查""" score: str = Field( description="相关性评分: 如果相关则为“yes”,如果不相关则为“no”" ) def grade_documents(state: MessagesState) -> Literal["generate_answer", "rewrite_question"]: """确定检索到的文档是否与问题相关""" question = state["messages"][0].content context = state["messages"][-1].content prompt = GRADE_PROMPT.format(question=question, context=context) response = ( model.with_structured_output(GradeDocuments).invoke( [{"role": "user", "content": prompt}] ) ) score = response.score if score == "yes": return "generate_answer" else: return "rewrite_question" workflow.add_conditional_edges( "retrieve", # 评估代理决策 grade_documents, ["generate_answer", "rewrite_question"], )
4.3.3.4 添加结束点并编译
workflow.add_edge("generate_answer", END) workflow.add_edge("rewrite_question", "generate_query_or_respond") graph = workflow.compile()
4.3.3.5 运行RAG

调用 LangGraph 的stream流式执行图,传入用户问题 :"C++开发方向的项目列表";

遍历每一步节点输出,打印当前节点名称,跳过 rewrite_question 节点,其余节点打印最新消息,节点之间空两行方便调试查看 RAG 每一步流转。

for chunk in graph.stream( { "messages": [HumanMessage(content="C++开发方向的项目列表")] } ): for node, update in chunk.items(): print(f"由节点 {node} 更新消息:") if node != "rewrite_question": update["messages"][-1].pretty_print() print("\n\n") # 输出: 由节点 generate_query_or_respond 更新消息: ============================ Ai Message ============================ Tool Calls: retrieve: retrieve_bit (call_kKhk5pvL33lGneckV1YvMKKt) Call ID: call_kKhk5pvL33lGneckV1YvMKKt Args: query: C++开发方向的项目列表 由节点 retrieve 更新消息: ============================ Tool Message ============================ Name: retrieve_bit ....(检索结果较长,省略显示) 由节点 generate_answer 更新消息: ============================ Ai Message ============================ C++开发方向的项目包括多个层次的挑战项目、标准项目和极简项目。挑战项目如微服务的即时通讯系统和视频点播系统,涵盖复杂功能和技术组件;标准项目包括仿QQ音乐的音乐播放客户端等,适合快速掌握;极简项目则如贪蛇游戏,适合基础薄弱的同学。总共有15个不同规格的项目可供选择。
返回列表