Proper Doc

README.md

@@ -1,15 +1,19 @@
 ---
 license: mit
 ---
-
 # Table of Contents
 
 * [AutoGPTFlow](#AutoGPTFlow)
   * [AutoGPTFlow](#AutoGPTFlow.AutoGPTFlow)
-    * [prepare\_memory\_read\_input](#AutoGPTFlow.AutoGPTFlow.prepare_memory_read_input)
+    * [set\_up\_flow\_state](#AutoGPTFlow.AutoGPTFlow.set_up_flow_state)
     * [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)
+    * [prepare\_memory\_read\_input](#AutoGPTFlow.AutoGPTFlow.prepare_memory_read_input)
+    * [prepare\_memory\_write\_input](#AutoGPTFlow.AutoGPTFlow.prepare_memory_write_input)
+    * [call\_memory\_read](#AutoGPTFlow.AutoGPTFlow.call_memory_read)
+    * [call\_memory\_write](#AutoGPTFlow.AutoGPTFlow.call_memory_write)
+    * [call\_human\_feedback](#AutoGPTFlow.AutoGPTFlow.call_human_feedback)
+    * [register\_data\_to\_state](#AutoGPTFlow.AutoGPTFlow.register_data_to_state)
+    * [run](#AutoGPTFlow.AutoGPTFlow.run)
 
 <a id="AutoGPTFlow"></a>
 
@@ -20,7 +24,7 @@ license: mit
 ## AutoGPTFlow Objects
 
 ```python
-class AutoGPTFlow(CircularFlow)
+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:
@@ -82,91 +86,102 @@ An illustration of the flow is as follows:
 - `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>
+<a id="AutoGPTFlow.AutoGPTFlow.set_up_flow_state"></a>
 
-#### prepare\_memory\_read\_input
+#### set\_up\_flow\_state
 
 ```python
-@CircularFlow.input_msg_payload_builder
-def prepare_memory_read_input(flow_state: Dict[str, Any],
-                              dst_flow: ChromaDBFlow) -> Dict[str, Any]
+def set_up_flow_state()
 ```
 
-This method prepares the input for the Memory Flow. It is called before the Memory Flow is called.
+This method sets up the state of the flow. It's called at the beginning of the flow.
 
-A (very) basic example implementation of how the memory retrieval could be constructed.
+<a id="AutoGPTFlow.AutoGPTFlow.prepare_memory_read_output"></a>
 
-**Arguments**:
+#### prepare\_memory\_read\_output
+
+```python
+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.
+
+<a id="AutoGPTFlow.AutoGPTFlow.prepare_memory_read_input"></a>
+
+#### prepare\_memory\_read\_input
+
+```python
+def prepare_memory_read_input() -> Dict[str, Any]
+```
 
-- `flow_state` (`Dict[str, Any]`): The state of the flow
-- `dst_flow` (`Flow`): The destination flow
+This method prepares the input of the Memory Flow to read memories
 
 **Returns**:
 
-`Dict[str, Any]`: The input message for the Memory Flow
+`Dict[str, Any]`: The input of the Memory Flow to read memories
 
-<a id="AutoGPTFlow.AutoGPTFlow.prepare_memory_read_output"></a>
+<a id="AutoGPTFlow.AutoGPTFlow.prepare_memory_write_input"></a>
 
-#### prepare\_memory\_read\_output
+#### prepare\_memory\_write\_input
 
 ```python
-@CircularFlow.output_msg_payload_processor
-def prepare_memory_read_output(output_payload: Dict[str, Any],
-                               src_flow: ControllerAtomicFlow)
+def prepare_memory_write_input() -> Dict[str, Any]
 ```
 
-This method processes the output of the Memory Flow. It is called after the Memory Flow is called.
+This method prepares the input of the Memory Flow to write memories
 
-**Arguments**:
+**Returns**:
 
-- `output_payload` (`Dict[str, Any]`): The output payload of the Memory Flow
-- `src_flow` (`Flow`): The source flow
+`Dict[str, Any]`: The input of the Memory Flow to write memories
 
-**Returns**:
+<a id="AutoGPTFlow.AutoGPTFlow.call_memory_read"></a>
+
+#### call\_memory\_read
+
+```python
+def call_memory_read()
+```
 
-`Dict[str, Any]`: The processed output payload
+This method calls the Memory Flow to read memories.
 
-<a id="AutoGPTFlow.AutoGPTFlow.detect_finish_or_continue"></a>
+<a id="AutoGPTFlow.AutoGPTFlow.call_memory_write"></a>
 
-#### detect\_finish\_or\_continue
+#### call\_memory\_write
 
 ```python
-@CircularFlow.output_msg_payload_processor
-def detect_finish_or_continue(
-        output_payload: Dict[str, Any],
-        src_flow: ControllerAtomicFlow) -> Dict[str, Any]
+def call_memory_write()
 ```
 
-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.
+This method calls the Memory Flow to write memories.
 
-**Arguments**:
+<a id="AutoGPTFlow.AutoGPTFlow.call_human_feedback"></a>
 
-- `output_payload` (`Dict[str, Any]`): The output payload of the Controller Flow
-- `src_flow` (`Flow`): The source flow
+#### call\_human\_feedback
 
-**Returns**:
+```python
+def call_human_feedback()
+```
 
-`Dict[str, Any]`: The processed output payload
+This method calls the HumanFeedback Flow to get feedback from the user/human.
 
-<a id="AutoGPTFlow.AutoGPTFlow.detect_finish_in_human_input"></a>
+<a id="AutoGPTFlow.AutoGPTFlow.register_data_to_state"></a>
 
-#### detect\_finish\_in\_human\_input
+#### register\_data\_to\_state
 
 ```python
-@CircularFlow.output_msg_payload_processor
-def detect_finish_in_human_input(
-        output_payload: Dict[str, Any],
-        src_flow: ControllerAtomicFlow) -> Dict[str, Any]
+def register_data_to_state(input_message)
 ```
 
-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.
+This method registers the data from the input message to the state of the flow.
 
-**Arguments**:
+<a id="AutoGPTFlow.AutoGPTFlow.run"></a>
 
-- `output_payload` (`Dict[str, Any]`): The output payload of the HumanFeedback Flow
-- `src_flow` (`Flow`): The source flow
+#### run
 
-**Returns**:
+```python
+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.
 
-`Dict[str, Any]`: The processed output payload