| ### Structure of ExtendLibraryFlow | |
| ``` | |
| goal, memory_files (dict) | |
| | | |
| v | |
| +-------------------+ | |
| | MemoryReading | Reads in the content of the memory files | |
| | Flow | | |
| +-------------------+ | |
| | | |
| | (memory_content) | |
| | | |
| v | |
| +-------------------+ | |
| | PlanWriter | Writes a step-by-step plan to achieve the goal | |
| +-------------------+ | |
| | | |
| | (plan) | |
| | | |
| v | |
| +-------------------+ | |
| | CtrlExMemFlow | Illustrated below. Carries out the plan in an controller-executor fashion, | |
| | | with memory management mechanisms. | |
| +-------------------+ | |
| | | |
| (summary, result) | |
| ``` | |
| Here is the structure of the `CtrlExMemFlow`: | |
| ``` | |
| plan, memory_files, memory_content, goal | |
| | | |
| v | |
| +---------------+ | |
| | Controller | --------<<<<-----------+ | |
| +---------------+ | | |
| | | | |
| | (command, command args) | | |
| | | | |
| v | | |
| +------------------+ | | |
| | Executor | Each branch is an | | |
| | (Tree Structure) | executor | | |
| +------------------+ | | |
| | ^ | |
| | (execution results) ^ | |
| | ^ | |
| v ^ | |
| +---------------+ ^ | |
| | MemWriteFlow | Updates memory files ^ | |
| +---------------+ ^ | |
| | ^ | |
| | (summary) | | |
| | | | |
| v | | |
| +---------------+ | | |
| | MemReadFlow | Reads updated memory | | |
| +---------------+ | | |
| | | | |
| | (updated memory content) | | |
| | | | |
| +-> goes back to the Controller>-+ | |
| ``` | |
| Structure of the Executors: | |
| ``` | |
| +-------------------+ | |
| | Branching | | |
| | Executor | | |
| +-------------------+ | |
| / | | | \ | |
| / | | | \ | |
| / | | | \ | |
| / | | | \ | |
| write_code ask_user re_plan update_plan save_code | |
| ``` | |
| Memory files of ExtendLibraryFlow: | |
| - plan_extlib.txt | |
| - logs_extlib.txt | |
| - library.py | |
| About the branches: | |
| - [write_code](https://huggingface.co/Tachi67/CodeWriterFlowModule): Generates code in an interactive way, the user is able to edit or provide feedback during the process of writing code. | |
| - [ask_user](https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/ExtLibAskUserFlow.py): Ask user for info / confirmation, etc. | |
| - [re_plan](https://huggingface.co/Tachi67/ReplanningFlowModule): One branch of the executors, when something goes wrong, re-draft the plan. | |
| - [update_plan](https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/UpdatePlanAtomicFlow.py): One branch of the executors, when the controller realizes that one (or some, depending on the LLM's response) step of the plan is (are) done, it generates a new plan that marks the step(s) as done. | |
| - [save_code](https://huggingface.co/Tachi67/ExtendLibraryFlowModule/blob/main/SaveCodeAtomicFlow.py): Writes the wriiten & tested code to the code library. | |
| # Table of Contents | |
| * [SaveCodeAtomicFlow](#SaveCodeAtomicFlow) | |
| * [SaveCodeAtomicFlow](#SaveCodeAtomicFlow.SaveCodeAtomicFlow) | |
| * [run](#SaveCodeAtomicFlow.SaveCodeAtomicFlow.run) | |
| * [ExtLibAskUserFlow](#ExtLibAskUserFlow) | |
| * [ExtLibAskUserFlow](#ExtLibAskUserFlow.ExtLibAskUserFlow) | |
| * [ExtendLibraryFlow](#ExtendLibraryFlow) | |
| * [ExtendLibraryFlow](#ExtendLibraryFlow.ExtendLibraryFlow) | |
| * [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow) | |
| * [UpdatePlanAtomicFlow](#UpdatePlanAtomicFlow.UpdatePlanAtomicFlow) | |
| * [run\_ExtendLibrary](#run_ExtendLibrary) | |
| * [CtrlExMem\_ExtLib](#CtrlExMem_ExtLib) | |
| * [CtrlExMem\_ExtLib](#CtrlExMem_ExtLib.CtrlExMem_ExtLib) | |
| * [ControllerFlow\_ExtLib](#ControllerFlow_ExtLib) | |
| * [ControllerFlow\_ExtLib](#ControllerFlow_ExtLib.ControllerFlow_ExtLib) | |
| * [\_\_init\_\_](#__init__) | |
| <a id="SaveCodeAtomicFlow"></a> | |
| # SaveCodeAtomicFlow | |
| <a id="SaveCodeAtomicFlow.SaveCodeAtomicFlow"></a> | |
| ## SaveCodeAtomicFlow Objects | |
| ```python | |
| class SaveCodeAtomicFlow(AtomicFlow) | |
| ``` | |
| This flow appends the code to the code library file. | |
| *Input Interface*: | |
| - `code` (str): the code to be appended to the code library | |
| - `memory_files` (dict): the dictionary of memory files | |
| *Output Interface*: | |
| - `result` (str): the result of the flow, to be returned to the controller of the caller | |
| - `summary` (str): the summary of the flow, to be appended to logs | |
| <a id="SaveCodeAtomicFlow.SaveCodeAtomicFlow.run"></a> | |
| #### run | |
| ```python | |
| def run(input_data: Dict[str, Any]) | |
| ``` | |
| Run the flow | |
| **Arguments**: | |
| - `input_data`: the input data | |
| **Returns**: | |
| the output data | |
| <a id="ExtLibAskUserFlow"></a> | |
| # ExtLibAskUserFlow | |
| <a id="ExtLibAskUserFlow.ExtLibAskUserFlow"></a> | |
| ## ExtLibAskUserFlow Objects | |
| ```python | |
| class ExtLibAskUserFlow(HumanStandardInputFlow) | |
| ``` | |
| This class is used to ask for user feedback whenever the controller is unsure of something, or need confirmation, etc. | |
| *Expected Input*: | |
| - `question`: The question asked by the controller | |
| *Expected Behaviour*: | |
| - The question is displayed, and the user gives feedback by inputing string. | |
| *Expected Ouput*: | |
| - `result`: The input of the user. | |
| - `summary`: The summary that will be written by the caller. | |
| <a id="ExtendLibraryFlow"></a> | |
| # ExtendLibraryFlow | |
| <a id="ExtendLibraryFlow.ExtendLibraryFlow"></a> | |
| ## ExtendLibraryFlow Objects | |
| ```python | |
| class ExtendLibraryFlow(AbstractBossFlow) | |
| ``` | |
| ExtendLibraryFlow is one branch executor of CoderFlow. At a higher level, it takes the goal | |
| from the Coder, writes functions in an interactive way, test the code and append the newly written function to | |
| the code library. | |
| Workflow of ExtendLibrary: | |
| 0. Coder calls ExtendLibrary with a goal. | |
| 1. MemoryReading reads logs, plan, and code library. | |
| 2. Planner makes a plan based on the goal. | |
| 3. Write code in an interactive fashion. | |
| 4. Test code. | |
| 5. Finish, writes code to the library. | |
| Step 3-5 is done via prompting the controller. | |
| *Input Interface (expected input)* | |
| - `goal` (str): The goal from the caller (source flow, i.e. CoderFlow) | |
| *Output Interface (expected output)* | |
| - `result` (str): The result of the flow, the result will be returned to the caller (i.e. CoderFlow). | |
| - `summary` (str): The summary of the flow, the summary will be logged into the logs of the caller flow (i.e. CoderFlow). | |
| <a id="UpdatePlanAtomicFlow"></a> | |
| # UpdatePlanAtomicFlow | |
| <a id="UpdatePlanAtomicFlow.UpdatePlanAtomicFlow"></a> | |
| ## UpdatePlanAtomicFlow Objects | |
| ```python | |
| class UpdatePlanAtomicFlow(AtomicFlow) | |
| ``` | |
| Refer to: https://huggingface.co/Tachi67/CoderFlowModule/blob/main/UpdatePlanAtomicFlow.py | |
| <a id="run_ExtendLibrary"></a> | |
| # run\_ExtendLibrary | |
| <a id="CtrlExMem_ExtLib"></a> | |
| # CtrlExMem\_ExtLib | |
| <a id="CtrlExMem_ExtLib.CtrlExMem_ExtLib"></a> | |
| ## CtrlExMem\_ExtLib Objects | |
| ```python | |
| class CtrlExMem_ExtLib(CtrlExMemFlow) | |
| ``` | |
| This class inherits from the CtrlExMemFlow class from AbstractBossFlowModule. | |
| See: https://huggingface.co/Tachi67/AbstractBossFlowModule/blob/main/CtrlExMemFlow.py | |
| *Input Interface*: | |
| - `plan` | |
| - `logs` | |
| - `memory_files` | |
| - `goal` | |
| *Output Interface* | |
| - `result` (str): The result of the flow, the result will be returned to the caller. | |
| - `summary` (str): The summary of the flow, the summary will be logged into the logs of the caller flow. | |
| <a id="ControllerFlow_ExtLib"></a> | |
| # ControllerFlow\_ExtLib | |
| <a id="ControllerFlow_ExtLib.ControllerFlow_ExtLib"></a> | |
| ## ControllerFlow\_ExtLib Objects | |
| ```python | |
| class ControllerFlow_ExtLib(ChatAtomicFlow) | |
| ``` | |
| Refer to: https://huggingface.co/Tachi67/JarvisFlowModule/blob/main/Controller_JarvisFlow.py | |
| <a id="__init__"></a> | |
| # \_\_init\_\_ | |