AI创想

标题: Langgraph 的 Planning Agent 深度解析 [打印本页]
作者: 创想小编    时间: 昨天 09:52
标题: Langgraph 的 Planning Agent 深度解析
作者：Gavana.
        在人工智能领域，智能代理（agent）的设计愈发重要。尤其在面对复杂任务时，规划（planning）技术成为智能代理的核心能力之一。Langgraph 是一个专为构建智能代理而设计的框架，结合了自然语言处理（NLP）与规划技术，旨在帮助开发者快速构建具有语言理解能力和决策能力的智能代理。本文将深入探讨 Langgraph 中的 planning agent，包括其设计理念、核心功能、实际应用及详细的代码示例，帮助开发者全面了解这一强大的工具。
目录
1. Langgraph 简介
1.1 什么是 Langgraph
1.1.1 与其他智能代理框架的比较
1.2 Langgraph 的核心组件
1.2.1 语言理解模块
代码示例：基本的语言理解模型配置
1.2.2 知识库
代码示例：如何创建和查询知识库
1.2.3 规划模块
代码示例：简单的计划生成算法
2. Planning Agent 概述
2.1 什么是 Planning Agent
2.2 Planning Agent 的工作流程
2.2.1 目标识别
代码示例：用户输入的处理
2.2.2 环境感知
代码示例：获取和处理环境数据
2.2.3 计划生成
代码示例：计划生成算法的实现
2.2.4 执行与反馈
代码示例：动态调整计划的实现
3. Langgraph 中的 Planning Agent
3.1 规划模块设计
3.1.1 状态表示
3.1.2 计划生成的核心算法
代码示例：计划生成算法的实现
3.2 规划模块的实现
4. 实际应用案例
4.1 任务管理助手
用户输入示例
代理处理过程
代码示例：任务管理助手
5.完整代码示例
5.1 项目架构
5.2 .env文件配置
5.3 agent.py
5.4 graph.py
5.5 plan.py
5.6 运行
6. 未来发展方向
结论
1. Langgraph 简介

1.1 什么是 Langgraph

Langgraph 是一个集成化的框架，旨在简化智能代理的开发过程。它通过提供语言理解、知识管理和规划能力，使开发者能够创建能够与用户进行自然语言交流的智能代理。Langgraph 采用模块化设计，使得每个功能组件都可以独立配置和扩展。
1.1.1 与其他智能代理框架的比较

与其他框架（如 Rasa、Dialogflow）相比，Langgraph 强调规划能力的集成。这意味着在 Langgraph 中，开发者不仅可以处理用户的输入，还能为代理生成复杂的行动计划。例如，在 Rasa 中，虽然可以处理对话流，但在执行多个任务时，往往需要额外的逻辑支持。而 Langgraph 的规划模块能够动态生成行动计划，使得智能代理在面对复杂场景时表现得更为灵活。
1.2 Langgraph 的核心组件

Langgraph 的核心组件包括语言理解模块、知识库和规划模块。
1.2.1 语言理解模块

语言理解模块负责解析用户的自然语言输入，将其转化为可供计算机处理的结构化信息。这一模块使用先进的自然语言处理技术，如意图识别和实体抽取，帮助代理理解用户的需求。
功能与实现方式
代码示例：基本的语言理解模型配置
  1. from langgraph.nlp import LanguageUnderstandingModel
  3. # 创建语言理解模型
  4. lu_model = LanguageUnderstandingModel()
  6. # 配置模型参数
  7. lu_model.set_intent_recognition(['book_hotel', 'check_weather'])
  8. lu_model.set_entity_extraction(['location', 'date', 'time'])
  10. # 示例输入
  11. user_input = "我想在明天预定一家酒店"
  12. parsed_result = lu_model.parse(user_input)
  14. print(parsed_result)  # 输出：{'intent': 'book_hotel', 'entities': {'date': '明天'}}
复制代码
1.2.2 知识库

知识库用于存储和管理智能代理所需的知识信息。通过知识图谱的形式，代理能够快速查询相关信息并为用户提供准确的答案。
知识库的结构与管理
代码示例：如何创建和查询知识库
  1. from langgraph.knowledge import KnowledgeBase
  3. # 创建知识库
  4. knowledge_base = KnowledgeBase()
  6. # 添加知识
  7. knowledge_base.add_fact('hotel_in_paris', {'name': '巴黎酒店', 'location': '巴黎', 'rating': 5})
  8. knowledge_base.add_fact('weather_in_paris', {'condition': '晴', 'temperature': '25°C'})
  10. # 查询知识
  11. hotel_info = knowledge_base.query('hotel_in_paris')
  12. print(hotel_info)  # 输出：{'name': '巴黎酒店', 'location': '巴黎', 'rating': 5}
复制代码
1.2.3 规划模块

规划模块是 Langgraph 的核心，负责根据用户的目标生成相应的行动计划。它结合了多种规划算法，使代理能够根据环境变化实时调整计划。
规划的基本原理
代码示例：简单的计划生成算法
  1. from langgraph.planning import PlanningAgent
  3. # 创建规划代理
  4. planning_agent = PlanningAgent()
  6. # 设置初始状态和目标
  7. initial_state = {'user_intent': 'book_hotel', 'available_hotels': ['巴黎酒店', '伦敦酒店']}
  8. goal_state = {'action': 'book', 'hotel': '巴黎酒店'}
  10. # 生成计划
  11. plan = planning_agent.generate_plan(initial_state, goal_state)
  12. print(plan)  # 输出：['查询酒店', '确认预定', '发送确认信息']
复制代码
2. Planning Agent 概述

2.1 什么是 Planning Agent

Planning agent 是一种智能代理，能够根据特定目标生成可执行的行动计划。与传统的基于规则的代理相比，planning agent 具备更高的灵活性和适应性，能够处理复杂的决策和动态环境。
2.2 Planning Agent 的工作流程

Planning agent 的工作流程可以分为以下几个步骤：
2.2.1 目标识别

在目标识别阶段，planning agent 解析用户输入，确定用户的意图和期望的目标。这一过程依赖于语言理解模块的准确性。
代码示例：用户输入的处理
  1. user_input = "我想在周末去巴黎旅行"
  2. parsed_input = lu_model.parse(user_input)
  4. # 从解析结果中提取意图
  5. user_intent = parsed_input['intent']
  6. print(user_intent)  # 输出：'book_travel'
复制代码
2.2.2 环境感知

环境感知阶段，planning agent 收集当前的环境状态信息。这包括可用的资源、外部条件和限制。
代码示例：获取和处理环境数据
  1. # 假设环境数据包含可用酒店和天气信息
  2. environment_data = {
  3.     'available_hotels': ['巴黎酒店', '伦敦酒店'],
  4.     'weather': {'condition': '晴', 'temperature': '25°C'}
  5. }
  7. # 代理收集环境状态
  8. planning_agent.set_environment(environment_data)
复制代码
2.2.3 计划生成

计划生成是 planning agent 的核心任务。基于目标和当前环境状态，生成一系列可行的行动计划。
代码示例：计划生成算法的实现
  1. # 生成计划
  2. goal_state = {'action': 'book', 'destination': '巴黎'}
  3. plan = planning_agent.generate_plan(environment_data, goal_state)
  5. print(plan)  # 输出：['查询可用酒店', '选择酒店', '确认预定']
复制代码
2.2.4 执行与反馈

执行阶段，planning agent 根据生成的计划逐步执行，并根据反馈调整计划。例如，如果用户选择了不同的酒店，代理需要实时更新计划。
代码示例：动态调整计划的实现
  1. # 执行第一个行动
  2. action = plan[0]  # '查询可用酒店'
  3. response = execute_action(action)  # 假设这是执行行动的函数
  5. # 根据用户的反馈调整计划
  6. if response == '用户选择了不同的酒店':
  7.     plan = planning_agent.update_plan(new_hotel_choice='伦敦酒店')
复制代码
3. Langgraph 中的 Planning Agent

3.1 规划模块设计

Langgraph 的规划模块使用多种算法来生成和优化计划。以下是其主要设计思路。
3.1.1 状态表示

规划模块首先需要定义状态表示。状态可以是一个复杂的数据结构，包含当前任务的所有相关信息，例如用户输入、当前环境状态等。
3.1.2 计划生成的核心算法

计划生成采用启发式搜索和图搜索等方法，使得生成的计划更加高效。启发式算法能够通过评估可能的行动，优先考虑最有希望的路径，而图搜索则能够全面探索状态空间。
代码示例：计划生成算法的实现

以下是一个简单的计划生成算法的代码示例：
  1. class PlanningAgent:
  2.     def __init__(self, initial_state, goal_state):
  3.         self.initial_state = initial_state
  4.         self.goal_state = goal_state
  6.     def heuristic(self, state):
  7.         # 计算当前状态与目标状态的差异
  8.         return abs(state - self.goal_state)
  10.     def a_star_search(self):
  11.         open_set = {self.initial_state}
  12.         came_from = {}
  13.         g_score = {self.initial_state: 0}
  14.         f_score = {self.initial_state: self.heuristic(self.initial_state)}
  16.         while open_set:
  17.             current = min(open_set, key=lambda x: f_score.get(x, float('inf')))
  18.             if current == self.goal_state:
  19.                 return self.reconstruct_path(came_from, current)
  21.             open_set.remove(current)
  22.             for neighbor in self.get_neighbors(current):
  23.                 tentative_g_score = g_score[current] + self.cost(current, neighbor)
  24.                 if tentative_g_score < g_score.get(neighbor, float('inf')):
  25.                     came_from[neighbor] = current
  26.                     g_score[neighbor] = tentative_g_score
  27.                     f_score[neighbor] = g_score[neighbor] + self.heuristic(neighbor)
  28.                     open_set.add(neighbor)
  30.         return None  # 如果没有找到路径
  32.     def get_neighbors(self, state):
  33.         # 返回当前状态的邻居状态
  34.         # 这部分逻辑依赖于具体应用
  35.         pass
  37.     def cost(self, current, neighbor):
  38.         # 计算从当前状态到邻居状态的成本
  39.         return 1  # 简化示例，假设每个步骤成本相同
  41.     def reconstruct_path(self, came_from, current):
  42.         total_path = [current]
  43.         while current in came_from:
  44.             current = came_from[current]
  45.             total_path.append(current)
  46.         return total_path[::-1]  # 反转路径
复制代码
3.2 规划模块的实现

规划模块的实现包含多个步骤，从定义状态到执行计划。开发者可以根据具体需求，定制状态表示、成本函数和邻居生成逻辑。
4. 实际应用案例

4.1 任务管理助手

一个常见的应用场景是任务管理助手。用户可以通过自然语言与代理交互，要求代理为他们安排会议、提醒待办事项等。
用户输入示例

代理处理过程

代码示例：任务管理助手

以下是任务管理助手的简单实现：
  1. class TaskManagerAgent(PlanningAgent):
  2.     def __init__(self, initial_state, goal_state, calendar):
  3.         super().__init__(initial_state, goal_state)
  4.         self.calendar = calendar  # 用户的日历
  6.     def identify_goal(self, user_input):
  7.         # 识别用户的目标
  8.         if "安排会议" in user_input:
  9.             return "schedule_meeting"
  10.         elif "提醒我" in user_input:
  11.             return "set_reminder"
  12.         return None
  14.     def execute_task(self, task):
  15.         if task == "schedule_meeting":
  16.             # 具体的安排逻辑
  17.             print("会议已安排在：", self.goal_state)
  18.         elif task == "set_reminder":
  19.             print("提醒已设置在：", self.goal_state)
  21. # 示例用法
  22. calendar = {}  # 用户的日历
  23. task_manager = TaskManagerAgent(initial_state=None, goal_state="2024-09-30 10:00", calendar=calendar)
  24. task_manager.execute_task(task_manager.identify_goal("帮我安排一个明天的会议。"))
复制代码
5.完整代码示例

根据官方博客：Plan-and-Execute (langchain-ai.github.io)
以及GitHub代码地址：主要的 langgraph/docs/docs/tutorials/plan-and-execute/plan-and-execute.ipynb ·langchain-ai/语言图 ·GitHub的
完整的运行文件如下：
5.1 项目架构

(, 下载次数: 0)


5.2 .env文件配置
  1. OPENAI_API_KEY=sk-proj-tfV9dwAWhKhtI7pjT2U3T3BlbkFJvnYXOW8AHhh3cVgO370I
  2. TAVILY_API_KEY=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
  3. LANGSMITH_API_KEY=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
复制代码
其中第二个是Tavily搜索的api key，需要创建账号并自己申请；第三个是检控LangChain运行的api key，课查看官方博客了解具体作用。
5.3 agent.py
  1. import os  # 导入操作系统模块
  3. from langchain_core.messages import HumanMessage  # 从 langchain_core 导入 HumanMessage 类
  5. # 设置 API 密钥
  6. from dotenv import load_dotenv
  8. # 加载环境变量
  9. load_dotenv()
  12. from langchain import hub  # 从 langchain 导入 hub 模块
  13. from langchain_openai import ChatOpenAI  # 从 langchain_openai 导入 ChatOpenAI 类
  14. from langgraph.prebuilt import create_react_agent  # 从 langgraph.prebuilt 导入 create_react_agent 函数
  15. from langchain_community.tools.tavily_search import TavilySearchResults  # 从 langchain_community.tools 导入 TavilySearchResults 类
  17. # 创建 LLM 实例
  18. llm = ChatOpenAI(model="gpt-4-turbo-preview")  # 实例化 ChatOpenAI，使用 gpt-4-turbo-preview 模型
  20. # 定义工具，使用 Tavily 搜索工具
  21. tools = [TavilySearchResults(max_results=3)]  # 设置最大结果为 3
  22. search_agent_executor = create_react_agent(llm, tools, state_modifier="你是一个有用的Agent,可以在线搜索")  # 创建代理执行器
  25. # 可选：调用代理并打印响应
  26. # response = search_agent_executor.invoke({"messages": [("user", "who is the winner of the us open")]})  # 调用代理，询问 US Open 胜者
  27. # print(response)  # 打印响应
复制代码
5.4 graph.py
  1. import asyncio
  2. from typing import Literal
  3. from agent import search_agent_executor
  4. from plan import PlanExecute, replanner, Response, planner
  5. from langgraph.graph import StateGraph, START
  6. # 设置 API 密钥
  7. from dotenv import load_dotenv
  9. # 加载环境变量
  10. load_dotenv()
  13. async def execute_step(state: PlanExecute):
  14.     plan = state["plan"]  # 获取当前的计划
  15.     plan_str = "\n".join(f"{i+1}. {step}" for i, step in enumerate(plan))  # 将计划格式化为字符串
  16.     task = plan[0]  # 获取当前的任务
  17.     task_formatted = f"""For the following plan:
  18. {plan_str}\n\nYou are tasked with executing step {1}, {task}."""  # 构造执行任务的提示
  19.     agent_response = await search_agent_executor.ainvoke(
  20.         {"messages": [("user", task_formatted)]}  # 发送消息给代理执行任务
  21.     )
  22.     return {
  23.         "past_steps": [(task, agent_response["messages"][-1].content)],  # 返回过去的步骤
  24.     }
  26. async def plan_step(state: PlanExecute):
  27.     plan = await planner.ainvoke({"messages": [("user", state["input"])]})  # 调用 planner 获取计划
  28.     return {"plan": plan.steps}  # 返回计划步骤
  30. async def replan_step(state: PlanExecute):
  31.     output = await replanner.ainvoke(state)  # 调用 replanner 进行重新规划
  32.     if isinstance(output.action, Response):  # 如果输出是响应
  33.         return {"response": output.action.response}  # 返回响应
  34.     else:
  35.         return {"plan": output.action.steps}  # 返回新的计划步骤
  37. def should_end(state: PlanExecute) -> Literal["agent", "__end__"]:  # 判断流程是否结束
  38.     if "response" in state and state["response"]:  # 检查是否有响应
  39.         return "__end__"  # 如果有，结束流程
  40.     else:
  41.         return "agent"  # 否则继续代理
  43. # 创建状态图
  44. workflow = StateGraph(PlanExecute)
  46. # 添加计划节点
  47. workflow.add_node("planner", plan_step)
  49. # 添加执行步骤
  50. workflow.add_node("agent", execute_step)
  52. # 添加重新规划节点
  53. workflow.add_node("replan", replan_step)
  55. workflow.add_edge(START, "planner")  # 从起始节点到计划节点
  57. # 从计划节点到执行节点
  58. workflow.add_edge("planner", "agent")
  60. # 从执行节点到重新规划节点
  61. workflow.add_edge("agent", "replan")
  63. workflow.add_conditional_edges("replan", should_end)  # 添加条件边，判断是否结束
  65. # Finally, we compile it!
  66. # This compiles it into a LangChain Runnable,
  67. # meaning you can use it as you would any other runnable
  68. app = workflow.compile()
  70. # 可视化状态图
  71. img_path = "graph.png"
  72. graph_image = app.get_graph(xray=True).draw_mermaid_png()  # 直接获取图像数据
  74. with open(img_path, "wb") as img_file:
  75.     img_file.write(graph_image)  # 保存为文件
  77. from IPython.display import Image, display
  78. display(Image(img_path))  # 读取并显示文件
  82. # 运行应用程序
  83. config = {"recursion_limit": 50}
  84. inputs = {"input": "what is the hometown of the mens 2024 Australia open winner?"}
  87. # 处理事件流
  88. async def main():
  89.     async for event in app.astream(inputs, config=config):
  90.         for k, v in event.items():
  91.             if k != "__end__":
  92.                 print(v)
  95. # 运行主程序
  96. if __name__ == "__main__":
  97.     asyncio.run(main())
复制代码
5.5 plan.py
  1. # 导入所需的库
  2. import operator
  3. import os
  4. from typing import Annotated, List, Tuple, TypedDict
  5. from langchain_openai import ChatOpenAI  # 导入OpenAI的聊天模型
  6. # 设置 API 密钥
  7. from dotenv import load_dotenv
  9. # 加载环境变量
  10. load_dotenv()
  12. # 定义状态类
  13. class PlanExecute(TypedDict):
  14.     input: str  # 用户输入
  15.     plan: List[str]  # 计划的步骤列表
  16.     past_steps: Annotated[List[Tuple], operator.add]  # 已执行的步骤
  17.     response: str  # 最终响应
  19. from pydantic import BaseModel, Field  # 导入Pydantic用于数据模型
  21. # 定义计划模型
  22. class Plan(BaseModel):
  23.     """Plan to follow in future"""  # 用于未来执行的计划
  25.     steps: List[str] = Field(
  26.         description="different steps to follow, should be in sorted order"  # 描述计划的步骤，应该是有序的
  27.     )
  29. from langchain_core.prompts import ChatPromptTemplate  # 导入提示模板
  31. # 定义规划提示模板
  32. planner_prompt = ChatPromptTemplate.from_messages(
  33.     [
  34.         (
  35.             "system",
  36.             """For the given objective, come up with a simple step by step plan. \
  37. This plan should involve individual tasks, that if executed correctly will yield the correct answer. Do not add any superfluous steps. \
  38. The result of the final step should be the final answer. Make sure that each step has all the information needed - do not skip steps.""",
  39.         ),
  40.         ("placeholder", "{messages}"),
  41.     ]
  42. )
  44. # 创建规划实例
  45. planner = planner_prompt | ChatOpenAI(
  46.     model="gpt-4o", temperature=0  # 使用OpenAI的GPT模型，设置温度为0以确保一致性
  47. ).with_structured_output(Plan)
  49. # 调用规划器生成计划
  50. planner.invoke(
  51.     {
  52.         "messages": [
  53.             ("user", "what is the hometown of the current Australia open winner?")  # 用户询问的问题
  54.         ]
  55.     }
  56. )
  58. # 重新规划部分
  59. from typing import Union  # 导入Union类型
  61. # 定义响应类
  62. class Response(BaseModel):
  63.     """Response to user."""  # 响应用户的类
  65.     response: str  # 响应内容
  67. # 定义动作类
  68. class Act(BaseModel):
  69.     """Action to perform."""  # 要执行的动作类
  71.     action: Union[Response, Plan] = Field(
  72.         description="Action to perform. If you want to respond to user, use Response. "
  73.         "If you need to further use tools to get the answer, use Plan."  # 描述动作的类型
  74.     )
  77. # 定义重新规划的提示模板
  78. replanner_prompt = ChatPromptTemplate.from_template(
  79.     """For the given objective, come up with a simple step by step plan. \
  80. This plan should involve individual tasks, that if executed correctly will yield the correct answer. Do not add any superfluous steps. \
  81. The result of the final step should be the final answer. Make sure that each step has all the information needed - do not skip steps.
  83. Your objective was this:
  84. {input}
  86. Your original plan was this:
  87. {plan}
  89. You have currently done the follow steps:
  90. {past_steps}
  92. Update your plan accordingly. If no more steps are needed and you can return to the user, then respond with that. Otherwise, fill out the plan. Only add steps to the plan that still NEED to be done. Do not return previously done steps as part of the plan."""
  93. )
  96. replanner = replanner_prompt | ChatOpenAI(
  97.     model="gpt-4o", temperature=0
  98. ).with_structured_output(Act)
复制代码
5.6 运行

直接运行graph.py文件就行啦，更改输入也是在graph.py文件中~
6. 未来发展方向

Langgraph 提供了一个强大的框架，用于构建具有规划能力的智能代理。通过灵活的设计和强大的功能，开发者能够快速实现复杂的任务规划。本文详细探讨了 planning agent 的概念、构建过程和实际应用，旨在帮助开发者深入理解这一技术。随着人工智能的持续发展，Langgraph 和 planning agent 也将迎来更多可能，值得持续关注和研究。
结论

Langgraph 的 planning agent 提供了一种强大的方式来构建智能代理。通过有效的规划和动态调整，智能代理能够在复杂的任务中表现出色。本文详细介绍了 Langgraph 的核心组件、规划模块的设计以及实际应用案例，为开发者在构建智能代理时提供了实用的参考。

原文地址：https://blog.csdn.net/TaloyerG/article/details/142546057



欢迎光临 AI创想 (https://www.llms-ai.com/) Powered by Discuz! X3.4