AutoGPTFlow
- AutoGPTFlow

AutoGPTFlow

AutoGPTFlow Objects

class AutoGPTFlow(ControllerExecutorFlow)

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

set_up_flow_state

def set_up_flow_state()

This method sets up the state of the flow. It's called at the beginning of the flow.

prepare_memory_read_output

def prepare_memory_read_output(data_dict: Dict[str, Any], **kwargs)

This method prepares the output of the Memory Flow to be used by the Controller Flow.

prepare_memory_read_input

def prepare_memory_read_input() -> Dict[str, Any]

This method prepares the input of the Memory Flow to read memories

Returns:

Dict[str, Any]: The input of the Memory Flow to read memories

prepare_memory_write_input

def prepare_memory_write_input() -> Dict[str, Any]

This method prepares the input of the Memory Flow to write memories

Returns:

Dict[str, Any]: The input of the Memory Flow to write memories

call_memory_read

def call_memory_read()

This method calls the Memory Flow to read memories.

call_memory_write

def call_memory_write()

This method calls the Memory Flow to write memories.

call_human_feedback

def call_human_feedback()

This method calls the HumanFeedback Flow to get feedback from the user/human.

register_data_to_state

def register_data_to_state(input_message)

This method registers the data from the input message to the state of the flow.

run

def run(input_message)

This method runs the flow. It's the main method of the flow. It's called when the flow is executed. It calls the subflows circularly.

aiflows
/

AutoGPTFlowModule

Table of Contents