service-forge 0.1.0__py3-none-any.whl

service_forge/workflow/triggers/fast_api_trigger.py

@@ -0,0 +1,125 @@
+
+from __future__ import annotations
+from service_forge.workflow.trigger import Trigger
+from typing import AsyncIterator, Any
+from fastapi import FastAPI, Request
+import uuid
+import asyncio
+import json
+from service_forge.workflow.port import Port
+from service_forge.utils.default_type_converter import type_converter
+from service_forge.api.websocket_manager import websocket_manager
+from fastapi import HTTPException
+from google.protobuf.message import Message
+from google.protobuf.json_format import MessageToJson
+
+class FastAPITrigger(Trigger):
+    DEFAULT_INPUT_PORTS = [
+        Port("app", FastAPI),
+        Port("path", str),
+        Port("method", str),
+        Port("data_type", type),
+    ]
+
+    DEFAULT_OUTPUT_PORTS = [
+        Port("trigger", bool),
+        Port("user_id", int),
+        Port("data", Any),
+    ]
+
+    def __init__(self, name: str):
+        super().__init__(name)
+        self.events = {}
+        self.is_setup_route = False
+
+    @staticmethod
+    def serialize_result(result: Any):
+        if isinstance(result, Message):
+            return MessageToJson(
+                result,
+                preserving_proto_field_name=True
+            )
+        try:
+            return json.dumps(result)
+        except Exception:
+            return result
+
+    async def handle_request(
+        self,
+        request: Request,
+        data_type: type,
+        extract_data_fn: callable[[Request], dict]
+    ):
+        task_id = uuid.uuid4()
+        self.result_queues[task_id] = asyncio.Queue()
+
+        body_data = await extract_data_fn(request)
+        converted_data = data_type(**body_data)
+
+        client_id = (
+            body_data.get("client_id")
+            or request.query_params.get("client_id")
+            or request.headers.get("X-Client-ID")
+        )
+        if client_id:
+            workflow_name = getattr(self.workflow, "name", "Unknown")
+            steps = len(self.workflow.nodes) if hasattr(self.workflow, "nodes") else 1
+            websocket_manager.create_task_with_client(task_id, client_id, workflow_name, steps)
+
+        self.trigger_queue.put_nowait({
+            "id": task_id,
+            "user_id": getattr(request.state, "user_id", None),
+            "data": converted_data,
+        })
+
+        result = await self.result_queues[task_id].get()
+        del self.result_queues[task_id]
+
+        if isinstance(result, HTTPException):
+            raise result
+        if isinstance(result, Exception):
+            raise HTTPException(status_code=500, detail=str(result))
+
+        return self.serialize_result(result)
+
+    def _setup_route(self, app: FastAPI, path: str, method: str, data_type: type) -> None:
+        async def get_data(request: Request) -> dict:
+            return dict(request.query_params)
+
+        async def body_data(request: Request) -> dict:
+            raw = await request.body()
+            if not raw:
+                return {}
+            return json.loads(raw.decode("utf-8"))
+
+        extractor = get_data if method == "GET" else body_data
+
+        async def handler(request: Request):
+            return await self.handle_request(request, data_type, extractor)
+
+        if method == "GET":
+            app.get(path)(handler)
+        elif method == "POST":
+            app.post(path)(handler)
+        elif method == "PUT":
+            app.put(path)(handler)
+        elif method == "DELETE":
+            app.delete(path)(handler)
+        else:
+            raise ValueError(f"Invalid method {method}")
+
+    async def _run(self, app: FastAPI, path: str, method: str, data_type: type) -> AsyncIterator[bool]:
+        if not self.is_setup_route:
+            self._setup_route(app, path, method, data_type)
+            self.is_setup_route = True
+
+        while True:
+            try:
+                trigger = await self.trigger_queue.get()
+                self.prepare_output_edges(self.get_output_port_by_name('user_id'), trigger['user_id'])
+                self.prepare_output_edges(self.get_output_port_by_name('data'), trigger['data'])
+                yield self.trigger(trigger['id'])
+            except Exception as e:
+                from loguru import logger
+                logger.error(f"Error in FastAPITrigger._run: {e}")
+                continue

service_forge/workflow/triggers/kafka_api_trigger.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+import uuid
+from typing import Any
+from service_forge.workflow.trigger import Trigger
+from typing import AsyncIterator
+from service_forge.workflow.port import Port
+from service_forge.api.kafka_api import KafkaApp
+
+class KafkaAPITrigger(Trigger):
+    DEFAULT_INPUT_PORTS = [
+        Port("app", KafkaApp),
+        Port("topic", str),
+        Port("data_type", type),
+        Port("group_id", str),
+    ]
+
+    DEFAULT_OUTPUT_PORTS = [
+        Port("trigger", bool),
+        Port("data", Any),
+    ]
+    
+    def __init__(self, name: str):
+        super().__init__(name)
+        self.events = {}
+        self.is_setup_kafka_input = False
+
+    def _setup_kafka_input(self, app: KafkaApp, topic: str, data_type: type, group_id: str) -> None:
+        @app.kafka_input(topic, data_type, group_id)
+        async def handle_message(data):
+            task_id = uuid.uuid4()
+            self.trigger_queue.put_nowait({
+                "id": task_id,
+                "data": data,
+            })
+
+    async def _run(self, app: KafkaApp, topic: str, data_type: type, group_id: str) -> AsyncIterator[bool]:
+        if not self.is_setup_kafka_input:
+            self._setup_kafka_input(app, topic, data_type, group_id)
+            self.is_setup_kafka_input = True
+
+        while True:
+            trigger = await self.trigger_queue.get()
+            self.prepare_output_edges(self.get_output_port_by_name('data'), trigger['data'])
+            yield self.trigger(trigger['id'])

service_forge/workflow/triggers/once_trigger.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+from service_forge.workflow.node import Node
+from service_forge.workflow.port import Port
+from service_forge.workflow.trigger import Trigger
+from typing import AsyncIterator
+import uuid
+
+class OnceTrigger(Trigger):
+    DEFAULT_INPUT_PORTS = [
+    ]
+
+    DEFAULT_OUTPUT_PORTS = [
+        Port("trigger", bool),
+    ]
+
+    def __init__(self, name: str):
+        super().__init__(name)
+
+    async def _run(self) -> AsyncIterator[bool]:
+        yield self.trigger(uuid.uuid4())

service_forge/workflow/triggers/period_trigger.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+import asyncio
+from service_forge.workflow.node import Node
+from service_forge.workflow.port import Port
+from service_forge.workflow.trigger import Trigger
+from typing import AsyncIterator
+import uuid
+
+class PeriodTrigger(Trigger):
+    DEFAULT_INPUT_PORTS = [
+        Port("TRIGGER", bool),
+        Port("period", float),
+        Port("times", int),
+    ]
+
+    DEFAULT_OUTPUT_PORTS = [
+        Port("trigger", bool),
+    ]
+
+    def __init__(self, name: str):
+        super().__init__(name)
+
+    async def _run(self, times: int, period: float) -> AsyncIterator[bool]:
+        for _ in range(times):
+            await asyncio.sleep(period)
+            yield uuid.uuid4()

service_forge/workflow/workflow.py

@@ -0,0 +1,251 @@
+
+from __future__ import annotations
+import asyncio
+import uuid
+from typing import AsyncIterator, Awaitable, Callable, Any
+from loguru import logger
+from copy import deepcopy
+from .node import Node
+from .port import Port
+from .trigger import Trigger
+from .edge import Edge
+from ..db.database import DatabaseManager
+from ..api.websocket_manager import websocket_manager
+
+
+class Workflow:
+    def __init__(
+        self,
+        name: str,
+        nodes: list[Node],
+        input_ports: list[Port],
+        output_ports: list[Port],
+        _handle_stream_output: Callable[[str, AsyncIterator[str]], Awaitable[None]] = None,
+        _handle_query_user: Callable[[str, str], Awaitable[str]] = None,
+        database_manager: DatabaseManager = None,
+        max_concurrent_runs: int = 10,
+    ) -> None:
+        self.name = name
+        self.nodes = nodes
+        self.ready_nodes = []
+        self.input_ports = input_ports
+        self.output_ports = output_ports
+        self._handle_stream_output = _handle_stream_output
+        self._handle_query_user = _handle_query_user
+        self.after_trigger_workflow = None
+        self.result_port = Port("result", Any)
+        self.database_manager = database_manager
+        self.run_semaphore = asyncio.Semaphore(max_concurrent_runs)
+        self._validate()
+
+    def add_nodes(self, nodes: list[Node]) -> None:
+        for node in nodes:
+            node.workflow = self
+        self.nodes.extend(nodes)
+
+    def remove_nodes(self, nodes: list[Node]) -> None:
+        for node in nodes:
+            self.nodes.remove(node)
+
+    def load_config(self) -> None:
+        ...
+
+    def _validate(self) -> None:
+        # DAG
+        ...
+
+    def get_input_port_by_name(self, name: str) -> Port:
+        for input_port in self.input_ports:
+            if input_port.name == name:
+                return input_port
+        return None
+
+    def get_output_port_by_name(self, name: str) -> Port:
+        for output_port in self.output_ports:
+            if output_port.name == name:
+                return output_port
+        return None
+
+    async def run_after_trigger(self, task_id: uuid.UUID = None) -> Any:
+        trigger_nodes = [node for node in self.nodes if isinstance(node, Trigger)]
+        if not trigger_nodes:
+            raise ValueError("No trigger nodes found in workflow.")
+        self.ready_nodes = []
+        for edge in trigger_nodes[0].output_edges:
+            edge.end_port.trigger()
+
+        logger.info(f"Running workflow: {self.name}")
+        result = None
+        try:
+            for input_port in self.input_ports:
+                if input_port.value is not None:
+                    input_port.port.node.fill_input(input_port.port, input_port.value)
+
+            for node in self.nodes:
+                for key in node.AUTO_FILL_INPUT_PORTS:
+                    if key[0] not in [edge.end_port.name for edge in node.input_edges]:
+                        node.fill_input_by_name(key[0], key[1])
+
+            while self.ready_nodes:
+                tasks = []
+                nodes = self.ready_nodes.copy()
+                self.ready_nodes = []
+                for i, node in enumerate(nodes):
+                    # 发送节点开始执行的WebSocket通知
+                    if task_id:
+                        # 更新当前步骤
+                        websocket_manager.task_manager.update_current_step(task_id, i + 1)
+                        await websocket_manager.send_executing(task_id, node.name)
+
+                    result = node.run(task_id)
+
+                    if hasattr(result, '__anext__'):
+                        # 处理流输出
+                        if self._handle_stream_output is None:
+                            tasks.append(self.handle_stream_output(node.name, result))
+                        else:
+                            tasks.append(self._handle_stream_output(node.name, result))
+                    elif asyncio.iscoroutine(result):
+                        tasks.append(result)
+
+                    # 发送每个输出端口的结果
+                    if task_id:
+                        for output_port in node.output_ports:
+                            if output_port.is_prepared:
+                                await websocket_manager.send_node_output(task_id, node.name, output_port.name, output_port.value)
+                
+                if tasks:
+                    results = await asyncio.gather(*tasks)
+                    # 更新result为最后一个非None的结果
+                    for res in results:
+                        if res is not None:
+                            result = res
+
+                    # 在所有任务完成后，再次发送每个输出端口的结果
+                    if task_id:
+                        for node in nodes:
+                            for output_port in node.output_ports:
+                                if output_port.is_prepared:
+                                    await websocket_manager.send_node_output(task_id, node.name, output_port.name, output_port.value)
+
+        except Exception as e:
+            import traceback
+            error_msg = f"Error in run_after_trigger: {str(e)}"
+            logger.error(error_msg)
+            logger.error(traceback.format_exc())
+            # 发送执行错误的WebSocket通知
+            if task_id:
+                # 更新任务状态为失败
+                websocket_manager.task_manager.fail_task(task_id, error_msg)
+                await websocket_manager.send_execution_error(task_id, "workflow", error_msg)
+            raise e
+
+        # 发送工作流执行完成的WebSocket通知
+        if task_id:
+            # 更新任务状态为已完成
+            websocket_manager.task_manager.complete_task(task_id)
+            await websocket_manager.send_executed(task_id, "workflow", result)
+
+        if len(self.output_ports) > 0 and self.output_ports[0].is_prepared:
+            return self.output_ports[0].value
+
+    async def _run(self, uuid: uuid.UUID, trigger_node: Trigger) -> None:
+        async with self.run_semaphore:
+            try:
+                # 发送任务开始执行的WebSocket通知
+                await websocket_manager.send_execution_start(uuid)
+
+                new_workflow = self._clone()
+                result = await new_workflow.run_after_trigger(uuid)
+                if uuid in trigger_node.result_queues:
+                    trigger_node.result_queues[uuid].put_nowait(result)
+
+            except Exception as e:
+                import traceback
+                error_msg = f"Error running workflow: {str(e)}, {traceback.format_exc()}"
+                logger.error(error_msg)
+                # 发送执行错误的WebSocket通知
+                # 更新任务状态为失败
+                websocket_manager.task_manager.fail_task(uuid, error_msg)
+                await websocket_manager.send_execution_error(uuid, "workflow", error_msg)
+                if uuid in trigger_node.result_queues:
+                    trigger_node.result_queues[uuid].put_nowait(e)
+
+    async def run(self):
+        trigger_nodes = [node for node in self.nodes if isinstance(node, Trigger)]
+
+        if len(trigger_nodes) == 0:
+            raise ValueError("No trigger nodes found in workflow.")
+        if len(trigger_nodes) > 1:
+            raise ValueError("Multiple trigger nodes found in workflow.")
+
+        trigger_node = trigger_nodes[0]
+        async for uuid in trigger_node.run():
+            asyncio.create_task(self._run(uuid, trigger_node))
+
+    async def handle_stream_output(self, node_name: str, stream: AsyncIterator[str]) -> None:
+        logger.info(f"[{node_name}] Starting stream output:")
+        buffer = []
+        async for char in stream:
+            buffer.append(char)
+            logger.info(f"[{node_name}] Received char: '{char}'")
+
+        complete_message = ''.join(buffer)
+        logger.info(f"[{node_name}] Complete message: '{complete_message}'")
+
+    async def handle_query_user(self, node_name: str, prompt: str) -> Awaitable[str]:
+        return await asyncio.to_thread(input, f"[{node_name}] {prompt}: ")
+
+    def _clone(self) -> Workflow:
+        node_map: dict[Node, Node] = {node: node._simple_clone() for node in self.nodes}
+
+        port_map: dict[Port, Port] = {}
+        port_map.update({port: port._simple_clone(node_map) for port in self.input_ports})
+        port_map.update({port: port._simple_clone(node_map) for port in self.output_ports})
+        for node in self.nodes:
+            for port in node.input_ports:
+                if port not in port_map:
+                    port_map[port] = port._simple_clone(node_map)
+            for port in node.output_ports:
+                if port not in port_map:
+                    port_map[port] = port._simple_clone(node_map)
+
+        edge_map: dict[Edge, Edge] = {}
+        for node in self.nodes:
+            for edge in node.input_edges:
+                if edge not in edge_map:
+                    edge_map[edge] = edge._simple_clone(node_map, port_map)
+            for edge in node.output_edges:
+                if edge not in edge_map:
+                    edge_map[edge] = edge._simple_clone(node_map, port_map)
+
+        # fill port.port
+        for old_port, new_port in port_map.items():
+            if old_port.port is not None:
+                new_port.port = port_map[old_port.port]
+
+
+        # fill ports and edges in nodes
+        for old_node, new_node in node_map.items():
+            new_node.input_edges = [edge_map[edge] for edge in old_node.input_edges]
+            new_node.output_edges = [edge_map[edge] for edge in old_node.output_edges]
+            new_node.input_ports = [port_map[port] for port in old_node.input_ports]
+            new_node.output_ports = [port_map[port] for port in old_node.output_ports]
+            new_node.input_variables = {
+                port_map[port]: value for port, value in old_node.input_variables.items()
+            }
+
+        workflow = Workflow(
+            name=self.name,
+            nodes=[node_map[node] for node in self.nodes],
+            input_ports=[port_map[port] for port in self.input_ports],
+            output_ports=[port_map[port] for port in self.output_ports],
+            _handle_stream_output=self._handle_stream_output,
+            _handle_query_user=self._handle_query_user,
+            database_manager=self.database_manager,
+        )
+
+        for node in workflow.nodes:
+            node.workflow = workflow
+
+        return workflow

service_forge/workflow/workflow_factory.py

@@ -0,0 +1,227 @@
+from omegaconf import OmegaConf
+from typing import Callable, Awaitable, AsyncIterator, Any
+from copy import deepcopy
+from .workflow import Workflow
+from .workflow_group import WorkflowGroup
+from .node import Node
+from .edge import Edge
+from .port import Port, parse_port_name, create_workflow_input_port, create_sub_workflow_input_port, create_port
+from .node import node_register
+from .nodes import *
+from .triggers import *
+from .context import Context
+from ..db.database import DatabaseManager
+
+WORKFLOW_KEY_NAME = 'name'
+WORKFLOW_KEY_NODES = 'nodes'
+WORKFLOW_KEY_INPUTS = 'inputs'
+WORKFLOW_KEY_OUTPUTS = 'outputs'
+
+NODE_KEY_NAME = 'name'
+NODE_KEY_TYPE = 'type'
+NODE_KEY_ARGS = 'args'
+NODE_KEY_OUTPUTS = 'outputs'
+NODE_KEY_INPUT_PORTS = 'input_ports'
+NODE_KEY_OUTPUT_PORTS = 'output_ports'
+NODE_KEY_SUB_WORKFLOWS = 'sub_workflows'
+NODE_KEY_SUB_WORKFLOWS_INPUT_PORTS = 'sub_workflows_input_ports'
+
+PORT_KEY_NAME = 'name'
+PORT_KEY_PORT = 'port'
+PORT_KEY_VALUE = 'value'
+
+def parse_argument(arg: Any, service_env: dict[str, Any] = None) -> Any:
+    if type(arg) == str and arg.startswith(f'<{{') and arg.endswith(f'}}>'):
+        key = arg[2:-2]
+        if key not in service_env:
+            raise ValueError(f"Key {key} not found in service env.")
+        return service_env[key]
+    return arg
+
+def create_workflow(
+    config_path: str = None,
+    service_env: dict[str, Any] = None,
+    config: dict = None,
+    workflows: WorkflowGroup = None,
+    _handle_stream_output: Callable[[str, AsyncIterator[str]], Awaitable[None]] | None = None,
+    _handle_query_user: Callable[[str, str], Awaitable[str]] | None = None,
+    database_manager: DatabaseManager = None,
+) -> Workflow:
+    if config is None:
+        config = OmegaConf.to_object(OmegaConf.load(config_path))
+
+    if WORKFLOW_KEY_NAME not in config:
+        if config_path is None:
+            raise ValueError(f"{WORKFLOW_KEY_NAME} is required in workflow config in {config}.")
+        else:
+            raise ValueError(f"{WORKFLOW_KEY_NAME} is required in workflow config at {config_path}.")
+
+    workflow = Workflow(
+        name = config[WORKFLOW_KEY_NAME],
+        nodes = [],
+        input_ports = [],
+        output_ports = [],
+        _handle_stream_output = _handle_stream_output,
+        _handle_query_user = _handle_query_user,
+        database_manager = database_manager,
+    )
+
+    nodes: dict[str, Node] = {}
+
+    # Nodes
+    for node_config in config[WORKFLOW_KEY_NODES]:
+        params = {
+            "name": node_config[NODE_KEY_NAME],
+        }
+        
+        node: Node = node_register.instance(node_config[NODE_KEY_TYPE], ignore_keys=['type'], kwargs=params)
+
+        # Context
+        node.context = Context(variables = {})
+
+        # Input ports
+        if node_key_input_ports := node_config.get(NODE_KEY_INPUT_PORTS, None):
+            node.input_ports = [Port(**port_params) for port_params in node_key_input_ports]
+        else:
+            node.input_ports = deepcopy(node.DEFAULT_INPUT_PORTS)
+        
+        for input_port in node.input_ports:
+            input_port.node = node
+
+        # Output ports
+        if node_key_output_ports := node_config.get(NODE_KEY_OUTPUT_PORTS, None):
+            node.output_ports = [Port(**port_params) for port_params in node_key_output_ports]
+        else:
+            node.output_ports = deepcopy(node.DEFAULT_OUTPUT_PORTS)
+
+        for output_port in node.output_ports:
+            output_port.node = node
+        
+        # Sub workflows
+        if node_key_sub_workflows := node_config.get(NODE_KEY_SUB_WORKFLOWS, None):
+            sub_workflows: WorkflowGroup = WorkflowGroup(workflows=[])
+            for sub_workflow_config in node_key_sub_workflows:
+                sub_workflow = workflows.get_workflow(sub_workflow_config['name'])
+                sub_workflows.add_workflow(deepcopy(sub_workflow))
+            node.sub_workflows = sub_workflows
+
+        # Sub workflows input ports
+        if node_key_sub_network_input_ports := node_config.get(NODE_KEY_SUB_WORKFLOWS_INPUT_PORTS, None):
+            for sub_workflow_input_port_config in node_key_sub_network_input_ports:
+                name = sub_workflow_input_port_config[PORT_KEY_NAME]
+                sub_workflow_name, sub_workflow_port_name = parse_port_name(sub_workflow_input_port_config[PORT_KEY_PORT])
+                sub_workflow = node.sub_workflows.get_workflow(sub_workflow_name)
+                if sub_workflow is None:
+                    raise ValueError(f"{sub_workflow_name} is not a valid sub workflow.")
+                sub_workflow_port = sub_workflow.get_input_port_by_name(sub_workflow_port_name)
+                if sub_workflow_port is None:
+                    raise ValueError(f"{sub_workflow_port_name} is not a valid input port.")
+                value = sub_workflow_input_port_config.get(PORT_KEY_VALUE, None)
+                node.input_ports.append(create_sub_workflow_input_port(name=name, node=node, port=sub_workflow_port, value=value))
+
+        # Sub workflows output ports
+        ...
+
+        # Hooks
+        if _handle_query_user is None:
+            node.query_user = workflow.handle_query_user
+        else:
+            node.query_user = _handle_query_user
+
+        nodes[node_config[NODE_KEY_NAME]] = node
+
+    # Edges
+    for node_config in config[WORKFLOW_KEY_NODES]:
+        start_node = nodes[node_config[NODE_KEY_NAME]]
+        if NODE_KEY_OUTPUTS in node_config and node_config[NODE_KEY_OUTPUTS]:
+            for key, value in node_config[NODE_KEY_OUTPUTS].items():
+                if value is None:
+                    continue
+
+                if type(value) is str:
+                    value = [value]
+
+                for edge_value in value:
+                    end_node_name, end_port_name = parse_port_name(edge_value)
+                    end_node = nodes[end_node_name]
+
+                    start_port = start_node.get_output_port_by_name(key)
+                    end_port = end_node.get_input_port_by_name(end_port_name)
+
+                    if start_port is None:
+                        raise ValueError(f"{key} is not a valid output port.")
+                    if end_port is None:
+                        raise ValueError(f"{end_port_name} is not a valid input port.")
+
+                    edge = Edge(start_node, end_node, start_port, end_port)
+
+                    start_node.output_edges.append(edge)
+                    end_node.input_edges.append(edge)
+
+    workflow.add_nodes(list(nodes.values()))
+    
+    # Inputs
+    if workflow_key_inputs := config.get(WORKFLOW_KEY_INPUTS, None):
+        for port_config in workflow_key_inputs:
+            name = port_config[PORT_KEY_NAME]
+            node_name, node_port_name = parse_port_name(port_config[PORT_KEY_PORT])
+            if node_name not in nodes:
+                raise ValueError(f"{node_name} is not a valid node.")
+            node = nodes[node_name]
+            port = node.get_input_port_by_name(node_port_name)
+            if port is None:
+                raise ValueError(f"{node_port_name} is not a valid input port.")
+            value = port_config.get(PORT_KEY_VALUE, None)
+            workflow.input_ports.append(create_workflow_input_port(name=name, port=port, value=value))
+
+    # Outputs
+    if workflow_key_outputs := config.get(WORKFLOW_KEY_OUTPUTS, None):
+        for port_config in workflow_key_outputs:
+            name = port_config[PORT_KEY_NAME]
+            node_name, node_port_name = parse_port_name(port_config[PORT_KEY_PORT])
+            if node_name not in nodes:
+                raise ValueError(f"{node_name} is not a valid node.")
+            node = nodes[node_name]
+            port = node.get_output_port_by_name(node_port_name)
+            if port is None:
+                raise ValueError(f"{node_port_name} is not a valid output port.")
+            output_port = create_port(name=name, type=Any)
+            workflow.output_ports.append(output_port)
+            edge = Edge(node, None, port, output_port)
+            node.output_edges.append(edge)
+
+    for node_config in config[WORKFLOW_KEY_NODES]:
+        node = nodes[node_config[NODE_KEY_NAME]]
+        # Arguments
+        if node_key_args := node_config.get(NODE_KEY_ARGS, None):
+            for key, value in node_key_args.items():
+                node.fill_input_by_name(key, parse_argument(value, service_env=service_env))
+
+    return workflow
+
+def create_workflows(
+    config_path: str,
+    service_env: dict[str, Any] = None,
+    _handle_stream_output: Callable[[str, AsyncIterator[str]], Awaitable[None]] = None,
+    _handle_query_user: Callable[[str, str], Awaitable[str]] = None,
+    database_manager: DatabaseManager = None,
+) -> WorkflowGroup:
+    WORKFLOW_KEY_WORKFLOWS = 'workflows'
+    WORKFLOW_KEY_MAIN_WORKFLOW_NAME = 'main'
+
+    config = OmegaConf.to_object(OmegaConf.load(config_path))
+
+    if WORKFLOW_KEY_WORKFLOWS not in config:
+        workflow = create_workflow(
+            config_path,
+            service_env=service_env,
+            _handle_stream_output=_handle_stream_output,
+            _handle_query_user=_handle_query_user,
+            database_manager=database_manager,
+        )
+        return WorkflowGroup(workflows=[workflow], main_workflow_name=workflow.name)
+
+    workflows = WorkflowGroup(workflows=[], main_workflow_name=config.get(WORKFLOW_KEY_MAIN_WORKFLOW_NAME, None))
+    for workflow_config in config[WORKFLOW_KEY_WORKFLOWS]:
+        workflows.add_workflow(create_workflow(config = workflow_config, workflows=workflows, _handle_stream_output=_handle_stream_output, _handle_query_user=_handle_query_user))
+    return workflows