---
license: mit
---

# Table of Contents

* [AutoGPTFlow](#AutoGPTFlow)
  * [AutoGPTFlow](#AutoGPTFlow.AutoGPTFlow)
    * [prepare\_memory\_read\_input](#AutoGPTFlow.AutoGPTFlow.prepare_memory_read_input)
    * [prepare\_memory\_read\_output](#AutoGPTFlow.AutoGPTFlow.prepare_memory_read_output)
    * [detect\_finish\_or\_continue](#AutoGPTFlow.AutoGPTFlow.detect_finish_or_continue)
    * [detect\_finish\_in\_human\_input](#AutoGPTFlow.AutoGPTFlow.detect_finish_in_human_input)

<a id="AutoGPTFlow"></a>

# AutoGPTFlow

<a id="AutoGPTFlow.AutoGPTFlow"></a>

## AutoGPTFlow Objects

```python
class AutoGPTFlow(CircularFlow)
```

This class implements a (very basic) AutoGPT flow. It is a flow that consists of multiple sub-flows that are executed circularly. It Contains the following subflows:

- A Controller Flow: A Flow that controls which subflow of the Executor Flow to execute next.
- A Memory Flow: A Flow used to save and retrieve messages or memories which might be useful for the Controller Flow.
- A HumanFeedback Flow: A flow use to get feedback from the user/human.
- A Executor Flow: A Flow that executes commands generated by the Controller Flow. Typically it's a branching flow (see BranchingFlow) and the commands are which branch to execute next.

An illustration of the flow is as follows:

    | -------> Memory Flow -------> Controller Flow ------->|
    ^                                                       |      
    |                                                       |
    |                                                       v
    | <----- HumanFeedback Flow <------- Executor Flow <----|

*Configuration Parameters*:

- `name` (str): The name of the flow. Default is "AutoGPTFlow".
- `description` (str): A description of the flow.  Default is "An example implementation of AutoGPT with Flows."
- `max_rounds` (int): The maximum number of rounds the circular flow can run for. Default is 30.
- `early_exit_key` (str): The key that is used to terminate the flow early. Default is "EARLY_EXIT".
- `subflows_config` (Dict[str,Any]): A dictionary of subflows configurations. Default:
    - `Controller` (Dict[str,Any]): The configuration of the Controller Flow. By default the controller flow is a ControllerAtomicFlow (see ControllerExecutorFlowModule). It's default values are
    defined in ControllerAtomicFlow.yaml of the ControllerExecutorFlowModule. Except for the following parameters who are overwritten by the AutoGPTFlow in AutoGPTFlow.yaml:
        - `finish` (Dict[str,Any]): The configuration of the finish command (used to terminate the flow early when the controller has accomplished its goal).
            - `description` (str):  The description of the command. Default is "The finish command is used to terminate the flow early when the controller has accomplished its goal."
            - `input_args` (List[str]): The list of expected keys to run the finish command. Default is ["answer"].
            - `human_message_prompt_template`(Dict[str,Any]): The prompt template used to generate the message that is shown to the user/human when the finish command is executed. Default is:
                - `template` (str): The template of the humand message prompt (see AutoGPTFlow.yaml for default template)
                - `input_variables` (List[str]): The list of variables to be included in the template. Default is ["observation", "human_feedback", "memory"].
        - `ìnput_interface_initialized` (List[str]): The input interface that Controller Flow expects except for the first time in the flow. Default is ["observation", "human_feedback", "memory"].
    - `Executor` (Dict[str,Any]): The configuration of the Executor Flow. By default the executor flow is a Branching Flow (see BranchingFlow). It's default values are the default values of the BranchingFlow. Fields to define:
        - `subflows_config` (Dict[str,Any]):  A Dictionary of subflows configurations.The keys are the names of the subflows and the values are the configurations of the subflows. Each subflow is a branch of the branching flow.
    - `HumanFeedback` (Dict[str,Any]): The configuration of the HumanFeedback Flow. By default the human feedback flow is a HumanStandardInputFlow (see HumanStandardInputFlowModule ).
    It's default values are specified in the REAMDE.md of HumanStandardInputFlowModule. Except for the following parameters who are overwritten by the AutoGPTFlow in AutoGPTFlow.yaml:
        - `request_multi_line_input_flag` (bool): Flag to request multi-line input. Default is False.
        - `query_message_prompt_template` (Dict[str,Any]): The prompt template presented to the user/human to request input. Default is:
            - `template` (str): The template of the query message prompt (see AutoGPTFlow.yaml for default template)
            - `input_variables` (List[str]): The list of variables to be included in the template. Default is ["goal","command","command_args",observation"]
        - input_interface_initialized (List[str]):  The input interface that HumanFeeback Flow expects except for the first time in the flow. Default is ["goal","command","command_args",observation"]
    - `Memory` (Dict[str,Any]): The configuration of the Memory Flow. By default the memory flow is a ChromaDBFlow (see VectorStoreFlowModule). It's default values are defined in ChromaDBFlow.yaml of the VectorStoreFlowModule. Except for the following parameters who are overwritten by the AutoGPTFlow in AutoGPTFlow.yaml:
        - `n_results`: The number of results to retrieve from the memory. Default is 2.
- `topology` (List[Dict[str,Any]]): The topology of the flow which is "circular". By default, the topology is the one shown in the illustration above (the topology is also described in AutoGPTFlow.yaml).


*Input Interface*:

- `goal` (str): The goal of the flow.

*Output Interface*:

- `answer` (str): The answer of the flow.
- `status` (str): The status of the flow. It can be "finished" or "unfinished".

**Arguments**:

- `flow_config` (`Dict[str,Any]`): The configuration of the flow. Contains the parameters described above and the parameters required by the parent class (CircularFlow).
- `subflows` (`List[Flow]`): A list of subflows constituating the circular flow. Required when instantiating the subflow programmatically (it replaces subflows_config from flow_config).

<a id="AutoGPTFlow.AutoGPTFlow.prepare_memory_read_input"></a>

#### prepare\_memory\_read\_input

```python
@CircularFlow.input_msg_payload_builder
def prepare_memory_read_input(flow_state: Dict[str, Any],
                              dst_flow: ChromaDBFlow) -> Dict[str, Any]
```

This method prepares the input for the Memory Flow. It is called before the Memory Flow is called.

A (very) basic example implementation of how the memory retrieval could be constructed.

**Arguments**:

- `flow_state` (`Dict[str, Any]`): The state of the flow
- `dst_flow` (`Flow`): The destination flow

**Returns**:

`Dict[str, Any]`: The input message for the Memory Flow

<a id="AutoGPTFlow.AutoGPTFlow.prepare_memory_read_output"></a>

#### prepare\_memory\_read\_output

```python
@CircularFlow.output_msg_payload_processor
def prepare_memory_read_output(output_payload: Dict[str, Any],
                               src_flow: ControllerAtomicFlow)
```

This method processes the output of the Memory Flow. It is called after the Memory Flow is called.

**Arguments**:

- `output_payload` (`Dict[str, Any]`): The output payload of the Memory Flow
- `src_flow` (`Flow`): The source flow

**Returns**:

`Dict[str, Any]`: The processed output payload

<a id="AutoGPTFlow.AutoGPTFlow.detect_finish_or_continue"></a>

#### detect\_finish\_or\_continue

```python
@CircularFlow.output_msg_payload_processor
def detect_finish_or_continue(
        output_payload: Dict[str, Any],
        src_flow: ControllerAtomicFlow) -> Dict[str, Any]
```

This method detects whether the Controller flow has generated a "finish" command or not to terminate the flow. . It is called after the Controller Flow is called.

**Arguments**:

- `output_payload` (`Dict[str, Any]`): The output payload of the Controller Flow
- `src_flow` (`Flow`): The source flow

**Returns**:

`Dict[str, Any]`: The processed output payload

<a id="AutoGPTFlow.AutoGPTFlow.detect_finish_in_human_input"></a>

#### detect\_finish\_in\_human\_input

```python
@CircularFlow.output_msg_payload_processor
def detect_finish_in_human_input(
        output_payload: Dict[str, Any],
        src_flow: ControllerAtomicFlow) -> Dict[str, Any]
```

This method detects whether the HumanFeedback (the human/user) flow has generated a "finish" command or not to terminate the flow. It is called after the HumanFeedback Flow is called.

**Arguments**:

- `output_payload` (`Dict[str, Any]`): The output payload of the HumanFeedback Flow
- `src_flow` (`Flow`): The source flow

**Returns**:

`Dict[str, Any]`: The processed output payload