mirror of
https://github.com/aljazceru/Auto-GPT.git
synced 2026-02-22 06:34:32 +01:00
a74548d3cd
This incremental re-architecture unifies Agent code and plugins, so everything is component-based. ## Breaking changes - Removed command categories and `DISABLED_COMMAND_CATEGORIES` environment variable. Use `DISABLED_COMMANDS` environment variable to disable individual commands. - Changed `command` decorator; old-style commands are no longer supported. Implement `CommandProvider` on components instead. - Removed `CommandRegistry`, now all commands are provided by components implementing `CommandProvider`. - Removed `prompt_config` from `AgentSettings`. - Removed plugin support: old plugins will no longer be loaded and executed. - Removed `PromptScratchpad`, it was used by plugins and is no longer needed. - Changed `ThoughtProcessOutput` from tuple to pydantic `BaseModel`. ## Other changes - Created `AgentComponent`, protocols and logic to execute them. - `BaseAgent` and `Agent` is now composed of components. - Moved some logic from `BaseAgent` to `Agent`. - Moved agent features and commands to components. - Removed check if the same operation is about to be executed twice in a row. - Removed file logging from `FileManagerComponent` (formerly `AgentFileManagerMixin`) - Updated tests - Added docs See [Introduction](https://github.com/kcze/AutoGPT/blob/kpczerwinski/open-440-modular-agents/docs/content/AutoGPT/component%20agent/introduction.md) for more information.
102 lines
3.2 KiB
Markdown
102 lines
3.2 KiB
Markdown
# 🛠️ Commands
|
|
|
|
Commands are a way for the agent to do anything; e.g. interact with the user or APIs and use tools. They are provided by components that implement the `CommandProvider` [⚙️ Protocol](./protocols.md). Commands are functions that can be called by the agent, they can have parameters and return values that will be seen by the agent.
|
|
|
|
```py
|
|
class CommandProvider(Protocol):
|
|
def get_commands(self) -> Iterator[Command]:
|
|
...
|
|
```
|
|
|
|
## `command` decorator
|
|
|
|
The easiest and recommended way to provide a command is to use `command` decorator on a component method and then just yield it in `get_commands` as part of your provider. Each command needs a name, description and a parameter schema - `JSONSchema`. By default method name is used as a command name, and first part of docstring for the description (before first double newline) and schema can be provided in the decorator.
|
|
|
|
### Example usage of `command` decorator
|
|
|
|
```py
|
|
# Assuming this is inside some component class
|
|
@command(
|
|
parameters={
|
|
"a": JSONSchema(
|
|
type=JSONSchema.Type.INTEGER,
|
|
description="The first number",
|
|
required=True,
|
|
),
|
|
"b": JSONSchema(
|
|
type=JSONSchema.Type.INTEGER,
|
|
description="The second number",
|
|
required=True,
|
|
)})
|
|
def multiply(self, a: int, b: int) -> str:
|
|
"""
|
|
Multiplies two numbers.
|
|
|
|
Args:
|
|
a: First number
|
|
b: Second number
|
|
|
|
Returns:
|
|
Result of multiplication
|
|
"""
|
|
return str(a * b)
|
|
```
|
|
|
|
The agent will be able to call this command, named `multiply` with two arguments and will receive the result. The command description will be: `Multiplies two numbers.`
|
|
|
|
We can provide `names` and `description` in the decorator, the above command is equivalent to:
|
|
|
|
```py
|
|
@command(
|
|
names=["multiply"],
|
|
description="Multiplies two numbers.",
|
|
parameters={
|
|
"a": JSONSchema(
|
|
type=JSONSchema.Type.INTEGER,
|
|
description="The first number",
|
|
required=True,
|
|
),
|
|
"b": JSONSchema(
|
|
type=JSONSchema.Type.INTEGER,
|
|
description="The second number",
|
|
required=True,
|
|
)})
|
|
def multiply_command(self, a: int, b: int) -> str:
|
|
return str(a * b)
|
|
```
|
|
|
|
To provide the `multiply` command to the agent, we need to yield it in `get_commands`:
|
|
|
|
```py
|
|
def get_commands(self) -> Iterator[Command]:
|
|
yield self.multiply
|
|
```
|
|
|
|
## Creating `Command` directly
|
|
|
|
If you don't want to use the decorator, you can create a `Command` object directly.
|
|
|
|
```py
|
|
|
|
def multiply(self, a: int, b: int) -> str:
|
|
return str(a * b)
|
|
|
|
def get_commands(self) -> Iterator[Command]:
|
|
yield Command(
|
|
names=["multiply"],
|
|
description="Multiplies two numbers.",
|
|
method=self.multiply,
|
|
parameters=[
|
|
CommandParameter(name="a", spec=JSONSchema(
|
|
type=JSONSchema.Type.INTEGER,
|
|
description="The first number",
|
|
required=True,
|
|
)),
|
|
CommandParameter(name="b", spec=JSONSchema(
|
|
type=JSONSchema.Type.INTEGER,
|
|
description="The second number",
|
|
required=True,
|
|
)),
|
|
],
|
|
)
|
|
``` |