一文讲透多智能体框架 Open Manus | 全网独家深度解剖，代码级讲解它背后隐藏的秘密

最新推荐文章于 2025-04-06 22:19:15 发布

置顶 AI让世界更懂你

最新推荐文章于 2025-04-06 22:19:15 发布

阅读量1.5k

点赞数 38

分类专栏： LLM 最新科技文章标签：人工智能 python

本文链接：https://blog.csdn.net/qq_35082030/article/details/146371952

版权

最新科技同时被 2 个专栏收录

23 篇文章

订阅专栏

LLM

12 篇文章

订阅专栏

1. 引言

自从 Manus 出圈以来，AI 领域再次掀起热潮，仿佛迈入了一个新的阶段。根据 OpenAI 提出的 AGI 五步走路线，如今似乎已经进入了 L3 级别的“行动者”阶段。

在这里插入图片描述

事实上，早在 LangChain 时代，这种模式的雏形便已初现。LangChain 通过调用外部工具来实现复杂功能，而后 OpenAI 直接将其能力内置，发展为 Function Calling 模式。然而，这一接口仍显得较为僵硬，泛化能力也存在一定的局限性。

近期，随着 DeepSeek 在大模型领域的强势冲击，业界对于基础对话模型的能力重新燃起信心。智能体（Agent）路线也随之复苏，从 Manus 到开源框架 Open Manus 和 OWL 等，大家都在关注这些框架究竟能做什么。但相比之下，却鲜有人深入剖析它们的代码，探究其实现背后的核心逻辑。

为此，我与三位同事——ChatGPT、Claude 以及 DeepSeek——决定啃下这块硬骨头。我们花了一下午的时间，试图彻底吃透其中的“魔法”。在这篇文章中，我们将以 Open Manus 项目代码为例，对其进行详细的解读，揭示它如何实现当前的智能体能力。

Open Manus的代码链接：https://github.com/mannaandpoem/OpenManus。

2. 项目框架

通过深入分析 open_manus 的代码结构，我们可以快速梳理出整个项目的框架。本篇文章将重点关注 app 目录下的核心代码。除去根目录中的一些配置和工具性代码，整体架构主要分为以下四个核心部分：

agent/：智能体核心，实现 open_manus 的主要功能模块。
flow/：工作流管理，负责规划和执行任务。
prompt/：智能体的提示词模板，定义不同模块的系统指令。
tool/：可扩展的工具集合，为智能体提供具体的执行能力。

接下来，我们将逐一拆解这些模块的代码实现，深入剖析 open_manus 的技术核心。

	app/
        config.py
        exceptions.py
        llm.py
        logger.py
        schema.py
        __init__.py
        agent/
            base.py
            manus.py
            planning.py
            react.py
            swe.py
            toolcall.py
            __init__.py
        flow/
            base.py
            flow_factory.py
            planning.py
            __init__.py
        prompt/
            manus.py
            planning.py
            swe.py
            toolcall.py
            __init__.py
        tool/
            base.py
            bash.py
            browser_use_tool.py
            create_chat_com

2.1 根目录

根目录下包含了一些核心配置和基础功能文件，其中 config.py、exceptions.py 和 logger.py 主要用于配置管理、异常处理和日志记录，属于项目的基础工具组件，本文不做深入探讨。

2.1.1 `llm.py`

llm.py 主要实现了一个 LLM（大语言模型）管理类，用于封装 OpenAI 或 Azure OpenAI 的 API 调用，并提供 消息格式化、令牌计数、API 请求、重试策略 等功能。可以理解为 agent 模块的基础支持层。下图展示了 llm.py 的类结构：
在这里插入图片描述

核心代码主要围绕 ask() 和 ask_tool() 这两个方法展开。不过，仔细分析代码后会发现，真正的核心逻辑只有 字数统计，其他部分本质上就是一个标准的 LLM API 封装，80% 的开发者都能自己实现类似的功能。

2.1.2 `schema.py`

schema.py 主要用于定义 对话消息、工具调用、对话记忆 的数据结构，并确保与 OpenAI API 交互时的格式一致。文件内容可以拆分为四个核心部分：

Role 和 ToolChoice 枚举（定义角色 & 工具选择）
Function & ToolCall（定义工具调用结构）
Message（封装对话消息）
Memory（管理对话记忆）

其中，最重要的部分是 Message 和 Memory。Message 负责不同角色的信息处理，而 Memory 则管理整个对话历史，可以理解为 Memory 是 Message 的更高级封装。

有趣的是，在代码中居然出现了汉字，我知道作者是中国开发者，但是这可能是彩蛋，也可能是作者的疏忽。不过，这些代码整体质量很高，AI 生成的影子非常明显。未来，代码的“手工艺人”可能会变得越来越少，毕竟代码的核心目的是 解决问题，而非纯粹的艺术创作。

2.2 `agent/` 智能体核心

agent/ 目录是 open_manus 的核心部分，定义了整个智能体的实现逻辑。根据文件结构，我们可以看到几个主要的智能体模块：

manus.py：主智能体，统筹整个 open_manus 逻辑。
planning.py：任务规划智能体。
react.py：响应式智能体。
swe.py：程序执行智能体。
toolcall.py：工具调用智能体。

以下是 agent 各个类之间的依赖关系（感谢 open_manus 的自我剖析）：

核心在于工具调用（ToolCall），只需要围绕 ToolCallAgent 扩展 3 个子类（Manus, PlanningAgent, SWEAgent），整个框架的核心功能就能快速复刻（开个玩笑，实际上代码质量还是很高的）。

2.2.1 `manus.py` - 主智能体

manus.py 是 open_manus 的核心智能体模块，负责协调任务并管理工具调用。从代码结构来看，它继承自 ToolCallAgent，并扩展了额外的工具支持，使其具备更强的执行能力。

在 manus.py 中，智能体默认支持 5 种工具：

# Add general-purpose tools to the tool collection
    available_tools: ToolCollection = Field(
        default_factory=lambda: ToolCollection(
            PythonExecute(), WebSearch(), BrowserUseTool(), FileSaver(), Terminate()
        )
    )

这些工具的功能如下：

PythonExecute()：执行 Python 代码，支持计算、数据处理、自动化任务等。
WebSearch()：进行网络搜索，获取外部信息。
BrowserUseTool()：打开、浏览和操作网页，支持加载本地 HTML 文件。
FileSaver()：保存文件，如 .txt、.py、.html 等格式。
Terminate()：当任务完成或需要用户提供额外信息时，终止当前交互。
可以看出，Manus 主要是一个工具协调者，它自身并不直接执行任务，而是通过工具调用完成各种复杂操作。

2.2.2 `swe.py` - 代码执行智能体

SWEAgent 主要扩展了对 代码执行 的支持，使其能够与系统终端交互，并运行命令行指令。

1. 代码执行工具
相比 manus.py，SWEAgent 额外增加了对命令执行的支持:

available_tools: ToolCollection = ToolCollection(
        Bash(), StrReplaceEditor(), Terminate()
    )

新增的工具包括：

Bash()：运行 Shell 命令，支持 Linux/Mac 终端操作。
StrReplaceEditor()：字符串替换工具，能够修改文本内容。
Terminate()：终止任务执行。

2. 任务思考与执行
SWEAgent 具备思考与调整执行流程的能力，它在执行前会先更新工作目录，并调整 next_step_prompt 以确保正确的任务规划：

async def think(self) -> bool:
        """Process current state and decide next action"""
        # Update working directory
        self.working_dir = await self.bash.execute("pwd")
        self.next_step_prompt = self.next_step_prompt.format(
            current_dir=self.working_dir
        )

        return await super().think()

可以看出，SWEAgent 不仅是一个工具调用智能体，还增加了自我调整能力，能够动态修改执行环境，使任务管理更具灵活性。

2.2.3 `planning.py` - 任务规划智能体

PlanningAgent 侧重于任务的分解与执行规划，它能够分析任务需求，并制定清晰的执行计划。其主要作用如下：

任务分析：拆解任务，定义执行步骤。
计划创建：根据需求构建任务计划，并调整执行顺序。
执行管理：调用适当的工具，确保任务顺利完成。

下图展示了 PlanningAgent 的执行流程：

在这里插入图片描述

2.2.4 `toolcall.py` - 工具调用智能体

ToolCallAgent 是 open_manus 工具调用的核心模块，它定义了工具调用的完整流程，包括选择工具、执行工具、检查执行结果等操作。

这里核心还是他们的父类toolcall.py。这里写的很清楚，如何调用工具的。

关键方法
工具调用的主要流程如下：

think()：调用 LLM 询问应执行哪些工具（基于 Function Calling）。
act()：执行选定工具，并确保调用的正确性。
execute_tool()：单独执行工具，检查参数并解析返回值。
其中，think() 方法用于决定下一步行动，它会基于当前对话上下文，调用 LLM 选择合适的工具：

async def think(self) -> bool:
        """Process current state and decide next actions using tools"""
        if self.next_step_prompt:
            user_msg = Message.user_message(self.next_step_prompt)
            self.messages += [user_msg]

        try:
            # Get response with tool options
            response = await self.llm.ask_tool(
                messages=self.messages,
                system_msgs=[Message.system_message(self.system_prompt)]
                if self.system_prompt
                else None,
                tools=self.available_tools.to_params(),
                tool_choice=self.tool_choices,
            )
        except ValueError:
            raise
        except Exception as e:
            # Check if this is a RetryError containing TokenLimitExceeded
            if hasattr(e, "__cause__") and isinstance(e.__cause__, TokenLimitExceeded):
                token_limit_error = e.__cause__
                logger.error(
                    f"🚨 Token limit error (from RetryError): {token_limit_error}"
                )
                self.memory.add_message(
                    Message.assistant_message(
                        f"Maximum token limit reached, cannot continue execution: {str(token_limit_error)}"
                    )
                )
                self.state = AgentState.FINISHED
                return False
            raise

        self.tool_calls = response.tool_calls

        # Log response info
        logger.info(f"✨ {self.name}'s thoughts: {response.content}")
        logger.info(
            f"🛠️ {self.name} selected {len(response.tool_calls) if response.tool_calls else 0} tools to use"
        )
        if response.tool_calls:
            logger.info(
                f"🧰 Tools being prepared: {[call.function.name for call in response.tool_calls]}"
            )

        try:
            # Handle different tool_choices modes
            if self.tool_choices == ToolChoice.NONE:
                if response.tool_calls:
                    logger.warning(
                        f"🤔 Hmm, {self.name} tried to use tools when they weren't available!"
                    )
                if response.content:
                    self.memory.add_message(Message.assistant_message(response.content))
                    return True
                return False

            # Create and add assistant message
            assistant_msg = (
                Message.from_tool_calls(
                    content=response.content, tool_calls=self.tool_calls
                )
                if self.tool_calls
                else Message.assistant_message(response.content)
            )
            self.memory.add_message(assistant_msg)

            if self.tool_choices == ToolChoice.REQUIRED and not self.tool_calls:
                return True  # Will be handled in act()

            # For 'auto' mode, continue with content if no commands but content exists
            if self.tool_choices == ToolChoice.AUTO and not self.tool_calls:
                return bool(response.content)

            return bool(self.tool_calls)
        except Exception as e:
            logger.error(f"🚨 Oops! The {self.name}'s thinking process hit a snag: {e}")
            self.memory.add_message(
                Message.assistant_message(
                    f"Error encountered while processing: {str(e)}"
                )
            )
            return False

而 act() 方法则负责执行工具调用，并确保执行顺序：

async def act(self) -> str:
        """Execute tool calls and handle their results"""
        if not self.tool_calls:
            if self.tool_choices == ToolChoice.REQUIRED:
                raise ValueError(TOOL_CALL_REQUIRED)

            # Return last message content if no tool calls
            return self.messages[-1].content or "No content or commands to execute"

        results = []
        for command in self.tool_calls:
            result = await self.execute_tool(command)

            if self.max_observe:
                result = result[: self.max_observe]

            logger.info(
                f"🎯 Tool '{command.function.name}' completed its mission! Result: {result}"
            )

            # Add tool response to memory
            tool_msg = Message.tool_message(
                content=result, tool_call_id=command.id, name=command.function.name
            )
            self.memory.add_message(tool_msg)
            results.append(result)

        return "\n\n".join(results)

下图展示了 ToolCallAgent 的执行流程：
在这里插入图片描述
至此，我们完成了 agent/ 目录的核心解析。接下来，我们将深入分析 flow/ 工作流管理模块，探索 open_manus 如何组织任务执行流程。

2.3 `flow/` 文件夹

flow/ 目录主要用于 工作流管理，负责规划和执行任务，使 open_manus 能够高效地组织和协调各个智能体的运作。该模块包含多个文件，其中 base.py 和 flow_factory.py 主要为 planning.py 提供支持，确保任务流的合理调度和执行。

2.3.1 `base.py` - 执行流程与状态管理

base.py 负责定义 执行流程（Execution Flow） 和 任务步骤状态（Plan Step Status），用于规范任务在 open_manus 中的运行方式。其主要组件包括：

BaseFlow 类：提供多个智能体（Agent）之间的执行流程管理，确保任务有序推进。
PlanStepStatus 枚举：定义任务执行的不同状态，例如 待处理（Pending）、进行中（In Progress） 和 已完成（Completed），用于跟踪任务的当前状态。

下图展示了 BaseFlow 及其相关组件的结构：
在这里插入图片描述

2.3.2 `planning.py` - 任务规划执行流

planning.py 主要实现 PlanningFlow，它是基于 BaseFlow 设计的 任务规划执行流，用于管理任务的创建、执行、进度跟踪及最终的总结。核心功能包括：

任务拆解：基于 BaseFlow 逻辑，制定任务执行计划。
动态调整：支持任务执行中的调整和优化，以适应不同情况。
进度跟踪：记录任务执行状态，确保流程顺利推进。
任务总结：在任务完成后，提供总结反馈，便于后续优化。

实际上，PlanningFlow 可以被视为 BaseFlow 的实例化，它是 manus 智能体的真正执行者，负责协调各个任务的有序执行。

下图展示了 PlanningFlow 的任务规划流程：
在这里插入图片描述
flow/ 目录的核心作用是让 open_manus 具备 高效的任务调度和执行能力，它确保了多个智能体能够协同工作，并依据合理的执行流程完成复杂任务。接下来，我们将深入解析 prompt/ 文件夹，了解 open_manus 如何利用提示词（Prompt）来引导智能体的行为。

2.4 `prompt/` 文件夹

prompt/ 目录主要存放 不同智能体的提示词（Prompt）模板，用于指导 open_manus 在不同任务场景下的行为。每个智能体的 Prompt 都定义了其工作方式、任务目标以及可用工具。尽管该目录本身不涉及具体的代码逻辑，但它在智能体的决策过程中起到了 关键引导作用。

接下来，我们对其中几个核心智能体的 Prompt 进行简要解析。

2.4.1 `manus.py` - 主智能体 Prompt

Manus 是 open_manus 的主智能体，负责统筹任务执行。它的 SYSTEM_PROMPT 明确规定了其职责，即 充当一个全能的 AI 助手，能够调用各种工具完成复杂任务：

SYSTEM_PROMPT=“你是OpenManus，一个全能的人工智能助手，旨在解决用户提出的任何任务。你可以使用各种工具来高效地完成复杂的请求。无论是编程、信息检索、文件处理还是网页浏览，你都可以处理。”

NEXT_STEP_PROMPT=“”“您可以使用PythonExecute与计算机交互，通过FileSaver保存重要内容和信息文件，使用BrowserUseTool打开浏览器，以及使用GoogleSearch检索信息。
PythonExecute：执行Python代码与计算机系统、数据处理、自动化任务等进行交互。
FileSaver：在本地保存文件，如txt、py、html等。
BrowserUseTool：打开、浏览和使用网络浏览器。如果打开本地HTML文件，则必须提供文件的绝对路径。
WebSearch：执行网络信息检索
Terminate：当任务完成或需要用户提供其他信息时，结束当前交互。使用此工具表示您已经完成了对用户请求的处理，或者在继续之前需要澄清。
根据用户需求，主动选择最合适的工具或工具组合。对于复杂的任务，您可以分解问题并使用不同的工具逐步解决。使用每个工具后，清楚地解释执行结果并建议下一步。
在整个互动过程中，始终保持一种乐于助人、信息丰富的语气。如果您遇到任何限制或需要更多详细信息，请在终止之前向用户明确传达。

从 Manus 的 Prompt 可以看出，它的核心任务是高效利用工具执行任务，并确保用户理解执行过程。

2.4.2 `planning.py` - 任务规划智能体 Prompt

PlanningAgent 负责任务的分解、执行计划的制定与调整，因此它的 SYSTEM_PROMPT 更加强调结构化任务规划：

PLANNING_SYSTEM_PROMPT=“”“
您是一名专业的规划代理，负责通过结构化计划有效地解决问题。
你的工作是：
1.分析请求以了解任务范围
2.制定一个明确、可操作的计划，利用“规划”工具取得有意义的进展
3.根据需要使用可用工具执行步骤
4.跟踪进度，必要时调整计划
5.任务完成后，使用“完成”立即结束
可用工具因任务而异，但可能包括：
-“planning”：创建、更新和跟踪计划（命令：Create、update、mark_step等）
-'finish'：任务完成后结束
将任务分解为具有明确结果的逻辑步骤。避免过多的细节或子步骤。
考虑依赖关系和验证方法。
知道什么时候结束——一旦目标实现，就不要继续思考。
"""
NEXT_STEP_pmpt=“”“
根据目前的情况，你的下一步行动是什么？
选择最有效的前进道路：
1.这个计划是否足够，还是需要改进？
2.你能立即执行下一步吗？
3.任务完成了吗？如果是这样，请立即使用“finish”。
推理要简洁，然后选择合适的工具或行动。
"""

这一 Prompt 使 PlanningAgent 能够自适应地规划任务流程，确保执行过程高效且逻辑清晰。

2.4.3 `swe.py` - 代码执行智能体 Prompt

SWEAgent 主要负责代码执行与终端交互，因此它的 SYSTEM_PROMPT 主要强调代码编辑与命令执行的约束：

SYSTEM_PROMPT=“”“设置：您是一名自主程序员，使用特殊界面直接在命令行中工作。

特殊界面由一个文件编辑器组成，一次显示文件的{{WINDOW}}行。
除了典型的bash命令外，您还可以使用特定的命令来帮助您导航和编辑文件。
要调用命令，您需要使用函数调用/tool调用来调用它。

请注意，编辑命令需要正确的标识。
如果你想添加“print（x）”行，你必须完整地写出来，并在代码前加上所有空格！缩进很重要，没有正确缩进的代码将失败，需要修复才能运行。

响应格式：
您的shell提示符格式如下：
（打开文件：<path>）
（当前目录：<cwd>）
bash-$

首先，你应该始终对下一步要做什么有一个总体的想法。
然后，对于每个响应，您必须精确地包含_ONE_工具调用/函数调用。

请记住，您应该始终包含_SINGLE_工具调用/函数调用，然后等待shell的响应，然后再继续进行更多讨论和命令。您在讨论部分包含的所有内容都将被保存以供将来参考。
如果你想同时发出两个命令，请不要这样做！请先提交第一个工具调用，然后在收到响应后，您将能够发出第二个工具调用。
请注意，该环境不支持交互式会话命令（例如python、vim），因此请不要调用它们。
"""

NEXT_STEP_TEMPLATE=“”{{观察}}
（打开文件：｛｛Open_file｝｝）
（当前目录：｛｛working_dir｝｝）
bash-$
"""

从 SWEAgent 的 Prompt 设计可以看出，它需要精确执行代码任务，并严格遵循 Shell 交互格式，以确保代码的正确性和稳定性。

2.4.4 总结

prompt/ 目录中的内容，虽然不涉及具体的代码实现，但却在 open_manus 的智能体行为决策中起到了至关重要的作用。不同智能体的 Prompt 侧重点各不相同：

Manus 关注工具调用，确保任务执行的高效性。
PlanningAgent 负责任务分解，优化任务规划和调整能力。
SWEAgent 专注于代码执行，确保 Shell 交互和代码编辑的准确性。

这些 Prompt 定义了各个智能体的行为边界，使得 open_manus 能够在不同的任务场景下表现出合理的智能决策能力。

接下来，我们将深入解析 tool/ 文件夹，了解 open_manus 如何通过外部工具扩展功能，提高任务执行能力。

2.5 `tool/` 文件夹

与前面几个目录不同，tool/ 目录主要负责 扩展 open_manus 的功能，它提供了一系列 可调用的工具模块，用于支持智能体执行各种任务。可以将其理解为一个 可扩展的工具包，每个工具都封装了特定的功能，使 open_manus 能够执行更复杂的操作。

截至 2025 年 3 月 19 日，tool/ 目录已包含以下工具：

bash：执行 Shell 命令，实现命令行操作。
browser_use：用于浏览器交互，打开和控制网页。
file_saver：用于保存文件，如文本、代码文件等。
planning：支持任务规划和执行管理。
python_execute：执行 Python 代码，实现数据处理和计算任务。
run（命令行）**：用于运行系统级命令。
str_replace_editor：字符串替换工具，支持文本编辑。
terminal：终端操作支持，扩展 Shell 交互能力。
terminate：任务终止工具，用于控制任务流结束。
web_search：执行互联网信息检索，帮助查找外部资源。

2.5.1 可扩展性

tool/ 目录的 最大特点 在于其 高度可扩展性。开发者可以根据需求不断添加新的工具，以提升 open_manus 的能力。例如：

未来可以引入 GUI 自动化工具，例如 按键精灵（Key Press Automation）。
Python 中已有类似功能的库，如 pyautogui，它可以 模拟鼠标和键盘操作，让智能体具备 完整的计算机交互能力。

如果 pyautogui 或类似工具被集成到 open_manus，智能体将不仅能执行代码，还能 直接控制计算机界面，例如自动点击按钮、输入文本、滚动页面等，使其能力更加接近人类操作。

2.5.2 未来发展

open_manus 未来可以通过扩展 tool/ 目录，进一步增强其功能：

系统控制：集成 pyautogui 或 AutoHotkey，使智能体具备 GUI 自动化能力。
文件管理：增加 OCR 识别工具，使其能读取图片中的文本信息。
深度学习推理：支持 TensorFlow/PyTorch，使 open_manus 可执行 AI 计算任务。

可以预见，未来 open_manus 可能会成为一个 更加强大的 AI 助手，不仅限于文本交互，而是能够 直接影响现实世界的任务执行。

2.5.3 总结

tool/ 目录是 open_manus 的 核心能力扩展组件，它允许智能体调用不同的工具 执行任务、处理数据、检索信息，甚至 运行外部程序。该模块的 灵活性 和 可扩展性 使其具备 无限的拓展可能性，未来可以加入更多实用工具，进一步提升 open_manus 的智能化水平。