Upload 16 files

Controller_JarvisFlow.yaml

@@ -34,7 +34,7 @@ backend:
     azure: azure/gpt-4
 
 commands:
-  call_coder:
+  Coder:
     description: "Instruct the coder to write and run code to finish your given goal."
     input_args: [ "goal" ]
   re_plan:
@@ -77,7 +77,7 @@ system_message_prompt_template:
           0.1 Whenever the user demands to quit or terminate the current process, call `manual_finish` command.
           0.2 Whenever in doubt, or you have something to ask, or confirm to the user, call `ask_user` with your question.
           0.3 During the execution of the plan, if something goes wrong, call the `re_plan` with detailed information about what was wrong.
-          1. If the current step of plan can be achieved by writing and running code, call `call_coder` with the goal of the current step of plan.
+          1. If the current step of plan can be achieved by writing and running code, call `Coder` with the goal of the current step of plan.
           2. Whenever you have done one step of the plan, do the following:
             2.1 Reflect on what plan you are having right now.
             2.2 Reflect on which step of the plan you just finished.
@@ -98,11 +98,11 @@ system_message_prompt_template:
           ### Beginning of an example execution: ###
           Plan: 1. Download the weather data from Paris on 19. Dec. 2021. 2. Send the weather data to an email address. 3. Give a final answer.
           Your actions:
-          1. Call `call_coder` with the goal of the first step of the plan. Code is written and run, the weather data is downloaded.
+          1. Call `Coder` with the goal of the first step of the plan. Code is written and run, the weather data is downloaded.
           2. You call `update_plan` with the plan you just generated, it is exactly the same as the plan you have now, but with the current step of plan marked as done.
           3. You call `intermediate_answer` with the result of the step you just finished.
           4. The user is happy with the intermediate result, you proceed to the next step of the plan.
-          5. Call `call_coder` with the goal of the second step of the plan. Code is written and run, the weather data is sent to an email address.
+          5. Call `Coder` with the goal of the second step of the plan. Code is written and run, the weather data is sent to an email address.
           6. You call `update_plan` with the plan you just generated, it is exactly the same as the plan you have now, but with the current step of plan marked as done.
           7. You call `intermediate_answer` with the result of the step you just finished.
           8. The user is happy with the intermediate result, you proceed to the next step of the plan.

CtrlExMem_JarvisFlow.yaml

@@ -19,11 +19,12 @@ subflows_config:
   Executor:
     _target_: flows.base_flows.BranchingFlow.instantiate_from_default_config
     subflows_config:
-      call_coder:
+      Coder:
         _target_: Tachi67.CoderFlowModule.CoderFlow.instantiate_from_default_config
         memory_files: ???
         subflows_config:
           Planner:
+            #TODO remove this line
             _target_: Tachi67.CoderFlowModule.Planner_CoderFlow.instantiate_from_default_config
             subflows_config:
               Controller:

JarvisFlow.yaml

@@ -1,7 +1,7 @@
 name: JarvisFlow
 description: Jarvis, an agent with structured llms and tools able to process user requests, write and execute code, with external memory mechanisms.
 
-target_: Tachi67.JarvisFlowModule.JarvisFlow.instantiate_from_default_config
+_target_: Tachi67.JarvisFlowModule.JarvisFlow.instantiate_from_default_config
 
 memory_files: ???
 
@@ -43,24 +43,6 @@ subflows_config:
             azure: azure/gpt-4
       Executor:
         subflows_config:
-          re_plan:
-            subflows_config:
-              Controller:
-                backend:
-                  api_infos: ???
-                  model_name:
-                    openai: gpt-4
-                    azure: azure/gpt-4
-              Executor:
-                subflows_config:
-                  write_plan:
-                    subflows_config:
-                      PlanGenerator:
-                        backend:
-                          api_infos: ???
-                          model_name:
-                            openai: gpt-4
-                            azure: azure/gpt-4
           Coder:
             memory_files: ???
             subflows_config:
@@ -179,4 +161,22 @@ subflows_config:
                                       api_infos: ???
                                       model_name:
                                         openai: gpt-4
-                                        azure: azure/gpt-4
+                                        azure: azure/gpt-4
+          re_plan:
+            subflows_config:
+              Controller:
+                backend:
+                  api_infos: ???
+                  model_name:
+                    openai: gpt-4
+                    azure: azure/gpt-4
+              Executor:
+                subflows_config:
+                  write_plan:
+                    subflows_config:
+                      PlanGenerator:
+                        backend:
+                          api_infos: ???
+                          model_name:
+                            openai: gpt-4
+                            azure: azure/gpt-4

Planner_JarvisFlow.yaml

@@ -47,7 +47,7 @@ subflows_config:
                   2. Give a final answer.**
 
                 Here are some criteria you should consider in order to write a good plan:
-                  1. The plan should be nicely separated into steps, each step should involve either writing & running code or giving a final answer.
+                  1. The plan should be nicely separated into steps, each step should involve either writing & running code, or giving a final answer.
                   2. Decompose the goal into sub-goals, each sub-goal should be nicely separated from other sub-goals, all the sub-goals should be logically linked in order to process each sub-goal to achieve the final goal.
                 
                 Performance Evaluation:

run_Jarvis.py

@@ -0,0 +1,117 @@
+import os
+
+import hydra
+
+from flows.backends.api_info import ApiInfo
+from flows.messages import InputMessage
+from flows.utils.general_helpers import read_yaml_file
+from flows.utils.general_helpers import update_api_infos
+
+from flows import logging
+from flows.flow_cache import CACHING_PARAMETERS, clear_cache
+
+CACHING_PARAMETERS.do_caching = False  # Set to True in order to disable caching
+# clear_cache() # Uncomment this line to clear the cache
+
+logging.set_verbosity_debug()
+logging.auto_set_dir()
+
+dependencies = [
+    {"url": "aiflows/HumanStandardInputFlowModule", "revision": "5683a922372c5fa90be9f6447d6662d8d80341fc"},
+    {"url": "aiflows/ChatFlowModule", "revision": "a749ad10ed39776ba6721c37d0dc22af49ca0f17"},
+    {"url": "Tachi67/AbstractBossFlowModule", "revision": "main"},
+    {"url": "Tachi67/MemoryReadingFlowModule", "revision": "main"},
+    {"url": "Tachi67/PlanWriterFlowModule", "revision": "main"},
+    {"url": "Tachi67/ExtendLibraryFlowModule", "revision": "main"},
+    {"url": "Tachi67/RunCodeFlowModule", "revision": "main"},
+    {"url": "Tachi67/ReplanningFlowModule", "revision": "main"},
+    {"url": "Tachi67/CoderFlowModule", "revision": "main"},
+    {"url": "Tachi67/JarvisFlowModule", "revision": "main"},
+]
+
+from flows import flow_verse
+
+flow_verse.sync_dependencies(dependencies)
+
+def set_up_memfiles(cfg):
+    code_lib_file_loc = os.path.join(current_dir, "library.py")
+    jarvis_plan_file_loc = os.path.join(current_dir, "plan_jarvis.txt")
+    jarvis_logs_file_loc = os.path.join(current_dir, "logs_jarvis.txt")
+    coder_plan_file_loc = os.path.join(current_dir, "plan_coder.txt")
+    coder_logs_file_loc = os.path.join(current_dir, "logs_coder.txt")
+    extlib_plan_file_loc = os.path.join(current_dir, "plan_extlib.txt")
+    extlib_logs_file_loc = os.path.join(current_dir, "logs_extlib.txt")
+    with open(code_lib_file_loc, 'w') as file:
+        pass
+    with open(jarvis_plan_file_loc, 'w') as file:
+        pass
+    with open(jarvis_logs_file_loc, 'w') as file:
+        pass
+    with open(coder_plan_file_loc, 'w') as file:
+        pass
+    with open(coder_logs_file_loc, 'w') as file:
+        pass
+    with open(extlib_plan_file_loc, 'w') as file:
+        pass
+    with open(extlib_logs_file_loc, 'w') as file:
+        pass
+
+    memfiles_jarvis = {}
+    memfiles_coder = {}
+    memfiles_extlib = {}
+    memfiles_writecode_interactivecoder = {}
+    memfiles_writecode_test = {}
+    memfiles_jarvis["plan"] = jarvis_plan_file_loc
+    memfiles_jarvis["logs"] = jarvis_logs_file_loc
+    memfiles_coder["plan"] = coder_plan_file_loc
+    memfiles_coder["logs"] = coder_logs_file_loc
+    memfiles_coder["code_library"] = code_lib_file_loc
+    memfiles_extlib["plan"] = extlib_plan_file_loc
+    memfiles_extlib["logs"] = extlib_logs_file_loc
+    memfiles_extlib["code_library"] = code_lib_file_loc
+    memfiles_writecode_interactivecoder["code_library"] = code_lib_file_loc
+    memfiles_writecode_test["code_library"] = code_lib_file_loc
+    cfg["memory_files"] = memfiles_jarvis
+    cfg["subflows_config"]["CtrlExMem"]["subflows_config"]["Executor"]["subflows_config"]["Coder"]["memory_files"] = memfiles_coder
+    cfg["subflows_config"]["CtrlExMem"]["subflows_config"]["Executor"]["subflows_config"]["Coder"]["subflows_config"]["CtrlExMem"]["subflows_config"]["Executor"]["subflows_config"]["extend_library"]["memory_files"] = memfiles_extlib
+    cfg["subflows_config"]["CtrlExMem"]["subflows_config"]["Executor"]["subflows_config"]["Coder"]["subflows_config"]["CtrlExMem"]["subflows_config"]["Executor"]["subflows_config"]["extend_library"]["subflows_config"]["CtrlExMem"]["subflows_config"]["Executor"]["subflows_config"]["write_code"][
+        "subflows_config"]["Executor"]["subflows_config"]["write_code"][
+        "memory_files"] = memfiles_writecode_interactivecoder
+    cfg["subflows_config"]["CtrlExMem"]["subflows_config"]["Executor"]["subflows_config"]["Coder"]["subflows_config"]["CtrlExMem"]["subflows_config"]["Executor"]["subflows_config"]["extend_library"]["subflows_config"]["CtrlExMem"]["subflows_config"]["Executor"]["subflows_config"]["write_code"][
+        "subflows_config"]["Executor"]["subflows_config"]["test"]["memory_files"] = memfiles_writecode_test
+
+
+if __name__ == "__main__":
+    # ~~~ make sure to set the openai api key in the envs ~~~
+    key = os.getenv("OPENAI_API_KEY")
+    api_information = [ApiInfo(backend_used="openai", api_key=os.getenv("OPENAI_API_KEY"))]
+    path_to_output_file = None
+
+    current_dir = os.getcwd()
+    cfg_path = os.path.join(current_dir, "JarvisFlow.yaml")
+    cfg = read_yaml_file(cfg_path)
+
+    # ~~~ setting api information into config ~~~
+    update_api_infos(cfg, api_information)
+
+    # ~~~ setting memory files into config ~~~
+    set_up_memfiles(cfg)
+
+    # ~~~ instantiating the flow and input data ~~~
+    JarvisFlow = hydra.utils.instantiate(cfg, _recursive_=False, _convert_="partial")
+    input_data = {
+        #"goal": "define a calculator that supports addition and multiplication on complex numbers",
+        #"goal": "define a calculator that supports addition on complex numbers"
+        "goal": "fetch google's stock prices using yfinance for the last 6 months and print the first 10 entries"
+    }
+    input_message = InputMessage.build(
+        data_dict=input_data,
+        src_flow="Launcher",
+        dst_flow=JarvisFlow.name
+    )
+
+    # ~~~ calling the flow ~~~
+    output_message = JarvisFlow(input_message)
+
+    # ~~~ printing the output ~~~
+    print(output_message)