README + demo +piprequirements

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+.flow_cache/

LCToolFlow.py

@@ -9,6 +9,31 @@ from flows.base_flows import AtomicFlow
 
 
 class LCToolFlow(AtomicFlow):
+    r""" A flow that runs a tool using langchain. For example, a tool could be to excute a query with the duckduckgo search engine.
+    
+    *Configuration Parameters*:
+    
+    - `name` (str): The name of the flow. Default: "search"
+    - `description` (str): A description of the flow. This description is used to generate the help message of the flow.
+    Default: "useful when you need to look for the answer online, especially for recent events."
+    - `keep_raw_response` (bool): If True, the raw response of the tool is kept. Default: False
+    - `clear_flow_namespase_on_run_end` (bool): If True, the flow namespace is cleared at the end of the run. Default: False
+    - `backend` (Dict[str, Any]): The configuration of the backend. Default: langchain.tools.DuckDuckGoSearchRun
+    - Other parameters are inherited from the default configuration of AtomicFlow (see AtomicFlow)
+    
+    *Input Interface*:
+    
+    - `query` (str): the query to run the tool on
+        
+    *Output Interface*:
+    
+    - `observation` (str): the observation returned by the tool
+        
+    :param backend: The backend of the flow. It is a tool that is run by the flow. (e.g. duckduckgo search engine)
+    :type backend: BaseTool
+    :param \**kwargs: Additional arguments to pass to the flow. See :class:`flows.base_flows.AtomicFlow` for more details.
+    """
+    
     REQUIRED_KEYS_CONFIG = ["backend"]
 
     SUPPORTS_CACHING: bool = False
@@ -21,6 +46,12 @@ class LCToolFlow(AtomicFlow):
         
     @classmethod
     def _set_up_backend(cls, config: Dict[str, Any]) -> BaseTool:
+        """ This method sets up the backend of the flow.
+        
+        :param config: The configuration of the backend.
+        :type config: Dict[str, Any]
+        :return: The backend of the flow.
+        """
         if config["_target_"].startswith("."):
             # assumption: cls is associated with relative data_transformation_configs
             # for example, CF_Code and CF_Code.yaml should be in the same directory,
@@ -33,6 +64,13 @@ class LCToolFlow(AtomicFlow):
 
     @classmethod
     def instantiate_from_config(cls, config: Dict[str, Any]) -> LCToolFlow:
+        """ This method instantiates the flow from a configuration file
+        
+        :param config: The configuration of the flow.
+        :type config: Dict[str, Any]
+        :return: The instantiated flow.
+        :rtype: LCToolFlow
+        """
         flow_config = deepcopy(config)
 
         kwargs = {"flow_config": flow_config}
@@ -44,6 +82,13 @@ class LCToolFlow(AtomicFlow):
         return cls(**kwargs)
 
     def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """ This method runs the flow. It runs the backend on the input data.
+        
+        :param input_data: The input data of the flow.
+        :type input_data: Dict[str, Any]
+        :return: The output data of the flow.
+        :rtype: Dict[str, Any]
+        """
         observation = self.backend.run(tool_input=input_data)
 
         return {"observation": observation}

LCToolFlow.yaml

@@ -5,7 +5,7 @@ description: "useful when you need to look for the answer online, especially for
 # Input keys
 #######################################################
 
-input_keys:
+input_interface:
   - "query"
 
 
@@ -13,7 +13,7 @@ input_keys:
 # Output keys
 #######################################################
 
-output_keys:
+output_interface:
   - "observation"
 
 keep_raw_response: false

README.md

@@ -1,27 +1,81 @@
----
-license: mit
----
-ToDo
+# Table of Contents
 
-## Description
-ToDo: Add description
+* [LCToolFlow](#LCToolFlow)
+  * [LCToolFlow](#LCToolFlow.LCToolFlow)
+    * [instantiate\_from\_config](#LCToolFlow.LCToolFlow.instantiate_from_config)
+    * [run](#LCToolFlow.LCToolFlow.run)
 
-< Flow description >
+<a id="LCToolFlow"></a>
 
-## Configuration parameters
+# LCToolFlow
 
-&lt; Name 1 &gt; (&lt; Type 1 &gt;): &lt; Description 1 &gt;. Required parameter.
+<a id="LCToolFlow.LCToolFlow"></a>
 
-&lt; Name 2 &gt; (&lt; Type 2 &gt;): &lt; Description 2 &gt;. Default value is: &lt; value 2 &gt;
+## LCToolFlow Objects
 
-## Input interface
+```python
+class LCToolFlow(AtomicFlow)
+```
 
-&lt; Name 1 &gt; (&lt; Type 1 &gt;): &lt; Description 1 &gt;. 
+A flow that runs a tool using langchain. For example, a tool could be to excute a query with the duckduckgo search engine.
 
-(Note that the interface might depend on the state of the Flow.)
+*Configuration Parameters*:
 
-## Output interface
+- `name` (str): The name of the flow. Default: "search"
+- `description` (str): A description of the flow. This description is used to generate the help message of the flow.
+Default: "useful when you need to look for the answer online, especially for recent events."
+- `keep_raw_response` (bool): If True, the raw response of the tool is kept. Default: False
+- `clear_flow_namespase_on_run_end` (bool): If True, the flow namespace is cleared at the end of the run. Default: False
+- `backend` (Dict[str, Any]): The configuration of the backend. Default: langchain.tools.DuckDuckGoSearchRun
+- Other parameters are inherited from the default configuration of AtomicFlow (see AtomicFlow)
 
-&lt; Name 1 &gt; (&lt; Type 1 &gt;): &lt; Description 1 &gt;. 
+*Input Interface*:
+
+- `query` (str): the query to run the tool on
+
+*Output Interface*:
+
+- `observation` (str): the observation returned by the tool
+
+**Arguments**:
+
+- `backend` (`BaseTool`): The backend of the flow. It is a tool that is run by the flow. (e.g. duckduckgo search engine)
+- `\**kwargs`: Additional arguments to pass to the flow. See :class:`flows.base_flows.AtomicFlow` for more details.
+
+<a id="LCToolFlow.LCToolFlow.instantiate_from_config"></a>
+
+#### instantiate\_from\_config
+
+```python
+@classmethod
+def instantiate_from_config(cls, config: Dict[str, Any]) -> LCToolFlow
+```
+
+This method instantiates the flow from a configuration file
+
+**Arguments**:
+
+- `config` (`Dict[str, Any]`): The configuration of the flow.
+
+**Returns**:
+
+`LCToolFlow`: The instantiated flow.
+
+<a id="LCToolFlow.LCToolFlow.run"></a>
+
+#### run
+
+```python
+def run(input_data: Dict[str, Any]) -> Dict[str, Any]
+```
+
+This method runs the flow. It runs the backend on the input data.
+
+**Arguments**:
+
+- `input_data` (`Dict[str, Any]`): The input data of the flow.
+
+**Returns**:
+
+`Dict[str, Any]`: The output data of the flow.
 
-(Note that the interface might depend on the state of the Flow.)

demo.yaml

@@ -0,0 +1,4 @@
+flow:
+  _target_: aiflows.LCToolFlowModule.LCToolFlow.instantiate_from_default_config
+  name: "demoLCToolFlow"
+  description: "An example flow that uses the LCToolFlowModule."

pip_requirements.py

@@ -1 +0,0 @@
-# ToDo

pip_requirements.txt

@@ -0,0 +1,2 @@
+langchain==0.0.336
+duckduckgo-search==3.9.6

run.py

@@ -5,7 +5,7 @@ import os
 import hydra
 
 import flows
-from flows.flow_launchers import FlowLauncher, ApiInfo
+from flows.flow_launchers import FlowLauncher
 from flows.utils.general_helpers import read_yaml_file
 
 from flows import logging
@@ -16,19 +16,17 @@ CACHING_PARAMETERS.do_caching = False  # Set to True to enable caching
 
 logging.set_verbosity_debug()
 
+dependencies = [
+    {"url": "aiflows/LCToolFlowModule", "revision": os.getcwd()},
+]
+from flows import flow_verse
+flow_verse.sync_dependencies(dependencies)
 
 if __name__ == "__main__":
-    # ~~~ Set the API information ~~~
-    # OpenAI backend
-    # api_information = ApiInfo("openai", os.getenv("OPENAI_API_KEY"))
-    # Azure backend
-    api_information = ApiInfo("azure", os.getenv("AZURE_OPENAI_KEY"), os.getenv("AZURE_OPENAI_ENDPOINT"))
 
-    # ~~~ Instantiate the Flow ~~~
     root_dir = "."
-    cfg_path = os.path.join(root_dir, "FlowName.yaml")
+    cfg_path = os.path.join(root_dir, "demo.yaml")
     cfg = read_yaml_file(cfg_path)
-
     flow_with_interfaces = {
         "flow": hydra.utils.instantiate(cfg['flow'], _recursive_=False, _convert_="partial"),
         "input_interface": (
@@ -45,7 +43,7 @@ if __name__ == "__main__":
 
     # ~~~ Get the data ~~~
     # This can be a list of samples
-    data = {"id": 0}  # Add your data here
+    data = {"id": 0, "query": "Michael Jordan age"}  # Add your data here
 
     # ~~~ Run inference ~~~
     path_to_output_file = None
@@ -55,7 +53,6 @@ if __name__ == "__main__":
         flow_with_interfaces=flow_with_interfaces,
         data=data,
         path_to_output_file=path_to_output_file,
-        api_information=api_information,
     )
 
     # ~~~ Print the output ~~~