Upload 7 files

AbstractBossFlow.py

@@ -0,0 +1,94 @@
+from copy import deepcopy
+from typing import Dict, Any
+
+from aiflows.base_flows import SequentialFlow
+from aiflows.utils import logging
+from abc import ABC
+
+
+logging.set_verbosity_debug()
+log = logging.get_logger(__name__)
+
+class AbstractBossFlow(SequentialFlow, ABC):
+    """This class is an abstraction of memory-planner-controller-executor flow. At a higher level, it is
+    an abstract agent empowered by multiple language models and subsequent tools like code interpreters, etc.
+    It is designed to cooperate with memory management mechanisms, lm-powered planner and controller, and
+    arbitrary executors.
+
+    *Configuration Parameters*
+
+    - `name` (str): Name of the flow.
+    - `description` (str): Description of the flow.
+    - `memory_files` (dict): A dictionary of memory files. The keys are the names of the memory files and the values
+        are the path to the memory files. Typical memory files include plan, logs, code library.
+    - `subflows_config`:
+        - MemoryReading: reads the content of the memory files into the flow states for later use.
+        - Planner: make a step-by-step plan based on the current goal.
+        - CtrlExMem: controller-executor agent with memory reading and memory writing, it will execute the plan generated by the planner.
+    - `early_exit_key` (str): The key in the flow state that indicates the early exit condition.
+    - `topology` (list) : The topology of the flow.
+
+    *Input Interface (expected input)*
+
+    - `goal` (str): The goal from the caller (source flow)
+
+    *Output Interface (expected output)*
+
+    - `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.
+
+    :param memory_files: A dictionary of memory files. The keys are the names of the memory files and the values are the path to the memory files.
+    :type memory_files: dict
+    """
+    REQUIRED_KEYS_CONFIG = ["max_rounds", "early_exit_key", "topology", "memory_files"]
+
+    def __init__(
+            self,
+            memory_files: Dict[str, Any],
+            **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.memory_files = memory_files
+
+    @classmethod
+    def instantiate_from_config(cls, config):
+        """This method instantiates the flow from a configuration dictionary.
+        
+        :param config: The configuration dictionary.
+        :type config: dict
+        """
+        flow_config = deepcopy(config)
+
+        kwargs = {"flow_config": flow_config}
+
+        # ~~~ Set up memory file ~~~
+        memory_files = flow_config["memory_files"]
+        kwargs.update({"memory_files": memory_files})
+
+        # ~~~ Set up subflows ~~~
+        kwargs.update({"subflows": cls._set_up_subflows(flow_config)})
+
+        # ~~~ Instantiate flow ~~~
+        return cls(**kwargs)
+
+    def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """This method runs the flow.
+    
+        :param input_data: The input data, the input_data is supposed to contain 'goal'
+        :type input_data: dict
+        """
+        # ~~~ sets the input_data in the flow_state dict ~~~
+        self._state_update_dict(update_data=input_data)
+
+        # ~~~ set the memory file to the flow state ~~~
+        self._state_update_dict(update_data={"memory_files": self.memory_files})
+
+        max_rounds = self.flow_config.get("max_rounds", 1)
+        if max_rounds is None:
+            log.info(f"Running {self.flow_config['name']} without `max_rounds` until the early exit condition is met.")
+
+        self._sequential_run(max_rounds=max_rounds)
+
+        output = self._get_output_from_state()
+
+        return output

AbstractBossFlow.yaml

@@ -0,0 +1,51 @@
+name: "AbstractBossFlow"
+description: "Abstract class of a boss, e.g. coder, ExtendLibrary, etc."
+
+_target_: flow_modules.aiflows.AbstractBossFlowModule.AbstractBossFlow.instantiate_from_default_config
+
+memory_files: ???
+
+input_interface:
+  - "goal"
+
+output_interface:
+  - "result"
+  - "summary" # to be written into the logs of the upper level boss
+
+subflows_config:
+  MemoryReading:
+    _target_: flow_modules.aiflows.MemoryReadingFlowModule.MemoryReadingAtomicFlow.instantiate_from_default_config
+
+  Planner:
+    _target_: flow_modules.aiflows.PlanWriterFlowModule.PlanWriterFlow.instantiate_from_default_config
+
+  # the flow with a controller, few executors in a branch, memory reading and memory writing
+  CtrlExMem:
+    _target_: flow_modules.aiflows.AbstractBossFlowModule.CtrlExMemFlow.instantiate_from_default_config
+
+early_exit_key: "EARLY_EXIT"
+
+topology:
+  - goal: "Read in necessary memory"
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: aiflows.data_transformations.KeyMatchInput
+    flow: MemoryReading
+    reset: false
+
+  - goal: "Make plans in an interactive fashion, write the plan into the plan file"
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: aiflows.data_transformations.KeyMatchInput
+    flow: Planner
+    reset: false
+
+  - goal: "Execute the plan and return answer & a summary of what was done"
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: aiflows.data_transformations.KeyMatchInput
+    flow: CtrlExMem
+    reset: false

CtrlExMemFlow.py

@@ -0,0 +1,63 @@
+from typing import Dict, Any
+
+from aiflows.base_flows import CircularFlow
+from aiflows.utils import logging
+from abc import ABC, abstractmethod
+
+
+logging.set_verbosity_debug()
+log = logging.get_logger(__name__)
+
+
+class CtrlExMemFlow(CircularFlow, ABC):
+    """This class is the controller-executor agent with memory reading and memory writing, it will execute the plan
+    generated by the planner. This flow is, at a higher level, a circular flow, it runs until either max_round is
+    reached, or the controller decides to early exit (see: detect_finish_or_continue)
+
+    The brain of the flow is the controller, the controller decides what action (which branch of the branching flow)
+    to take next. The controller can also decide to early exit the flow, in which case the flow will stop. After the
+    controller decides what action to take, the controller will pass the action to the executor, the executor will
+    execute the action, yielding `result` and `summary`, which respectively will be passed to the controller and the
+    memory writer (into logs of the upper layer of flow). Depending on the `result`, the controller will decide what
+    action to take next.
+
+    *Configuration Parameters*:
+    - `name` (str): Name of the flow.
+    - `description` (str): Description of the flow.
+    - `max_round` (int): The maximum number of rounds the flow will run. Default: 30.
+    - `subflows_config` (dict): The configuration of the subflows.
+        - `Controller` (dict): The configuration of the controller. It is important that the target of the controller (instance customizable by the user) and the api information should be specified.
+        - `Executor` (dict): The executor of the flow, it is supposed to be a branching flow. To instantiate the executor, the user needs to specify the subflows of the executor (i.e. the actual tools that can be used by the agent, e.g. a flow for interpreting code)
+        - `MemoryWriting` (dict): The configuration of the memory writer. There is an existing memory writing flow implemented.
+        - 'MemoryReading' (dict): The configuration of the memory reader. There is an existing memory reading flow implemented.
+    - `topology` (List): The topology of the subflows, notice that the output interface of the Controller must be implemented and specified.
+
+    *Input Interface*:
+    - `plan` (str): The plan generated by the planner, the CtrlExMem flow should follow the plan.
+    - `memory_files` (dict): mem_name - memfile_path pairs, the memory files that the memory reader will read from.
+    - `goal` (str): The goal of the flow
+    - `logs` (str): Execution history of the flow, contains all actions taken by each subflow of the flow.
+
+    *Output Interface*:
+    - `result` (str): The result of the flow, will be returned to the controller of the caller flow.
+    - `summary` (str): The summary of the flow, will be written to the logs of the caller flow.
+
+    """
+    @abstractmethod
+    def _on_reach_max_round(self):
+        """This function will be called when the flow reaches the maximum number of rounds."""
+        pass
+
+    @abstractmethod
+    @CircularFlow.output_msg_payload_processor
+    def detect_finish_or_continue(self, output_payload: Dict[str, Any], src_flow) -> Dict[str, Any]:
+        """This function is called after the Controller, it is used to:
+        1. Check if the Controller decides to early-exit, if so, implement necessary logics for exiting e.g. drafting result and summary, etc.
+        2. For other commands called by the controller, implement necessary logics for the flow to continue e.g. providing necessary information to the branching flow.
+        :param output_payload: The output payload of the Controller.
+        :type output_payload: Dict[str, Any]
+        :param src_flow: The source flow of the Controller.
+        :type src_flow: Flow
+        :return: The input payload of the Executor.
+        """
+        pass

CtrlExMemFlow.yaml

@@ -0,0 +1,95 @@
+# Abstract class, should provide more information in subclasses
+
+_target_: flow_modules.aiflows.AbstractBossFlowModule.CtrlExMemFlow.instantiate_from_default_config
+
+name: "AbstractCtrlExMemFlow"
+description: "Abstract class of controller-executor flow with mem reading and mem writing"
+max_rounds: 30
+
+input_interface:
+  - "plan"
+  - "memory_files"
+  - "goal"
+  - "logs"
+  
+output_interface:
+  - "summary"
+  - "result"
+
+subflows_config:
+  Controller:
+    _target_: ??? # controller of the flow, could be a subclass of ChatAtomic flow, see https://huggingface.co/Tachi67/CodeWriterFlowModule/blob/main/CodeWriterCtrlFlow.py
+    backend:
+      api_infos: ???
+      model_name:
+        openai: gpt-4
+        azure: azure/gpt-4
+    # In subclasses, should provide specific command and command args.
+# E.g.,
+#    commands:
+#      wiki_search:
+#        description: "Performs a search on Wikipedia."
+#        input_args: ["search_term"]
+
+  Executor:
+     _target_: aiflows.base_flows.BranchingFlow.instantiate_from_default_config
+    # In subclasses, should provide what are the branches of executors
+# E.g.,
+#    subflows_config:
+#      wiki_search:
+#        _target_: .WikiSearchAtomicFlow.instantiate_from_default_config
+
+  MemoryWriting:
+    _target_: flow_modules.aiflows.MemoryWritingFlowModule.MemoryWritingAtomicFlow.instantiate_from_default_config
+    # default input interface is summary & memory_files
+
+  MemoryReading:
+    _target_: flow_modules.aiflows.MemoryReadingFlowModule.MemoryReadingAtomicFlow.instantiate_from_default_config
+    # should provide the output of MemRead in the CtrlExMem flow e.g. plan, logs, code_library
+    # output is then like {"plan":"plan string", "code_library": "function signatures in the code library"}
+    # default output interface is code_library
+
+topology:
+  - goal: "Select the next action and prepare the input for the executor."
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: aiflows.data_transformations.KeyMatchInput
+    flow: Controller
+    output_interface: ???
+      # In subclasses, should provide name of function name of output processor
+      #_target_: Controller.detect_finish_or_continue
+    reset: false
+
+  - goal: "Execute the action specified by the Controller."
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      keys_to_rename:
+        command: branch
+        command_args: branch_input_data
+      keys_to_select: ["branch", "branch_input_data"]
+    flow: Executor
+    output_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      # in subclasses, should provide corresponding output interface of branches      
+      keys_to_rename:
+        branch_output_data.summary: summary
+        branch_output_data.result: result
+      keys_to_delete: [ "branch_output_data" ]
+    reset: false
+
+  - goal: "Write memory to memory files"
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: aiflows.data_transformations.KeyMatchInput
+    flow: MemoryWriting
+    reset: false
+
+  - goal: "Read memory from memory files (flow_state)"
+    input_interface:
+      _target_: aiflows.interfaces.KeyInterface
+      additional_transformations:
+        - _target_: aiflows.data_transformations.KeyMatchInput
+    flow: MemoryReading
+    reset: false

README.md

@@ -1,3 +1,157 @@
----
-license: mit
----
+# Table of Contents
+
+* [AbstractBossFlow](#AbstractBossFlow)
+  * [AbstractBossFlow](#AbstractBossFlow.AbstractBossFlow)
+    * [instantiate\_from\_config](#AbstractBossFlow.AbstractBossFlow.instantiate_from_config)
+    * [run](#AbstractBossFlow.AbstractBossFlow.run)
+* [CtrlExMemFlow](#CtrlExMemFlow)
+  * [CtrlExMemFlow](#CtrlExMemFlow.CtrlExMemFlow)
+    * [detect\_finish\_or\_continue](#CtrlExMemFlow.CtrlExMemFlow.detect_finish_or_continue)
+* [\_\_init\_\_](#__init__)
+
+<a id="AbstractBossFlow"></a>
+
+# AbstractBossFlow
+
+<a id="AbstractBossFlow.AbstractBossFlow"></a>
+
+## AbstractBossFlow Objects
+
+```python
+class AbstractBossFlow(SequentialFlow, ABC)
+```
+
+This class is an abstraction of memory-planner-controller-executor flow. At a higher level, it is
+
+an abstract agent empowered by multiple language models and subsequent tools like code interpreters, etc.
+It is designed to cooperate with memory management mechanisms, lm-powered planner and controller, and
+arbitrary executors.
+
+*Configuration Parameters*
+
+- `name` (str): Name of the flow.
+- `description` (str): Description of the flow.
+- `memory_files` (dict): A dictionary of memory files. The keys are the names of the memory files and the values
+    are the path to the memory files. Typical memory files include plan, logs, code library.
+- `subflows_config`:
+    - MemoryReading: reads the content of the memory files into the flow states for later use.
+    - Planner: make a step-by-step plan based on the current goal.
+    - CtrlExMem: controller-executor agent with memory reading and memory writing, it will execute the plan generated by the planner.
+- `early_exit_key` (str): The key in the flow state that indicates the early exit condition.
+- `topology` (list) : The topology of the flow.
+
+*Input Interface (expected input)*
+
+- `goal` (str): The goal from the caller (source flow)
+
+*Output Interface (expected output)*
+
+- `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.
+
+**Arguments**:
+
+- `memory_files` (`dict`): A dictionary of memory files. The keys are the names of the memory files and the values are the path to the memory files.
+
+<a id="AbstractBossFlow.AbstractBossFlow.instantiate_from_config"></a>
+
+#### instantiate\_from\_config
+
+```python
+@classmethod
+def instantiate_from_config(cls, config)
+```
+
+This method instantiates the flow from a configuration dictionary.
+
+**Arguments**:
+
+- `config` (`dict`): The configuration dictionary.
+
+<a id="AbstractBossFlow.AbstractBossFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any]) -> Dict[str, Any]
+```
+
+This method runs the flow.
+
+**Arguments**:
+
+- `input_data` (`dict`): The input data, the input_data is supposed to contain 'goal'
+
+<a id="CtrlExMemFlow"></a>
+
+# CtrlExMemFlow
+
+<a id="CtrlExMemFlow.CtrlExMemFlow"></a>
+
+## CtrlExMemFlow Objects
+
+```python
+class CtrlExMemFlow(CircularFlow, ABC)
+```
+
+This class is the controller-executor agent with memory reading and memory writing, it will execute the plan
+generated by the planner. This flow is, at a higher level, a circular flow, it runs until either max_round is
+reached, or the controller decides to early exit (see: detect_finish_or_continue)
+
+The brain of the flow is the controller, the controller decides what action (which branch of the branching flow)
+to take next. The controller can also decide to early exit the flow, in which case the flow will stop. After the
+controller decides what action to take, the controller will pass the action to the executor, the executor will
+execute the action, yielding `result` and `summary`, which respectively will be passed to the controller and the
+memory writer (into logs of the upper layer of flow). Depending on the `result`, the controller will decide what
+action to take next.
+
+*Configuration Parameters*:
+- `name` (str): Name of the flow.
+- `description` (str): Description of the flow.
+- `max_round` (int): The maximum number of rounds the flow will run. Default: 30.
+- `subflows_config` (dict): The configuration of the subflows.
+    - `Controller` (dict): The configuration of the controller. It is important that the target of the controller (instance customizable by the user) and the api information should be specified.
+    - `Executor` (dict): The executor of the flow, it is supposed to be a branching flow. To instantiate the executor, the user needs to specify the subflows of the executor (i.e. the actual tools that can be used by the agent, e.g. a flow for interpreting code)
+    - `MemoryWriting` (dict): The configuration of the memory writer. There is an existing memory writing flow implemented.
+    - 'MemoryReading' (dict): The configuration of the memory reader. There is an existing memory reading flow implemented.
+- `topology` (List): The topology of the subflows, notice that the output interface of the Controller must be implemented and specified.
+
+*Input Interface*:
+- `plan` (str): The plan generated by the planner, the CtrlExMem flow should follow the plan.
+- `memory_files` (dict): mem_name - memfile_path pairs, the memory files that the memory reader will read from.
+- `goal` (str): The goal of the flow
+- `logs` (str): Execution history of the flow, contains all actions taken by each subflow of the flow.
+
+*Output Interface*:
+- `result` (str): The result of the flow, will be returned to the controller of the caller flow.
+- `summary` (str): The summary of the flow, will be written to the logs of the caller flow.
+
+<a id="CtrlExMemFlow.CtrlExMemFlow.detect_finish_or_continue"></a>
+
+#### detect\_finish\_or\_continue
+
+```python
+@abstractmethod
+@CircularFlow.output_msg_payload_processor
+def detect_finish_or_continue(output_payload: Dict[str, Any],
+                              src_flow) -> Dict[str, Any]
+```
+
+This function is called after the Controller, it is used to:
+
+1. Check if the Controller decides to early-exit, if so, implement necessary logics for exiting e.g. drafting result and summary, etc.
+2. For other commands called by the controller, implement necessary logics for the flow to continue e.g. providing necessary information to the branching flow.
+
+**Arguments**:
+
+- `output_payload` (`Dict[str, Any]`): The output payload of the Controller.
+- `src_flow` (`Flow`): The source flow of the Controller.
+
+**Returns**:
+
+The input payload of the Executor.
+
+<a id="__init__"></a>
+
+# \_\_init\_\_
+

__init__.py

@@ -0,0 +1,11 @@
+dependencies = [
+    {"url": "aiflows/MemoryReadingFlowModule", "revision": "main"},
+    {"url": "aiflows/PlanWriterFlowModule", "revision":"main"},
+    {"url": "aiflows/MemoryReadingFlowModule", "revision":"main"},
+    {"url": "aiflows/MemoryWritingFlowModule", "revision":"main"},
+]
+from aiflows import flow_verse
+
+flow_verse.sync_dependencies(dependencies)
+from .AbstractBossFlow import AbstractBossFlow
+from .CtrlExMemFlow import CtrlExMemFlow

pip_requirements.txt

@@ -0,0 +1,15 @@
+colorama==0.4.6
+pytest==7.3.1
+pytest-cov==4.1.0
+hydra-core==1.3.2
+hydra-colorlog==1.1.0
+wrapt-timeout-decorator==1.3.12.2
+diskcache==5.6.1
+openai==1.0.0
+huggingface_hub==0.19.4
+jsonlines==3.1.0
+jinja2==3.1.2
+mock==5.0.2
+rich==12.6.0
+litellm==1.0.0
+aiflows