OpenManus с открытым исходным кодом: объяснение архитектуры искусственного интеллекта, лежащей в его основе

Открытие: Огонь Мануса и разрыв OpenManus

В последнее время в кругах, занимающихся вопросами искусственного интеллекта, часто говорят о том, что Манус Manus, агент искусственного интеллекта, привлек к себе много внимания благодаря своим мощным функциям и гибкости использования. Проще говоря, Manus - это универсальный помощник: программирование, поиск информации, обработка документов или работа в Интернете - все это он поможет вам сделать.

Однако использовать Manus не так просто - для этого необходимо иметь код приглашения. Это мешает многим разработчикам и исследователям использовать Manus. Именно тогда, когда все были в растерянности, сообщество разработчиков с открытым исходным кодом вмешалось! Команда MetaGPT в составе @mannaandpoem, @XiangJinyu, @MoshiQAQ и @didiforgithub потратила всего 3 часа, чтобы создать проект с открытым исходным кодом под названием OpenManus. Теперь вы можете испытать возможности Manus без пригласительного кода! Что еще более интересно, так это то, что OpenManus - проект с открытым исходным кодом, а значит, вы можете изменять и расширять его в соответствии со своими потребностями!

Появление OpenManus не только дает возможность большему числу людей ощутить прелесть AI Agent, но и вливает новую энергию в развитие AI Agent. Для тех из нас, кто занимается технологиями, OpenManus - это не только хороший инструмент, но и отличный обучающий ресурс. Изучая его код, мы можем глубже понять дизайн и детали реализации AI Agent.

Система агентов искусственного интеллекта: философия дизайна OpenManus

Структура кода OpenManus очень четкая и использует модульную конструкцию, которая напоминает строительные блоки для объединения различных функциональных модулей. Преимущество такого дизайна заключается в том, что код является очень многоразовым и расширяемым, а обязанности каждого модуля четко определены.

Основные компоненты OpenManus включают в себя:

OpenManus
├── Agent (代理层)
│   ├── BaseAgent (基础抽象类)
│   ├── ReActAgent (思考-行动模式)
│   ├── ToolCallAgent (工具调用能力)
│   ├── PlanningAgent (规划能力)
│   ├── SWEAgent (软件工程能力)
│   └── Manus (通用代理)
├── LLM (语言模型层)
├── Memory (记忆层)
├── Tool (工具层)
│   ├── BaseTool (工具基类)
│   ├── PlanningTool (规划工具)
│   ├── PythonExecute (Python 执行)
│   ├── GoogleSearch (搜索工具)
│   ├── BrowserUseTool (浏览器工具)
│   └── ... (其他工具)
├── Flow (工作流层)
│   ├── BaseFlow (基础流程)
│   └── PlanningFlow (规划流程)
└── Prompt (提示词层)

Компоненты LLM: Мозг агента

Если сравнить агента с человеком, то LLM (Large Language Model) - это мозг агента, который отвечает за понимание команд пользователя, генерирование ответов и принятие решений. Она отвечает за понимание команд пользователя, генерирование ответов и принятие решений. OpenManus инкапсулирует взаимодействие с LLM через класс LLM.

class LLM:
_instances: Dict[str, "LLM"] = {}  # 单例模式实现
def __init__(
self, config_name: str = "default", llm_config: Optional[LLMSettings] = None
):
if not hasattr(self, "client"):  # 只初始化一次
llm_config = llm_config or config.llm
llm_config = llm_config.get(config_name, llm_config["default"])
self.model = llm_config.model
self.max_tokens = llm_config.max_tokens
self.temperature = llm_config.temperature
self.client = AsyncOpenAI(
api_key=llm_config.api_key, base_url=llm_config.base_url
)

Класс LLM предоставляет два основных метода:

• ask:: Отправить запрос на общий диалог
• ask_tool:: Отправка запросов с помощью вызовов инструментов

async def ask_tool(
self,
messages: List[Union[dict, Message]],
system_msgs: Optional[List[Union[dict, Message]]] = None,
timeout: int = 60,
tools: Optional[List[dict]] = None,
tool_choice: Literal["none", "auto", "required"] = "auto",
temperature: Optional[float] = None,
**kwargs,
):
# 格式化消息
if system_msgs:
system_msgs = self.format_messages(system_msgs)
messages = system_msgs + self.format_messages(messages)
else:
messages = self.format_messages(messages)
# 发送请求
response = await self.client.chat.completions.create(
model=self.model,
messages=messages,
temperature=temperature or self.temperature,
max_tokens=self.max_tokens,
tools=tools,
tool_choice=tool_choice,
timeout=timeout,
**kwargs,
)

Компонент памяти: память агента

Компонент Memory - это как записная книжка для агента, отвечающая за запись и управление историей диалога агента. С помощью памяти агент может вспомнить, что он говорил раньше, и поддерживать последовательность диалога.

class Memory(BaseModel):
"""Stores and manages agent's conversation history."""
messages: List[Message] = Field(default_factory=list)
def add_message(self, message: Union[Message, dict]) -> None:
"""Add a message to memory."""
if isinstance(message, dict):
message = Message(**message)
self.messages.append(message)
def get_messages(self) -> List[Message]:
"""Get all messages in memory."""
return self.messages

Компонент памяти является основным компонентом агента, и доступ к нему осуществляется через BaseAgent's update_memory чтобы добавить новое сообщение:

def update_memory(
self,
role: Literal["user", "system", "assistant", "tool"],
content: str,
**kwargs,
) -> None:
"""Add a message to the agent's memory."""
message_map = {
"user": Message.user_message,
"system": Message.system_message,
"assistant": Message.assistant_message,
"tool": lambda content, **kw: Message.tool_message(content, **kw),
}
if role not in message_map:
raise ValueError(f"Unsupported message role: {role}")
msg_factory = message_map[role]
msg = msg_factory(content, **kwargs) if role == "tool" else msg_factory(content)
self.memory.add_message(msg)

Инструментальный компонент: набор инструментов агента

Компонент Tools является связующим звеном между агентом и внешним миром, и OpenManus реализует гибкую систему инструментов, которая позволяет агенту вызывать различные инструменты для выполнения задач.

class BaseTool(ABC, BaseModel):
name: str
description: str
parameters: Optional[dict] = None
async def __call__(self, **kwargs) -> Any:
"""Execute the tool with given parameters."""
return await self.execute(**kwargs)
    @abstractmethod
async def execute(self, **kwargs) -> Any:
"""Execute the tool with given parameters."""
def to_param(self) -> Dict:
"""Convert tool to function call format."""
return {
"type": "function",
"function": {
"name": self.name,
"description": self.description,
"parameters": self.parameters,
},
}

Результаты выполнения инструмента представлены в виде ToolResult класс для его представления:

class ToolResult(BaseModel):
"""Represents the result of a tool execution."""
output: Any = Field(default=None)
error: Optional[str] = Field(default=None)
system: Optional[str] = Field(default=None)

OpenManus предоставляет ряд встроенных инструментов, таких как PlanningTool::

class PlanningTool(BaseTool):
"""
A planning tool that allows the agent to create and manage plans for solving complex tasks.
The tool provides functionality for creating plans, updating plan steps, and tracking progress.
"""
name: str = "planning"
description: str = _PLANNING_TOOL_DESCRIPTION
parameters: dict = {
"type": "object",
"properties": {
"command": {
"description": "The command to execute. Available commands: create, update, list, get, set_active, mark_step, delete.",
"enum": [
"create",
"update",
"list",
"get",
"set_active",
"mark_step",
"delete",
],
"type": "string",
},
# 其他参数...
},
"required": ["command"],
}

Компонент планирования: возможности планирования агента

Компонент планирования - это ключ к способности OpenManus справляться со сложными задачами. Он позволяет агентам планировать и разбивать сложные задачи на небольшие пошаговые задания, а затем выполнять их одно за другим.

Компонент "Планирование" состоит из двух основных частей:

1. PlanningTool: Предоставляет возможности создания, обновления и отслеживания планов.
2. PlanningAgent: Использование PlanningTool для планирования и выполнения задач.

class PlanningAgent(ToolCallAgent):
"""
An agent that creates and manages plans to solve tasks.
This agent uses a planning tool to create and manage structured plans,
and tracks progress through individual steps until task completion.
"""
name: str = "planning"
description: str = "An agent that creates and manages plans to solve tasks"
system_prompt: str = PLANNING_SYSTEM_PROMPT
next_step_prompt: str = NEXT_STEP_PROMPT
available_tools: ToolCollection = Field(
default_factory=lambda: ToolCollection(PlanningTool(), Terminate())
)
# 步骤执行跟踪器
step_execution_tracker: Dict[str, Dict] = Field(default_factory=dict)
current_step_index: Optional[int] = None

PlanningAgent Основная методология включает в себя:

async def think(self) -> bool:
"""Decide the next action based on plan status."""
prompt = (
f"CURRENT PLAN STATUS:n{await self.get_plan()}nn{self.next_step_prompt}"
if self.active_plan_id
else self.next_step_prompt
)
self.messages.append(Message.user_message(prompt))
# 获取当前步骤索引
self.current_step_index = await self._get_current_step_index()
result = await super().think()
# 关联工具调用与当前步骤
if result and self.tool_calls:
# ...关联逻辑...
return result

Компонент потока: возможности сотрудничества для агентов

Роль компонента Flow заключается в координации нескольких агентов, работающих вместе для выполнения более сложных задач.

class BaseFlow(BaseModel, ABC):
"""Base class for execution flows supporting multiple agents"""
agents: Dict[str, BaseAgent]
tools: Optional[List] = None
primary_agent_key: Optional[str] = None
    @property
def primary_agent(self) -> Optional[BaseAgent]:
"""Get the primary agent for the flow"""
return self.agents.get(self.primary_agent_key)
    @abstractmethod
async def execute(self, input_text: str) -> str:
"""Execute the flow with given input"""

PlanningFlow это конкретная реализация Flow для планирования и выполнения задач:

class PlanningFlow(BaseFlow):
"""A flow that manages planning and execution of tasks using agents."""
llm: LLM = Field(default_factory=lambda: LLM())
planning_tool: PlanningTool = Field(default_factory=PlanningTool)
executor_keys: List[str] = Field(default_factory=list)
active_plan_id: str = Field(default_factory=lambda: f"plan_{int(time.time())}")
current_step_index: Optional[int] = None
async def execute(self, input_text: str) -> str:
"""Execute the planning flow with agents."""
try:
# 创建初始计划
if input_text:
await self._create_initial_plan(input_text)
# 执行计划步骤
while await self._has_next_step():
# 获取当前步骤
step_info = await self._get_current_step()
# 选择合适的执行者
executor = self.get_executor(step_info.get("type"))
# 执行步骤
result = await self._execute_step(executor, step_info)
# 更新步骤状态
await self._update_step_status(step_info["index"], "completed")
# 完成计划
return await self._finalize_plan()
except Exception as e:
# 处理异常
return f"Error executing flow: {str(e)}"

Агентская реализация OpenManus: многоуровневая архитектура

Агент OpenManus использует иерархическую архитектуру, выстраиваемую слой за слоем от базовой функциональности до специализированных приложений. Преимуществами такой архитектуры являются высокая степень повторного использования кода, высокая масштабируемость и четкая ответственность на каждом уровне.

BaseAgent (抽象基类)
└── ReActAgent (思考-行动模式)
└── ToolCallAgent (工具调用能力)
├── PlanningAgent (规划能力)
├── SWEAgent (软件工程能力)
└── Manus (通用代理)

BaseAgent: база баз

BaseAgent является основой всего фреймворка и определяет основные свойства и методы Агента:

class BaseAgent(BaseModel, ABC):
"""Abstract base class for managing agent state and execution."""
# 核心属性
name: str = Field(..., description="Unique name of the agent")
description: Optional[str] = Field(None, description="Optional agent description")
# 提示词
system_prompt: Optional[str] = Field(None, description="System-level instruction prompt")
next_step_prompt: Optional[str] = Field(None, description="Prompt for determining next action")
# 依赖组件
llm: LLM = Field(default_factory=LLM, description="Language model instance")
memory: Memory = Field(default_factory=Memory, description="Agent's memory store")
state: AgentState = Field(default=AgentState.IDLE, description="Current agent state")
# 执行控制
max_steps: int = Field(default=10, description="Maximum steps before termination")
current_step: int = Field(default=0, description="Current step in execution")

ReActAgent: думающий агент

ReActAgent Была реализована модель "мысль-действие", разделяющая процесс выполнения агента на две фазы:

class ReActAgent(BaseAgent, ABC):
    @abstractmethod
async def think(self) -> bool:
"""Process current state and decide next action"""
    @abstractmethod
async def act(self) -> str:
"""Execute decided actions"""
async def step(self) -> str:
"""Execute a single step: think and act."""
should_act = await self.think()
if not should_act:
return "Thinking complete - no action needed"
return await self.act()

ToolCallAgent: Агент с возможностью использования инструментов

ToolCallAgent Добавляет агенту возможность использовать инструменты:

class ToolCallAgent(ReActAgent):
"""Base agent class for handling tool/function calls with enhanced abstraction"""
available_tools: ToolCollection = ToolCollection(
CreateChatCompletion(), Terminate()
)
tool_choices: Literal["none", "auto", "required"] = "auto"
async def think(self) -> bool:
# 获取 LLM 响应和工具选择
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,
)
self.tool_calls = response.tool_calls
# 处理响应和工具调用
# ...
async def act(self) -> str:
# 执行工具调用
results = []
for command in self.tool_calls:
result = await self.execute_tool(command)
# 添加工具响应到内存
# ...
results.append(result)
return "nn".join(results)

PlanningAgent: агент, который планирует.

PlanningAgent Планирование и отслеживание выполнения задач было обеспечено:

class PlanningAgent(ToolCallAgent):
"""
An agent that creates and manages plans to solve tasks.
This agent uses a planning tool to create and manage structured plans,
and tracks progress through individual steps until task completion.
"""
# 步骤执行跟踪器
step_execution_tracker: Dict[str, Dict] = Field(default_factory=dict)
current_step_index: Optional[int] = None
async def think(self) -> bool:
"""Decide the next action based on plan status."""
prompt = (
f"CURRENT PLAN STATUS:n{await self.get_plan()}nn{self.next_step_prompt}"
if self.active_plan_id
else self.next_step_prompt
)
self.messages.append(Message.user_message(prompt))
# 获取当前步骤索引
self.current_step_index = await self._get_current_step_index()
result = await super().think()
# 关联工具调用与当前步骤
if result and self.tool_calls:
# ...关联逻辑...
return result

Манус: Всемогущий агент

Manus это основной агент OpenManus, который объединяет инструменты и возможности для решения широкого спектра задач:

class Manus(ToolCallAgent):
"""
A versatile general-purpose agent that uses planning to solve various tasks.
This agent extends PlanningAgent with a comprehensive set of tools and capabilities,
including Python execution, web browsing, file operations, and information retrieval
to handle a wide range of user requests.
"""
name: str = "manus"
description: str = "A versatile general-purpose agent"
system_prompt: str = SYSTEM_PROMPT
next_step_prompt: str = NEXT_STEP_PROMPT
available_tools: ToolCollection = Field(
default_factory=lambda: ToolCollection(
PythonExecute(), GoogleSearch(), BrowserUseTool(), FileSaver(), Terminate()
)
)

Подсказка: Поведенческие рекомендации для агентов

Подсказка играет важную роль в построении системы агентов, выступая в качестве инструкции, которая указывает агенту, что делать.

Системная подсказка: определение роли агента

Системная подсказка задает основные роли и правила поведения агента:

SYSTEM_PROMPT = "You are OpenManus, an all-capable AI assistant, aimed at solving any task presented by the user. You have various tools at your disposal that you can call upon to efficiently complete complex requests. Whether it's programming, information retrieval, file processing, or web browsing, you can handle it all."

Подсказка сообщает агенту, что он является универсальным ИИ-помощником, который может использовать различные инструменты для выполнения запроса пользователя.

Планирование Подсказка: направляет агента в планировании

Подсказка планирования подсказывает агенту, как разбить сложные задачи на более мелкие с планом выполнения:

PLANNING_SYSTEM_PROMPT = """
You are an expert Planning Agent tasked with solving complex problems by creating and managing structured plans.
Your job is:
1. Analyze requests to understand the task scope
2. Create clear, actionable plans with the `planning` tool
3. Execute steps using available tools as needed
4. Track progress and adapt plans dynamically
5. Use `finish` to conclude when the task is complete
Available tools will vary by task but may include:
- `planning`: Create, update, and track plans (commands: create, update, mark_step, etc.)
- `finish`: End the task when complete
Break tasks into logical, sequential steps. Think about dependencies and verification methods.
"""

Эта подсказка сообщает агенту, что он является экспертом по планированию и должен использовать planning инструменты для создания, обновления и отслеживания планов.

Подсказка об использовании инструмента: подсказывает агенту, как использовать инструмент.

Подсказка использования инструмента подробно описывает функции и сценарии использования каждого инструмента, чтобы помочь агенту выбрать нужный инструмент:

NEXT_STEP_PROMPT = """You can interact with the computer using PythonExecute, save important content and information files through FileSaver, open browsers with BrowserUseTool, and retrieve information using GoogleSearch.
PythonExecute: Execute Python code to interact with the computer system, data processing, automation tasks, etc.
FileSaver: Save files locally, such as txt, py, html, etc.
BrowserUseTool: Open, browse, and use web browsers.If you open a local HTML file, you must provide the absolute path to the file.
GoogleSearch: Perform web information retrieval
Based on user needs, proactively select the most appropriate tool or combination of tools. For complex tasks, you can break down the problem and use different tools step by step to solve it. After using each tool, clearly explain the execution results and suggest the next steps.
"""

Динамическая подсказка: делаем агентов более гибкими

Подсказки в OpenManus могут быть не только статичными, но и генерироваться динамически. Например, в PlanningAgent в подсказке, система добавляет текущий статус плана в подсказку:

async def think(self) -> bool:
"""Decide the next action based on plan status."""
prompt = (
f"CURRENT PLAN STATUS:n{await self.get_plan()}nn{self.next_step_prompt}"
if self.active_plan_id
else self.next_step_prompt
)
self.messages.append(Message.user_message(prompt))

Эта динамическая подсказка позволяет агенту принимать более рациональные решения в зависимости от текущей ситуации.

Реферат: Информация из OpenManus

Проанализировав код OpenManus, мы можем кратко описать несколько ключевых компонентов фреймворка AI Agent:

1. Агент: Иерархический дизайн от базового до профессионального для достижения различных уровней компетенции.
   • BaseAgent: Обеспечивает базовое управление состоянием и циклы выполнения.
   • ReActAgent: Реализация модели мыследеятельности.
   • ToolCallAgent: Добавьте возможности вызова инструментов.
   • Профессиональный агент: например. PlanningAgent, иSWEAgent ответить пением Manus.
2. LLM: Инкапсулируйте взаимодействие с большими языковыми моделями, предоставляя возможности диалога и вызова инструментов.
   • Поддержка обычного диалога и вызовов инструментов.
   • Реализуйте механизм повторных попыток и обработку ошибок.
   • Поддерживается потоковый ответ.
3. ПамятьУправление диалогом: история и контекст.
   • Храните и извлекайте сообщения.
   • Поддержание контекста диалога.
4. Инструмент: Предоставляют интерфейс для взаимодействия с внешним миром.
   • Базовая абстракция инструментов.
   • Многочисленные специализированные инструменты для достижения этой цели.
   • Обработка результатов работы инструмента.
5. Планирование: Обеспечение планирования и отслеживания выполнения задач.
   • Создание и управление планами.
   • Отслеживание состояния шагов.
   • Программы динамической корректировки.
6. Поток: Управление сотрудничеством между несколькими агентами.
   • Постановка задачи.
   • Интеграция результатов.
   • Управление процессом.
7. Подсказка: Руководит поведением и принятием решений агента.
   • System Prompt определяет роль.
   • Профессиональная подсказка направляет решения.
   • Динамическая генерация подсказок.

Благодаря четкому дизайну и хорошо структурированному коду, OpenManus является отличным примером для изучения реализации агентов искусственного интеллекта. Его модульная конструкция позволяет разработчикам легко расширять и настраивать свои агенты.

OpenManus является хорошей отправной точкой для разработчиков, которые хотят узнать больше об агентах искусственного интеллекта или создать свои собственные агентные системы. Изучив его архитектуру и реализацию, мы сможем лучше понять, как работают агенты искусственного интеллекта и как они создаются.