AI Agent的规划系统：让Agent更智能地完成任务

最新推荐文章于 2025-04-30 12:42:44 发布
最新推荐文章于 2025-04-30 12:42:44 发布
阅读量598 收藏 7
点赞数 13
文章标签： 人工智能 AI ai agent
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChengFengTech/article/details/145345743
版权

在前面的文章中，我们已经讨论了 AI Agent 的记忆系统和工具调用体系。今天，我想分享一下如何实现规划系统，让 AI Agent 能够更智能地完成复杂任务。

从一个真实需求说起

还记得前段时间，我在开发一个代码重构助手时遇到的场景：

用户：帮我重构这个项目的日志系统，统一使用结构化日志，添加链路追踪。

助手：好的，我来帮你重构。首先修改 logger.py...
（开始修改代码）

用户：等等，你这样直接改可能会影响到其他模块，能不能先分析一下影响范围？

助手：抱歉，你说得对。让我重新规划一下...

这个场景让我意识到：AI Agent 需要像人类工程师一样，在执行任务前先做好规划。不能一上来就写代码，而是要：

  1. 分析需求和影响范围
  2. 制定详细的执行计划
  3. 按步骤有序地执行
  4. 及时处理意外情况

规划系统的设计

经过几轮迭代，我设计了一个相对完善的规划系统：

from typing import List, Dict, Any
from enum import Enum
from datetime import datetime
from pydantic import BaseModel

class TaskStatus(Enum):
    PENDING = "pending"
    IN_PROGRESS = "in_progress"
    COMPLETED = "completed"
    FAILED = "failed"
    BLOCKED = "blocked"

class TaskStep(BaseModel):
    id: str
    description: str
    status: TaskStatus
    dependencies: List[str]
    estimated_time: float
    actual_time: float = 0
    result: Any = None
    error: str = None

class Task(BaseModel):
    id: str
    name: str
    description: str
    steps: List[TaskStep]
    context: Dict[str, Any]
    created_at: datetime
    updated_at: datetime
    status: TaskStatus

class PlanningSystem:
    def __init__(
        self,
        llm,
        tool_registry,
        memory_system
    ):
        self.llm = llm
        self.tool_registry = tool_registry
        self.memory_system = memory_system
        self.tasks: Dict[str, Task] = {}

    async def plan_task(
        self,
        description: str,
        context: Dict[str, Any] = None
    ) -> Task:
        # 1. 分析任务，生成步骤
        steps = await self._generate_steps(
            description,
            context
        )

        # 2. 创建任务
        task = Task(
            id=self._generate_id(),
            name=self._extract_name(description),
            description=description,
            steps=steps,
            context=context or {},
            created_at=datetime.now(),
            updated_at=datetime.now(),
            status=TaskStatus.PENDING
        )

        # 3. 存储任务
        self.tasks[task.id] = task

        return task

    async def execute_task(
        self,
        task_id: str
    ) -> Task:
        task = self.tasks[task_id]
        task.status = TaskStatus.IN_PROGRESS

        try:
            # 1. 获取可执行的步骤
            steps = self._get_executable_steps(task)

            # 2. 并行执行步骤
            results = await asyncio.gather(*[
                self._execute_step(task, step)
                for step in steps
            ])

            # 3. 更新任务状态
            task.updated_at = datetime.now()
            if all(r.status == TaskStatus.COMPLETED for r in results):
                task.status = TaskStatus.COMPLETED
            elif any(r.status == TaskStatus.FAILED for r in results):
                task.status = TaskStatus.FAILED

            return task

        except Exception as e:
            task.status = TaskStatus.FAILED
            raise

    async def _generate_steps(
        self,
        description: str,
        context: Dict[str, Any]
    ) -> List[TaskStep]:
        # 使用 LLM 分析任务，生成步骤
        response = await self.llm.plan(
            task=description,
            context=context,
            available_tools=self.tool_registry.list_tools()
        )

        # 解析响应，创建步骤
        steps = []
        for step in response.steps:
            steps.append(TaskStep(
                id=self._generate_id(),
                description=step.description,
                status=TaskStatus.PENDING,
                dependencies=step.dependencies,
                estimated_time=step.estimated_time
            ))

        return steps

    def _get_executable_steps(
        self,
        task: Task
    ) -> List[TaskStep]:
        # 找出所有依赖已完成的步骤
        executable = []
        for step in task.steps:
            if step.status != TaskStatus.PENDING:
                continue

            if all(
                self._get_step_by_id(task, dep).status == TaskStatus.COMPLETED
                for dep in step.dependencies
            ):
                executable.append(step)

        return executable

    async def _execute_step(
        self,
        task: Task,
        step: TaskStep
    ) -> TaskStep:
        start_time = datetime.now()

        try:
            # 1. 准备执行上下文
            context = self._prepare_context(task, step)

            # 2. 使用 LLM 决定使用哪些工具
            tools = await self.llm.select_tools(
                step=step,
                context=context,
                available_tools=self.tool_registry.list_tools()
            )

            # 3. 执行工具调用
            results = []
            for tool in tools:
                result = await self.tool_registry.get_tool(
                    tool.name
                ).execute(**tool.parameters)
                results.append(result)

            # 4. 更新步骤状态
            step.status = TaskStatus.COMPLETED
            step.result = results

        except Exception as e:
            step.status = TaskStatus.FAILED
            step.error = str(e)

        finally:
            step.actual_time = (
                datetime.now() - start_time
            ).total_seconds()

        return step

    def _prepare_context(
        self,
        task: Task,
        step: TaskStep
    ) -> Dict[str, Any]:
        # 合并任务上下文和前置步骤的结果
        context = task.context.copy()

        # 添加依赖步骤的结果
        for dep_id in step.dependencies:
            dep_step = self._get_step_by_id(task, dep_id)
            if dep_step.result:
                context[f"step_{dep_id}_result"] = dep_step.result

        return context

使用示例：

# 初始化规划系统
planner = PlanningSystem(
    llm=ChatGPT(),
    tool_registry=tool_registry,
    memory_system=memory_system
)

# 创建任务计划
task = await planner.plan_task(
    description="""
    重构项目的日志系统：
    1. 统一使用结构化日志
    2. 添加链路追踪
    3. 确保向后兼容
    """,
    context={
        "project_root": "./src",
        "current_logger": "logging",
        "target_logger": "structlog"
    }
)

# 查看生成的步骤
for step in task.steps:
    print(f"步骤：{step.description}")
    print(f"依赖：{step.dependencies}")
    print(f"预计耗时：{step.estimated_time}分钟")
    print("---")

# 输出：
# 步骤：分析当前日志系统的使用情况
# 依赖：[]
# 预计耗时：15分钟
# ---
# 步骤：设计新的日志接口
# 依赖：['step_1']
# 预计耗时：30分钟
# ---
# 步骤：实现日志适配器
# 依赖：['step_2']
# 预计耗时：45分钟
# ---
# 步骤：修改日志配置
# 依赖：['step_3']
# 预计耗时：20分钟
# ---
# 步骤：更新依赖项
# 依赖：['step_4']
# 预计耗时：10分钟
# ---
# 步骤：添加单元测试
# 依赖：['step_3', 'step_4']
# 预计耗时：40分钟
# ---
# 步骤：进行集成测试
# 依赖：['step_5', 'step_6']
# 预计耗时：60分钟

# 执行任务
result = await planner.execute_task(task.id)

关键设计决策

在实现这个规划系统时，我做了几个重要的设计决策：

1. 任务分解

class TaskAnalyzer:
    def __init__(self, llm):
        self.llm = llm

    async def analyze(
        self,
        description: str,
        context: Dict[str, Any]
    ) -> List[Dict]:
        # 使用 LLM 分析任务
        response = await self.llm.analyze(
            prompt=self._generate_prompt(
                description,
                context
            )
        )

        # 验证步骤的合理性
        steps = self._validate_steps(response.steps)

        # 检查依赖关系
        self._check_dependencies(steps)

        return steps

    def _generate_prompt(
        self,
        description: str,
        context: Dict[str, Any]
    ) -> str:
        return f"""
        请分析以下任务，将其分解为具体的执行步骤：

        任务描述：
        {description}

        上下文信息：
        {json.dumps(context, indent=2)}

        要求：
        1. 每个步骤要具体且可执行
        2. 明确步骤之间的依赖关系
        3. 估计每个步骤的执行时间
        4. 考虑可能的风险和回退方案

        请以 JSON 格式返回结果。
        """

2. 并行执行

class StepExecutor:
    def __init__(
        self,
        tool_registry,
        max_concurrent: int = 5
    ):
        self.tool_registry = tool_registry
        self.semaphore = asyncio.Semaphore(max_concurrent)

    async def execute_steps(
        self,
        steps: List[TaskStep],
        context: Dict[str, Any]
    ) -> List[TaskStep]:
        # 创建执行任务
        tasks = [
            self._execute_with_semaphore(step, context)
            for step in steps
        ]

        # 并行执行
        return await asyncio.gather(*tasks)

    async def _execute_with_semaphore(
        self,
        step: TaskStep,
        context: Dict[str, Any]
    ) -> TaskStep:
        async with self.semaphore:
            return await self._execute_step(step, context)

3. 错误处理

class ErrorHandler:
    def __init__(self, llm):
        self.llm = llm

    async def handle_error(
        self,
        step: TaskStep,
        error: Exception,
        context: Dict[str, Any]
    ) -> TaskStep:
        # 分析错误
        analysis = await self.llm.analyze_error(
            step=step,
            error=str(error),
            context=context
        )

        if analysis.can_retry:
            # 修改参数重试
            step.parameters = analysis.fixed_parameters
            return await self._retry_step(step)
        elif analysis.can_workaround:
            # 使用替代方案
            return await self._execute_workaround(
                step,
                analysis.workaround
            )
        else:
            # 标记失败
            step.status = TaskStatus.FAILED
            step.error = str(error)
            return step

实践心得

在实现和使用这个规划系统的过程中，我总结了几点经验：

  1. 任务分解要合理

    • 粒度要适中
    • 依赖要清晰
    • 考虑并行可能

  2. 执行要有弹性

    • 支持并行执行
    • 优雅处理错误
    • 允许动态调整

  3. 状态管理很重要

    • 及时更新状态
    • 保存执行历史
    • 支持断点恢复

写在最后

一个好的规划系统能让 AI Agent 的行为更加可控和高效。它就像是一个项目经理，懂得如何拆分任务、分配资源、控制风险。

在下一篇文章中，我会讲解如何实现 AI Agent 的多轮对话系统。如果你对规划系统的设计有什么想法，欢迎在评论区交流。

AI人工智能 Agent：电力系统中智能体的应用
AI天才研究院
06-03 1084
背景介绍 随着人工智能技术的不断发展，人工智能在各个领域得到广泛应用。其中，电力系统领域的应用也日益重要。人工智能 Agent 在电力系统中扮演着重要角色，提供了智能化的解决方案，提高了电力系统的运行效率和安全性。本文将探讨 AI Agent 在电力系统中的应用，分析其核心概念、原理、应用场景以及未来发展趋势。
AI人工智能代理工作流AI Agent WorkFlow：设计智能任务处理流程
AI天才研究院
07-18 1606
AI人工智能代理工作流AI Agent WorkFlow：设计智能任务处理流程 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 1. 背景介绍
AI Agent设计模式 | Planning(规划模式)：实现任务自主分解
Androiddddd的博客
01-14 1394
在人工智能领域，大型语言模型（LLM）一直是推动技术进步的核心力量。从最初的自然语言理解到如今的多模态交互，LLM的应用场景不断拓展，其能力也在不断提升。然而，随着任务复杂度的增加，单一的模型输出已难以满足需求，这就催生了AI Agent设计模式的诞生。Planning（规划模式）作为其中一种重要模式，它赋予了AI自主分解任务、制定执行计划的能力，使得AI在处理复杂任务时更加高效、灵活。
一文搞懂如何规划一个AI Agent（智能体）
2401_85375186的博客
03-20 991
场景”这个词在许多领域被广泛使用，通常指特定的时间与空间，并涵盖各种活动和特定的环境因素。场景定义了用户使用产品或服务时的行为、需求以及互动方式，帮助我们更好地理解用户的体验和期望。因此，在设计时，有必要明确应用场景的定义。这包括具体的用户角色、使用场景的核心功能以及所能提供的独特价值。比如说，如果我们要设计一个短视频改写 Agent，它的主要用户对象是短视频创作者和营销人员。这个 Agent 的用户包括需要优化短视频内容的创作者、品牌营销团队，以及负责社交媒体内容的管理人员。
小白学AI量化：DeepSeek+Python构建强大的金融数据挖掘与多维分析机器人
weixin_70955880的博客
03-21 2405
在机构主导的量化交易时代，普通投资者如何用一杯奶茶的钱（15元/天）打造专业级智能量化产品？ 本文将为您揭秘一个革命性的解决方案——基于国产大模型DeepSeek和Python构建的智能数据挖掘分析机器人。它不仅适用于通用网页数据抓取，更能深度应用于金融领域，精准捕捉市场信号。本文“干货”很多，请务必耐心读完。
万字长文！AI Agent架构概况：关于推理、规划和工具调用
hunteritself的博客
05-13 3664
万字长文！AI Agent架构概况：关于推理、规划和工具调用
基于大模型的Agent进行任务规划的10种方式（附代码和论文）
人工智能讲师分享前沿技术
05-21 4130
这种方式模拟人类解决问题的思维组合，它能合并多条推理链，自然回溯到有效的推理链，并行地探索独立的推理链，更贴近人类思维方式，从而增强了推理能力。而 Agent 的执行过程与人做事的方式类似，其中最有效的就是 ReAct 框架的思路，它来自论文《ReAct：在语言模型中协同推理与行动》[3]，作者发现让 Agent 执行下一步行动的时候，加上大模型自己的思考过程，并将思考过程、执行的工具及参数、执行的结果放到提示词中，就能使得模型对当前和先前的任务完成度有更好的反思能力，从而提升模型的问题解决能力。
人工智能06 能计划的agent
weixin_41565471的博客
07-08 364
能计划的agent 存储与计算 响应agent的动作功能几乎没有做任何计算。从本质上讲，这些agent执行的动作或者由他们的设计者、或者通过学习、或者通过演化过程、或者由以上几方面的组合来选择给他们的。 一个能在复杂环境下执行复杂任务的反应型agent需要大量的存储。而且，这样一个反应型机器的设计者需要有超人类的预见能力，要为该机器能遇到的所有可能情况预期一个合适的反应。首先，考虑反应型机器人的设...
AI Agent综述 李飞飞 人工智能之母出品
12-22
人工智能在当今社会的应用已经渗透到生活的方方面面，其发展速度之快，应用范围之广，都在不断地推动人类社会的进步。其中，AI Agent作为人工智能的一个重要分支，扮演着至关重要的角色。AI Agent综述一文详细探讨了...
AI测试入门：什么是智能体（AI-Agent）？
blues_C的博客
07-21 1970
在人工智能领域，AI-Agent 逐渐成为一种重要的新形态。AI-Agent 具备环境感知能力、自主理解、决策制定及执行行动能力。简而言之，它是构建于大模型之上的计算机程序，能够模拟独立思考过程，灵活调用各类工具，逐步达成预设目标。本文将详细介绍AI智能体的概念、架构设计及其应用案例，帮助大家更好地理解这一前沿技术。
基于大模型的 Agent 进行任务规划的10种方式
weixin_43829633的博客
03-13 3102
基于大模型的 Agent 基本组成应该包含规划（planning)，工具（Tools)，执行(Action)，和记忆(Memory)四个方面，上一篇中多轮对话中让AI保持长期记忆的8种优化方式（附案例和代码）重点讲了进行长记忆管理的 8 种方案，本节将从 Agent 概念、ReAct 框架、示例、以及一些论文思路来具体聊下任务规划的话题，同时会辅以代码帮助理解，欢迎大家一起探讨。
【AI大模型】Agent规划大揭秘！这才是真正的planning
Android23333的博客
01-17 1120
给定一个任务，有很多种可能的解决方法，但不是所有方法都能成功。在正确的方案中，有些比其他方案更高效。考虑这个查询：“有多少没有收入的公司至少融了 10 个亿？”，以及两个可能的解决方案：先找出所有没有收入的公司，然后按照融资金额筛选。先找出所有至少融资了 10 个亿的公司，然后按照收入筛选。第二种方案效率更高。没有收入的公司数量远远多于筹集了 10 个亿的公司数量。如果只有这两个选项，一个智能 agent 应该选择方案 2。你可以将规划和执行放在同一个prompt中。
初识AI Agent——以大模型为核心的智能体
2301_82275412的博客
08-09 1339
尽管ChatGPT、Midjourney、Runway、Pika等原生AI应用非常火爆，微软、谷歌、百度、淘宝等大厂在结合LLM的能力更新迭代自己的产品，很多套壳应用也层出不穷，但LLM的潜力可远远不止于用来生成好的文案、图片和视频，或者用来优化学习、体验、搜索等，
一文了解AI Agent（智能体）
m0_59235699的博客
08-01 3429
AI Agent（人工智能代理）是上半年一个火热的话题。笔者最近对相关概念进行了学习与研究，期间也通过智能体开发平台成功搭建了一些有趣的Agent。所以计划通过本篇文章，跟大家分享笔者对于AI Agent的些许理解。
基于AIAgent的智能任务调度与分发算法
AI天才研究院
04-14 1036
基于AIAgent的智能任务调度与分发算法 1. 背景介绍 在当今高度自动化和智能化的信息时代,如何有效地调度和分发大量异构任务已经成为亟需解决的关键问题。传统的任务调度算法往往过于静态和僵化,无法适应不断变化的复杂任务环境和计算资源条件。为此,我们提出了一种基于AIAgent的
高压开关柜局部放电信号分析系统
m0_61057267的博客
04-28 1650
这个项目是我在2025年实现的高压开关柜局部放电信号分析系统，目的是通过采集分析局部放电信号，判断设备的工作状态和潜在故障。系统包含从信号模拟生成、特征提取、到深度学习模型训练的全流程，最终可自动生成分析报告。
远光软件发布九天 AI 应用开发平台，加速企业研发效能跃升
最新发布
YG_JT的博客
04-30 294
4月25日，远光软件在“2025珠海软件产业年会暨AI技术赋能行业发展交流会”上以虚拟直播方式发布了远光九天AI应用开发平台。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值