OpenManus Open Source erklärt, mit Einblicken in die KI-Agentenarchitektur dahinter

Eröffnung: Das Manus-Feuer und der OpenManus-Zusammenbruch

Eines der wichtigsten Ereignisse der letzten Zeit in KI-Kreisen ist, dass die Manus Manus, der KI-Agent, hat mit seinen leistungsstarken Funktionen und seiner flexiblen Nutzung viel Aufmerksamkeit erregt. Einfach ausgedrückt ist Manus wie ein Allround-Assistent, der Ihnen beim Programmieren, Nachschlagen von Informationen, Bearbeiten von Dokumenten oder Surfen im Internet helfen kann.

Allerdings ist es nicht so einfach, Manus zu benutzen, man braucht einen Einladungscode. Das hat viele Entwickler und Forscher davon abgehalten, Manus zu nutzen. Das MetaGPT-Team, bestehend aus @mannaandpoem, @XiangJinyu, @MoshiQAQ und @didiforgithub, hat nur 3 Stunden gebraucht, um ein Open-Source-Projekt namens OpenManus zu entwickeln. Jetzt können Sie die Leistungsfähigkeit von Manus auch ohne Einladungscode erleben! Noch spannender ist, dass OpenManus ein Open-Source-Projekt ist, was bedeutet, dass Sie es nach Ihren Bedürfnissen verändern und erweitern können!

Das Auftauchen von OpenManus gibt nicht nur mehr Menschen die Möglichkeit, den Charme von AI Agent zu erleben, sondern verleiht der Entwicklung von AI Agent auch neuen Schwung. Für diejenigen unter uns, die sich mit Technologie beschäftigen, ist OpenManus nicht nur ein gutes Werkzeug, sondern auch eine hervorragende Lernressource. Durch das Studium seines Codes können wir ein tieferes Verständnis für das Framework-Design und die Implementierungsdetails von AI Agent gewinnen.

AI Agent Framework: Designphilosophie von OpenManus

Die Codestruktur von OpenManus ist sehr übersichtlich und folgt einem modularen Aufbau, bei dem verschiedene Funktionsmodule wie Bausteine miteinander kombiniert werden. Der Vorteil dieses Designs ist, dass der Code in hohem Maße wiederverwendbar und erweiterbar ist und die Zuständigkeiten der einzelnen Module klar sind.

Zu den Kernkomponenten von OpenManus gehören:

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

LLM-Komponenten: Das Gehirn des Agenten

Wenn wir einen Agenten mit einer Person vergleichen, dann ist das LLM (Large Language Model) das Gehirn des Agenten, das dafür verantwortlich ist, Benutzerbefehle zu verstehen, Antworten zu erzeugen und Entscheidungen zu treffen. Es ist für das Verstehen von Benutzerbefehlen, die Erzeugung von Antworten und das Treffen von Entscheidungen verantwortlich. OpenManus kapselt die Interaktion mit dem LLM durch die LLM-Klasse.

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
)

Die LLM-Klasse bietet zwei Hauptmethoden:

• ask:: Eine allgemeine Dialoganfrage senden
• ask_tool:: Anfragen mit Tool-Aufrufen senden

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,
)

Speicherkomponente: Speicher des Agenten

Die Komponente Memory ist wie ein Notizbuch für den Agenten, das für die Aufzeichnung und Verwaltung des Dialogverlaufs des Agenten verantwortlich ist. Mit Memory kann sich der Agent daran erinnern, was er zuvor gesagt hat, und die Konsistenz des Dialogs aufrechterhalten.

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

Die Speicherkomponente ist die Kernkomponente des Agenten, auf die über die BaseAgent's update_memory Methode, um eine neue Nachricht hinzuzufügen:

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)

Komponente Werkzeuge: Werkzeugkasten des Agenten

Die Komponente Werkzeuge ist die Brücke zwischen dem Agenten und der Außenwelt, und OpenManus implementiert ein flexibles System von Werkzeugen, die es dem Agenten ermöglichen, eine Vielzahl von Werkzeugen aufzurufen, um Aufgaben zu erfüllen.

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,
},
}

Die Ergebnisse der Ausführung des Tools werden durch die ToolResult Klasse, um sie zu repräsentieren:

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 bietet eine Reihe von eingebauten Werkzeugen, wie z. B. 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"],
}

Planungskomponente: Planungsfähigkeiten des Agenten

Die Planungskomponente ist der Schlüssel zu OpenManus' Fähigkeit, komplexe Aufgaben zu bewältigen. Sie ermöglicht es den Agenten, komplexe Aufgaben zu planen und in kleine, schrittweise Aufgaben aufzuteilen und diese dann nacheinander zu erledigen.

Die Komponente Planung besteht aus zwei Hauptteilen:

1. PlanningToolPlanerstellungs-, Aktualisierungs- und Verfolgungsfunktionen.
2. PlanningAgent: Verwendung PlanningTool um die Planung und Ausführung von Aufgaben durchzuführen.

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 Die zentrale Methodik umfasst:

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

Flusskomponente: Kollaborationsmöglichkeiten für Agenten

Die Rolle der Flow-Komponente besteht darin, mehrere Agenten zu koordinieren, die zusammenarbeiten, um komplexere Aufgaben zu bewältigen.

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 ist eine konkrete Flow-Implementierung für die Planung und Ausführung von Aufgaben:

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)}"

Agentenimplementierung von OpenManus: Eine mehrschichtige Architektur

OpenManus' Agent verwendet eine hierarchische Architektur, die Schicht für Schicht von der Basisfunktionalität bis hin zu spezialisierten Anwendungen aufgebaut ist. Die Vorteile dieses Konzepts sind eine hohe Wiederverwendbarkeit des Codes, eine hohe Skalierbarkeit und klare Verantwortlichkeiten auf jeder Ebene.

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

BaseAgent: die Basis der Basen

BaseAgent ist die Grundlage des gesamten Frameworks und definiert die wichtigsten Eigenschaften und Methoden eines Agenten:

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: Der denkende Agent

ReActAgent Es wurde ein "Think-Act"-Modell realisiert, das den Ausführungsprozess des Agenten in zwei Phasen unterteilt:

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: Werkzeugfähiger Agent

ToolCallAgent Erweitert den Agenten um die Möglichkeit, Werkzeuge zu verwenden:

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: Agent, der plant.

PlanningAgent Die Planung und Verfolgung der Ausführung von Aufgaben wurde erreicht:

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: Omnipotenter Agent

Manus ist der zentrale Agent von OpenManus, der Werkzeuge und Fähigkeiten zur Bewältigung einer Vielzahl von Aufgaben integriert:

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()
)
)

Aufforderung: Verhaltensrichtlinien für Agenten

Die Eingabeaufforderung spielt beim Aufbau eines Agentensystems eine wichtige Rolle, denn sie dient als Bedienungsanleitung, die dem Agenten sagt, was er zu tun hat.

System Prompt: Definition der Rolle eines Agenten

Die Systemansage legt die grundlegenden Rollen und Verhaltensrichtlinien für den Agenten fest:

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."

Das Prompt teilt dem Agenten mit, dass er ein universell einsetzbarer KI-Assistent ist, der eine Vielzahl von Tools verwenden kann, um die Anfrage des Nutzers zu erfüllen.

Planungsaufforderung: leitet den Agenten bei der Planung an

Die Planungsaufforderung teilt dem Agenten mit, wie er komplexe Aufgaben in kleinere Aufgaben mit einem Ausführungsplan zerlegen kann:

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.
"""

Diese Aufforderung teilt dem Agenten mit, dass er ein Planungsexperte ist und die planning Werkzeuge zur Erstellung, Aktualisierung und Verfolgung von Plänen.

Aufforderung zur Verwendung des Tools: Informiert den Agenten über die Verwendung des Tools.

In der Eingabeaufforderung zur Werkzeugverwendung werden die Funktionen und Einsatzszenarien der einzelnen Werkzeuge detailliert beschrieben, um dem Agenten die Auswahl des richtigen Werkzeugs zu erleichtern:

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.
"""

Dynamische Aufforderung: Agenten flexibler machen

Die Eingabeaufforderungen in OpenManus können nicht nur statisch sein, sondern auch dynamisch erzeugt werden. Zum Beispiel können in der PlanningAgent in der Eingabeaufforderung, fügt das System den aktuellen Planstatus in die Eingabeaufforderung ein:

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))

Diese dynamische Aufforderung ermöglicht es dem Agenten, rationalere Entscheidungen auf der Grundlage der aktuellen Situation zu treffen.

Zusammenfassung: Einblicke aus OpenManus

Durch die Analyse des OpenManus-Codes können wir mehrere Schlüsselkomponenten des KI-Agentenrahmens zusammenfassen:

1. AgentHierarchischer Aufbau von Grundkenntnissen bis hin zu Fachkenntnissen, um verschiedene Kompetenzniveaus zu erreichen.
   • BaseAgentBietet eine grundlegende Zustandsverwaltung und Ausführungsschleifen.
   • ReActAgentUmsetzung des Think-Act-Modells.
   • ToolCallAgent: Hinzufügen von Funktionen zum Aufrufen von Werkzeugen.
   • Berufsmäßiger Vertreter: z. B. PlanningAgentundSWEAgent im Gesang antworten Manus.
2. LLMKapseln Sie die Interaktion mit großen Sprachmodellen, indem Sie Dialog- und Werkzeugaufrufe ermöglichen.
   • Unterstützung für normale Dialoge und Tool-Aufrufe.
   • Implementierung eines Wiederholungsmechanismus und Fehlerbehandlung.
   • Streaming Response wird unterstützt.
3. SpeicherGeschichte und Kontext des Dialogs verwalten.
   • Speichern und Abrufen von Nachrichten.
   • Den Kontext des Dialogs beibehalten.
4. Werkzeug: Bietet eine Schnittstelle zur Interaktion mit der Außenwelt.
   • Grundlegende Abstraktion der Werkzeuge.
   • Mehrere spezialisierte Werkzeuge, um dies zu erreichen.
   • Verarbeitung der Werkzeugergebnisse.
5. PlanungErmöglichung der Planung und Verfolgung der Ausführung von Aufgaben.
   • Erstellung und Verwaltung von Plänen.
   • Verfolgung des Schrittstatus.
   • Dynamische Anpassungsprogramme.
6. DurchflussVerwaltung der Zusammenarbeit zwischen mehreren Agenten.
   • Aufgabenstellung.
   • Ergebnisse Integration.
   • Prozesskontrolle.
7. EingabeaufforderungLeitet das Verhalten und die Entscheidungsfindung des Agenten.
   • System Prompt definiert die Rolle.
   • Das Professional Prompt dient als Entscheidungshilfe.
   • Dynamische Prompt-Generierung.

Mit seinem klaren Design und gut strukturierten Code ist OpenManus ein hervorragendes Beispiel, um die Implementierung von KI-Agenten kennenzulernen. Sein modularer Aufbau ermöglicht es Entwicklern, ihre Agenten einfach zu erweitern und anzupassen.

OpenManus bietet einen guten Ausgangspunkt für Entwickler, die mehr über KI-Agenten erfahren oder ihre eigenen Agentensysteme entwickeln möchten. Indem wir etwas über seine Architektur und Implementierung erfahren, können wir besser verstehen, wie KI-Agenten funktionieren und wie sie konzipiert sind.