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 (Agentenschicht)
│ ├── BaseAgent (abstrakte Basisklasse)
│ ├── ReActAgent (Denk- und Handlungsmodus)
│ ├── ToolCallAgent (Tool Calling Capability)
│ ├── PlanningAgent (Planungsfähigkeit)
│ ├── SWEAgent (Softwareentwicklungs-Fähigkeit)
│ └─ Manus (Generischer Agent)
├─ LLM (Language Modelling Layer) │ ├─── Speicher (Language Model Layer)
├─ Speicher (Speicherebene)
├─ Werkzeug (Werkzeugschicht)
│ ├── BaseTool (Werkzeug-Basisklasse)
│ ├─ PlanningTool
│ ├── PythonExecute (Python-Ausführung)
│ ├── GoogleSearch (Suchwerkzeug)
│ ├── BrowserUseTool (Browser-Tool)
│ └── ... (Andere Werkzeuge)
├─ Fluss (Workflow-Ebene) │ ├─ BaseFlow
│ ├── BaseFlow (Basisfluss)
│ └─ PlanningFlow (Planungsfluss)
└─ Prompt (Wortschicht Prompt) │ └─ Prompt (Wortschicht 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"] = {} # Singleton-Muster-Implementierung
def __init__(
self, config_name: str = "default", llm_config: Optional[LLMSettings] = None
).
if not hasattr(self, "client"): # nur einmal initialisieren
llm_config = llm_config oder 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:

• fragen Sie:: 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, async
system_msgs: Optional[List[Union[dict, Message]]] = None, timeout: int = 60, async ask_tool(
system_msgs: Optional[List[List[Union[dict, Message]]] = None, timeout: int = 60,

tool_choice: Literal["none", "auto", "required"] = "auto", temperature: Optional[float] = None
temperature: Optional[float] = Keine,
**kwargs.
).
# Formatierung der Nachricht
if system_msgs.
system_msgs = self.format_messages(system_msgs)
messages = system_msgs + self.format_messages(messages)
meldungen = self.format_messages(system_msgs)
meldungen = self.format_messages(meldungen)
# Senden Sie die Anfrage
response = await self.client.chat.completions.create(
model=self.model,
messages=messages, temperature=temperature, oder self.chat.completions.create(
Temperatur=Temperatur oder self.temperature, max_tokens=self.temperature, max_tokens=self.temperature
max_tokens=self.max_tokens, tools=tools,
max_tokens=self.max_tokens, tools=tools, tool_choice=tool_choice
tool_choice=tool_choice,
timeout=timeout, **kwargs, **kwargs, **kwargs
**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).
"""Speichert und verwaltet den Gesprächsverlauf des Agenten.""""
messages: List[Message] = Field(default_factory=list)
def add_message(self, message: Union[Message, dict]) -> None.
"""Eine Nachricht zum Speicher hinzufügen.""""
if isinstance(nachricht, dict).
message = Nachricht(**message)
self.messages.append(nachricht)
def get_messages(self) -> List[Message].
"""Alle Nachrichten im Speicher abrufen.""""
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, **kwargs, **kwargs
**kwargs.
) -> Keine.
"""Eine Nachricht zum Speicher des Agenten hinzufügen."""""
message_map = {
"user": Message.user_message, """Füge eine Nachricht zum Speicher des Agenten hinzu.""
"system": Message.system_message, "assistant": Message.
"assistant": Message.assistant_message, "tool": lambda content, message_map
"tool": lambda content, **kw: Message.tool_message(content, **kw),
}
if role nicht in message_map.
raise ValueError(f "Nicht unterstützte Nachrichtenrolle: {role}")
msg_factory = message_map[role]
msg = msg_factory(Inhalt, **kwargs) if role == "tool" else msg_factory(Inhalt)
self.memory.add_message(msg)

Komponente Werkzeuge: Werkzeugkasten des Agenten

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

class BaseTool(ABC, BaseModel).
Name: str
Beschreibung: str
parameter: Optional[dict] = Keine
async def __call__(self, **kwargs) -> Any.
"""Das Tool mit den angegebenen Parametern ausführen."""""
return await self.execute(**kwargs)
    @AbstrakteMethode
async def execute(self, **kwargs) -> Any.
"""Das Werkzeug mit den angegebenen Parametern ausführen. """""
def to_param(self) -> Dict.
"""Werkzeug in Funktionsaufruf-Format umwandeln.""""
return {

"function": {
"name": self.name, "description": self.description, "function": {
"description": self.description, "parameters": self.
"parameter": self.parameters, }, return { "type": "function": { "name": self.name, "description": self.description, "parameters": self.
}, }
}

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

class ToolResult(BaseModel).
"""Stellt das Ergebnis einer Werkzeugausführung dar.""""
output: Any = Feld(default=None)
error: Optional[str] = Feld(default=None)
system: Optional[str] = Field(default=None)

OpenManus bietet eine Reihe von eingebauten Werkzeugen, wie z. B. PlanungsTool::

class PlanningTool(BaseTool).
"""
Ein Planungstool, das es dem Agenten ermöglicht, Pläne zur Lösung komplexer Aufgaben zu erstellen und zu verwalten.
Das Tool bietet Funktionen zum Erstellen von Plänen, Aktualisieren von Planschritten und Verfolgen des Fortschritts.
"""
name: str = "Planung"
Beschreibung: str = _PLANNING_TOOL_DESCRIPTION
parameter: dict = {
"Typ": "Objekt", "Eigenschaften": {
"properties": {
"Befehl": {
"description": "Der auszuführende Befehl. Verfügbare Befehle: create, update, list, get, set_active, mark_step, delete.",
"enum": [
"create",
"create", "update",
"list", "get", "set_active", delete.
"get", "set_active", "set_step", "list", "get".


"löschen".
], "typ".
"type": "string", },, "type".
}, .
# Andere Parameter...
},, "erforderlich".
"erforderlich": ["Befehl"], }, # Weitere Parameter...
}

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. PlanungsToolPlanerstellungs-, Aktualisierungs- und Verfolgungsfunktionen.
2. PlanningAgent: Verwendung PlanungsTool um die Planung und Ausführung von Aufgaben durchzuführen.

class PlanningAgent(ToolCallAgent).
"""
Ein Agent, der Pläne zur Lösung von Aufgaben erstellt und verwaltet.
Dieser Agent verwendet ein Planungstool, um strukturierte Pläne zu erstellen und zu verwalten, und verfolgt den Fortschritt durch die einzelnen Schritte bis zum Abschluss der Aufgabe.
Dieser Agent verwendet ein Planungstool, um strukturierte Pläne zu erstellen und zu verwalten, und verfolgt den Fortschritt durch die einzelnen Schritte bis zum Abschluss der Aufgabe.
"""
name: str = "Planung"
name: str = "planning" description: str = "Ein Agent, der Pläne zur Lösung von Aufgaben erstellt und verwaltet"
system_prompt: str = PLANNING_SYSTEM_PROMPT
nächster_Schritt_Aufforderung: str = NEXT_STEP_PROMPT
available_tools: ToolCollection = Feld(
default_factory=lambda: ToolCollection(PlanningTool(), Terminate())
)
# Schrittausführungs-Tracker
step_execution_tracker: Dict[str, Dict] = Field(default_factory=dict)
current_step_index: Optional[int] = Keine

PlanningAgent Die zentrale Methodik umfasst:

async def think(self) -> bool.
"""Entscheide die nächste Aktion basierend auf dem Planstatus."""""
prompt = (
f "AKTUELLER PLANSTATUS:n{await self.get_plan()}nn{self.next_step_prompt}""
if self.active_plan_id
sonst self.next_step_prompt
)
self.messages.append(Nachricht.user_message(prompt))
# Aktuellen Schrittindex abrufen
self.current_step_index = await self._get_current_step_index()
Ergebnis = await super().think()
# Verknüpfen eines Werkzeugaufrufs mit dem aktuellen Schritt
if result und self.tool_calls:
# ... Assoziierende Logik ...
return result

Flusskomponente: Kollaborationsfähigkeiten 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).
"""Basisklasse für Ausführungsabläufe, die mehrere Agenten unterstützen""""
agents: Dict[str, BaseAgent]
tools: Optional[List] = None
primary_agent_key: Optional[str] = None
    @property
def primary_agent(self) -> Optional[BaseAgent].
"""Ermittelt den primären Agenten für den Fluss""""
return self.agents.get(self.primary_agent_key)
    @abstrakteMethode
async def execute(self, input_text: str) -> str.
"""Führt den Fluss mit der gegebenen Eingabe aus""""

PlanningFlow ist eine konkrete Flow-Implementierung für die Planung und Ausführung von Aufgaben:

class PlanningFlow(BaseFlow).
"""Ein Fluss, der die Planung und Ausführung von Aufgaben mit Hilfe von Agenten verwaltet.""""
llm: LLM = Field(default_factory=lambda: LLM())
planning_tool: PlanningTool = Field(default_factory=PlanningTool)
executor_keys: Liste[str] = Feld(default_factory=liste)
active_plan_id: str = Field(default_factory=lambda: f "plan_{int(time.time())}")
current_step_index: Optional[int] = Keine
async def execute(self, input_text: str) -> str.
"""Ausführen des Planungsablaufs mit agents."""""
try.
# Erstellen des ersten Plans
if input_text: await self._create_initial_plan
await self._create_initial_plan(input_text)
# Ausführen des Planungsschritts
while await self._has_next_step():: # Ermitteln des aktuellen Schritts.
# Abrufen des aktuellen Schritts
step_info = await self._get_current_step()
# Wählen Sie den entsprechenden Ausführer
Ausführender = self.get_executor(step_info.get("type"))
# Führen Sie den Schritt aus
result = await self._execute_step(ausführender, step_info)
# Schrittstatus aktualisieren
await self._update_step_status(step_info["index"], "abgeschlossen")
# Das Programm abschließen
return await self._finalise_plan()
except Exception as e.
# Behandlung von Ausnahmen
return f "Fehler beim Ausführen des Ablaufs: {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 (abstrakte Basisklasse)
└─ ReActAgent (Denk- und Handlungsmodus)
└─ ToolCallAgent (Werkzeugaufruf-Fähigkeit)
├─ PlanningAgent (Planungsfähigkeit)
├─── SWEAgent (Softwareentwicklungsfähigkeit)
└─ Manus (allgemeiner Agent)

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).
"""Abstrakte Basisklasse zur Verwaltung des Agentenstatus und der Ausführung.""""
# Kern-Eigenschaften
name: str = Field(... , description="Eindeutiger Name des Agenten")
description: Optional[str] = Field(None, description="Optionale Agentenbeschreibung")
# Eingabeaufforderung
system_prompt: Optional[str] = Field(None, description="System-level instruction prompt")
next_step_prompt: Optional[str] = Field(None, description="Aufforderung zur Bestimmung der nächsten Aktion")
#-Abhängigkeiten
llm: LLM = Field(default_factory=LLM, description="Sprachmodell-Instanz")
memory: Memory = Field(default_factory=Memory, description="Agent's memory store")
state: AgentState = Field(default=AgentState.IDLE, description="Aktueller Agentenstatus")
#-Ausführungssteuerung
max_steps: int = Field(default=10, description="Maximale Schritte vor Abbruch")
current_step: int = Field(default=0, description="Aktueller Schritt in der Ausführung")

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).
    @abstrakteMethode
async def think(self) -> bool.
"""Aktuellen Zustand verarbeiten und nächste Aktion entscheiden"""""
    @abstrakteMethode
async def act(self) -> str.
"""Entschiedene Aktionen ausführen""""
async def step(self) -> str.
"""Einen einzelnen Schritt ausführen: think und act."""""
should_act = await self.think()
if not should_act: return "Nachdenken abgeschlossen - keine Aktion.
return "Denken abgeschlossen - keine Aktion erforderlich"
return await self.act()

ToolCallAgent: Werkzeugfähiger Agent

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

class ToolCallAgent(ReActAgent).
"""Basis-Agentenklasse für die Handhabung von Werkzeug-/Funktionsaufrufen mit erweiterter Abstraktion"""""
available_tools: ToolCollection = ToolCollection(
CreateChatCompletion(), Terminate()
)
tool_choices: Literal["none", "auto", "required"] = "auto"
async def think(self) -> bool.
# LLM-Antwort und Werkzeugauswahl abrufen
response = await self.llm.ask_tool(
messages=self.messages,
system_msgs=[Message.system_message(self.system_prompt)]
if self.system_prompt
messages, system_msgs=[Nachricht.system_message(self.system_prompt)
tools=self.available_tools.to_params(),
tool_choice=self.tool_choices, )
)
self.tool_calls = response.tool_calls
# Behandlung von Antworten und Werkzeugaufrufen
# ...
async def act(self) -> str.
# Ausführen von Werkzeugaufrufen
results = []
for command in self.tool_calls:
results = await self.execute_tool(command)
# Hinzufügen der Werkzeugantwort zum Speicher
# ...
results.append(result)
return "nn".join(ergebnisse)

PlanningAgent: Agent, der plant.

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

class PlanningAgent(ToolCallAgent).
"""
Ein Agent, der Pläne zur Lösung von Aufgaben erstellt und verwaltet.
Dieser Agent verwendet ein Planungstool, um strukturierte Pläne zu erstellen und zu verwalten, und verfolgt den Fortschritt durch die einzelnen Schritte bis zum Abschluss der Aufgabe.
Dieser Agent verwendet ein Planungstool, um strukturierte Pläne zu erstellen und zu verwalten, und verfolgt den Fortschritt durch die einzelnen Schritte bis zum Abschluss der Aufgabe.
"""
# Schrittausführungs-Tracker
step_execution_tracker: Dict[str, Dict] = Feld(default_factory=dict)
current_step_index: Optional[int] = Keine
async def think(self) -> bool.
"""Entscheide die nächste Aktion basierend auf dem Planstatus."""""
prompt = (
f "AKTUELLER PLANSTATUS:n{await self.get_plan()}nn{self.next_step_prompt}""
if self.active_plan_id
sonst self.next_step_prompt
)
self.messages.append(Nachricht.user_message(prompt))
# Aktuellen Schrittindex abrufen
self.current_step_index = await self._get_current_step_index()
Ergebnis = await super().think()
# Verknüpfen eines Werkzeugaufrufs mit dem aktuellen Schritt
if result und self.tool_calls:
# ... Assoziierende Logik ...
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).
"""
Ein vielseitiger Allzweck-Agent, der Planung zur Lösung verschiedener Aufgaben verwendet.
Dieser Agent erweitert PlanningAgent um einen umfassenden Satz von Werkzeugen und Fähigkeiten, einschließlich Python-Ausführung, Web-Browsing, Dateioperationen und Informationsmanagement.
Dieser Agent erweitert PlanningAgent um einen umfassenden Satz von Werkzeugen und Fähigkeiten, einschließlich Python-Ausführung, Web-Browsing, Dateioperationen und Informationsmanagement. Abruf
um ein breites Spektrum von Benutzeranfragen zu bearbeiten.
"""
name: str = "manus"
description: str = "Ein vielseitiger Allzweck-Agent"
system_prompt: str = SYSTEM_PROMPT
nächster_schritt_prompt: str = NEXT_STEP_PROMPT
available_tools: ToolCollection = Feld(
default_factory=lambda: WerkzeugSammlung(
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 = "Du bist OpenManus, ein vollwertiger KI-Assistent, der jede vom Benutzer gestellte Aufgabe lösen kann. Dir stehen verschiedene Werkzeuge zur Verfügung Ihnen stehen verschiedene Werkzeuge zur Verfügung, die Sie zur effizienten Erledigung komplexer Aufgaben heranziehen können. Ob Programmieren, Informationsbeschaffung, Dateiverarbeitung oder Surfen im Internet, du kannst alles bewältigen."

Das Prompt teilt dem Agenten mit, dass es sich um einen universell einsetzbaren KI-Assistenten handelt, der eine Vielzahl von Tools nutzen 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 = """
Sie sind ein Planungsexperte und haben die Aufgabe, komplexe Probleme durch die Erstellung und Verwaltung strukturierter Pläne zu lösen.
Ihre Aufgabe ist.
1. die Anfragen zu analysieren, um den Umfang der Aufgabe zu verstehen
2. klare, umsetzbare Pläne mit dem Werkzeug `Planung` zu erstellen
3. führen Sie die Schritte mit den verfügbaren Werkzeugen nach Bedarf aus
4. den Fortschritt verfolgen und die Pläne dynamisch anpassen
5. mit `finish` die Aufgabe abschließen
Die verfügbaren Werkzeuge sind je nach Aufgabe unterschiedlich, können aber Folgendes umfassen.
- Planen": Pläne erstellen, aktualisieren und verfolgen (Befehle: create, update, mark_step, etc.)
- Beenden": Beendet die Aufgabe nach Abschluss
Unterteilen Sie Aufgaben in logische, aufeinander folgende Schritte und denken Sie an Abhängigkeiten und Überprüfungsmethoden.
"""

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

Aufforderung zur Verwendung des Tools: Informiert den Agent ü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 = """Sie können mit dem Computer mit PythonExecute, Speichern wichtiger Inhalte und Informationsdateien mit FileSaver, Öffnen von Browsern mit BrowserUseTool und Abrufen von Informationen mit GoogleSearch.
PythonExecute: Ausführen von Python-Code zur Interaktion mit dem Computersystem, Datenverarbeitung, Automatisierungsaufgaben usw.
FileSaver: Dateien lokal speichern, z. B. txt, py, html, usw.
BrowserUseTool: Öffnen, durchsuchenWenn Sie eine lokale HTML-Datei öffnen, müssen Sie den absoluten Pfad zu dieser Datei angeben.
GoogleSearch: Abrufen von Webinformationen
Wählen Sie je nach Bedarf des Benutzers proaktiv das am besten geeignete Werkzeug oder die am besten geeignete Kombination von Werkzeugen aus. Bei komplexen Aufgaben können Sie das Problem aufschlüsseln und verschiedene Werkzeuge Schritt für Schritt zur Lösung einsetzen. Bei komplexen Aufgaben können Sie das Problem aufschlüsseln und Schritt für Schritt mit verschiedenen Werkzeugen lösen. Erläutern Sie nach dem Einsatz jedes Werkzeugs deutlich die Ergebnisse der Ausführung und schlagen Sie die nächsten Schritte vor.
"Erläutern Sie nach dem Einsatz der einzelnen Werkzeuge die Ergebnisse und schlagen Sie die nächsten Schritte vor.

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.
"""Entscheide die nächste Aktion basierend auf dem Planstatus."""""
prompt = (
f "AKTUELLER PLANSTATUS:n{await self.get_plan()}nn{self.next_step_prompt}""
if self.active_plan_id
sonst 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. PlanningAgent, undSWEAgent 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 Werkzeugabstraktion.
   • 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.