# 🛠️ 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](https://docs.agpt.co/forge/components/protocols/). Commands are functions that can be called by the agent, they can have parameters and return values that will be seen by the agent.

```
class CommandProvider(Protocol):
    def get_commands(self) -> Iterator[Command]:
        ...
```

## `Command` Decorator <a href="#command-decorator" id="command-decorator"></a>

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[¶](https://docs.agpt.co/forge/components/commands/#example-usage-of-command-decorator) <a href="#example-usage-of-command-decorator" id="example-usage-of-command-decorator"></a>

```
# 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:

```
@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`:

```
def get_commands(self) -> Iterator[Command]:
    yield self.multiply
```

## Creating `Command` Directly[¶](https://docs.agpt.co/forge/components/commands/#creating-command-directly) <a href="#creating-command-directly" id="creating-command-directly"></a>

If you don't want to use the decorator, you can create a `Command` object directly.

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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://agpt.co/docs/classic/forge/component-agent-introduction/commands.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.