将flask改成fastapi

agent/__init__.py

@@ -0,0 +1,18 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+from beartype.claw import beartype_this_package
+beartype_this_package()

agent/canvas.py

@@ -0,0 +1,515 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import base64
+import json
+import logging
+import re
+import time
+from concurrent.futures import ThreadPoolExecutor
+from copy import deepcopy
+from functools import partial
+from typing import Any, Union, Tuple
+
+from agent.component import component_class
+from agent.component.base import ComponentBase
+from api.db.services.file_service import FileService
+from api.utils import get_uuid, hash_str2int
+from rag.prompts.generator import chunks_format
+from rag.utils.redis_conn import REDIS_CONN
+
+class Graph:
+    """
+        dsl = {
+            "components": {
+                "begin": {
+                    "obj":{
+                        "component_name": "Begin",
+                        "params": {},
+                    },
+                    "downstream": ["answer_0"],
+                    "upstream": [],
+                },
+                "retrieval_0": {
+                    "obj": {
+                        "component_name": "Retrieval",
+                        "params": {}
+                    },
+                    "downstream": ["generate_0"],
+                    "upstream": ["answer_0"],
+                },
+                "generate_0": {
+                    "obj": {
+                        "component_name": "Generate",
+                        "params": {}
+                    },
+                    "downstream": ["answer_0"],
+                    "upstream": ["retrieval_0"],
+                }
+            },
+            "history": [],
+            "path": ["begin"],
+            "retrieval": {"chunks": [], "doc_aggs": []},
+            "globals": {
+                "sys.query": "",
+                "sys.user_id": tenant_id,
+                "sys.conversation_turns": 0,
+                "sys.files": []
+            }
+        }
+        """
+
+    def __init__(self, dsl: str, tenant_id=None, task_id=None):
+        self.path = []
+        self.components = {}
+        self.error = ""
+        self.dsl = json.loads(dsl)
+        self._tenant_id = tenant_id
+        self.task_id = task_id if task_id else get_uuid()
+        self.load()
+
+    def load(self):
+        self.components = self.dsl["components"]
+        cpn_nms = set([])
+        for k, cpn in self.components.items():
+            cpn_nms.add(cpn["obj"]["component_name"])
+
+        for k, cpn in self.components.items():
+            cpn_nms.add(cpn["obj"]["component_name"])
+            param = component_class(cpn["obj"]["component_name"] + "Param")()
+            param.update(cpn["obj"]["params"])
+            try:
+                param.check()
+            except Exception as e:
+                raise ValueError(self.get_component_name(k) + f": {e}")
+
+            cpn["obj"] = component_class(cpn["obj"]["component_name"])(self, k, param)
+
+        self.path = self.dsl["path"]
+
+    def __str__(self):
+        self.dsl["path"] = self.path
+        self.dsl["task_id"] = self.task_id
+        dsl = {
+            "components": {}
+        }
+        for k in self.dsl.keys():
+            if k in ["components"]:
+                continue
+            dsl[k] = deepcopy(self.dsl[k])
+
+        for k, cpn in self.components.items():
+            if k not in dsl["components"]:
+                dsl["components"][k] = {}
+            for c in cpn.keys():
+                if c == "obj":
+                    dsl["components"][k][c] = json.loads(str(cpn["obj"]))
+                    continue
+                dsl["components"][k][c] = deepcopy(cpn[c])
+        return json.dumps(dsl, ensure_ascii=False)
+
+    def reset(self):
+        self.path = []
+        for k, cpn in self.components.items():
+            self.components[k]["obj"].reset()
+        try:
+            REDIS_CONN.delete(f"{self.task_id}-logs")
+        except Exception as e:
+            logging.exception(e)
+
+    def get_component_name(self, cid):
+        for n in self.dsl.get("graph", {}).get("nodes", []):
+            if cid == n["id"]:
+                return n["data"]["name"]
+        return ""
+
+    def run(self, **kwargs):
+        raise NotImplementedError()
+
+    def get_component(self, cpn_id) -> Union[None, dict[str, Any]]:
+        return self.components.get(cpn_id)
+
+    def get_component_obj(self, cpn_id) -> ComponentBase:
+        return self.components.get(cpn_id)["obj"]
+
+    def get_component_type(self, cpn_id) -> str:
+        return self.components.get(cpn_id)["obj"].component_name
+
+    def get_component_input_form(self, cpn_id) -> dict:
+        return self.components.get(cpn_id)["obj"].get_input_form()
+
+    def get_tenant_id(self):
+        return self._tenant_id
+
+    def get_variable_value(self, exp: str) -> Any:
+        exp = exp.strip("{").strip("}").strip(" ").strip("{").strip("}")
+        if exp.find("@") < 0:
+            return self.globals[exp]
+        cpn_id, var_nm = exp.split("@")
+        cpn = self.get_component(cpn_id)
+        if not cpn:
+            raise Exception(f"Can't find variable: '{cpn_id}@{var_nm}'")
+        return cpn["obj"].output(var_nm)
+
+
+class Canvas(Graph):
+
+    def __init__(self, dsl: str, tenant_id=None, task_id=None):
+        self.globals = {
+            "sys.query": "",
+            "sys.user_id": tenant_id,
+            "sys.conversation_turns": 0,
+            "sys.files": []
+        }
+        super().__init__(dsl, tenant_id, task_id)
+
+    def load(self):
+        super().load()
+        self.history = self.dsl["history"]
+        if "globals" in self.dsl:
+            self.globals = self.dsl["globals"]
+        else:
+            self.globals = {
+            "sys.query": "",
+            "sys.user_id": "",
+            "sys.conversation_turns": 0,
+            "sys.files": []
+        }
+            
+        self.retrieval = self.dsl["retrieval"]
+        self.memory = self.dsl.get("memory", [])
+
+    def __str__(self):
+        self.dsl["history"] = self.history
+        self.dsl["retrieval"] = self.retrieval
+        self.dsl["memory"] = self.memory
+        return super().__str__()
+
+    def reset(self, mem=False):
+        super().reset()
+        if not mem:
+            self.history = []
+            self.retrieval = []
+            self.memory = []
+
+        for k in self.globals.keys():
+            if isinstance(self.globals[k], str):
+                self.globals[k] = ""
+            elif isinstance(self.globals[k], int):
+                self.globals[k] = 0
+            elif isinstance(self.globals[k], float):
+                self.globals[k] = 0
+            elif isinstance(self.globals[k], list):
+                self.globals[k] = []
+            elif isinstance(self.globals[k], dict):
+                self.globals[k] = {}
+            else:
+                self.globals[k] = None
+
+    def run(self, **kwargs):
+        st = time.perf_counter()
+        self.message_id = get_uuid()
+        created_at = int(time.time())
+        self.add_user_input(kwargs.get("query"))
+        for k, cpn in self.components.items():
+            self.components[k]["obj"].reset(True)
+
+        for k in kwargs.keys():
+            if k in ["query", "user_id", "files"] and kwargs[k]:
+                if k == "files":
+                    self.globals[f"sys.{k}"] = self.get_files(kwargs[k])
+                else:
+                    self.globals[f"sys.{k}"] = kwargs[k]
+        if not self.globals["sys.conversation_turns"] :
+            self.globals["sys.conversation_turns"] = 0
+        self.globals["sys.conversation_turns"] += 1
+
+        def decorate(event, dt):
+            nonlocal created_at
+            return {
+                "event": event,
+                #"conversation_id": "f3cc152b-24b0-4258-a1a1-7d5e9fc8a115",
+                "message_id": self.message_id,
+                "created_at": created_at,
+                "task_id": self.task_id,
+                "data": dt
+            }
+
+        if not self.path or self.path[-1].lower().find("userfillup") < 0:
+            self.path.append("begin")
+            self.retrieval.append({"chunks": [], "doc_aggs": []})
+
+        yield decorate("workflow_started", {"inputs": kwargs.get("inputs")})
+        self.retrieval.append({"chunks": {}, "doc_aggs": {}})
+
+        def _run_batch(f, t):
+            with ThreadPoolExecutor(max_workers=5) as executor:
+                thr = []
+                for i in range(f, t):
+                    cpn = self.get_component_obj(self.path[i])
+                    if cpn.component_name.lower() in ["begin", "userfillup"]:
+                        thr.append(executor.submit(cpn.invoke, inputs=kwargs.get("inputs", {})))
+                    else:
+                        thr.append(executor.submit(cpn.invoke, **cpn.get_input()))
+                for t in thr:
+                    t.result()
+
+        def _node_finished(cpn_obj):
+            return decorate("node_finished",{
+                           "inputs": cpn_obj.get_input_values(),
+                           "outputs": cpn_obj.output(),
+                           "component_id": cpn_obj._id,
+                           "component_name": self.get_component_name(cpn_obj._id),
+                           "component_type": self.get_component_type(cpn_obj._id),
+                           "error": cpn_obj.error(),
+                           "elapsed_time": time.perf_counter() - cpn_obj.output("_created_time"),
+                           "created_at": cpn_obj.output("_created_time"),
+                       })
+
+        self.error = ""
+        idx = len(self.path) - 1
+        partials = []
+        while idx < len(self.path):
+            to = len(self.path)
+            for i in range(idx, to):
+                yield decorate("node_started", {
+                    "inputs": None, "created_at": int(time.time()),
+                    "component_id": self.path[i],
+                    "component_name": self.get_component_name(self.path[i]),
+                    "component_type": self.get_component_type(self.path[i]),
+                    "thoughts": self.get_component_thoughts(self.path[i])
+                })
+            _run_batch(idx, to)
+
+            # post processing of components invocation
+            for i in range(idx, to):
+                cpn = self.get_component(self.path[i])
+                cpn_obj = self.get_component_obj(self.path[i])
+                if cpn_obj.component_name.lower() == "message":
+                    if isinstance(cpn_obj.output("content"), partial):
+                        _m = ""
+                        for m in cpn_obj.output("content")():
+                            if not m:
+                                continue
+                            if m == "<think>":
+                                yield decorate("message", {"content": "", "start_to_think": True})
+                            elif m == "</think>":
+                                yield decorate("message", {"content": "", "end_to_think": True})
+                            else:
+                                yield decorate("message", {"content": m})
+                                _m += m
+                        cpn_obj.set_output("content", _m)
+                        cite = re.search(r"\[ID:[ 0-9]+\]", _m)
+                    else:
+                        yield decorate("message", {"content": cpn_obj.output("content")})
+                        cite = re.search(r"\[ID:[ 0-9]+\]",  cpn_obj.output("content"))
+                    yield decorate("message_end", {"reference": self.get_reference() if cite else None})
+
+                    while partials:
+                        _cpn_obj = self.get_component_obj(partials[0])
+                        if isinstance(_cpn_obj.output("content"), partial):
+                            break
+                        yield _node_finished(_cpn_obj)
+                        partials.pop(0)
+
+                other_branch = False
+                if cpn_obj.error():
+                    ex = cpn_obj.exception_handler()
+                    if ex and ex["goto"]:
+                        self.path.extend(ex["goto"])
+                        other_branch = True
+                    elif ex and ex["default_value"]:
+                        yield decorate("message", {"content": ex["default_value"]})
+                        yield decorate("message_end", {})
+                    else:
+                        self.error = cpn_obj.error()
+
+                if cpn_obj.component_name.lower() != "iteration":
+                    if isinstance(cpn_obj.output("content"), partial):
+                        if self.error:
+                            cpn_obj.set_output("content", None)
+                            yield _node_finished(cpn_obj)
+                        else:
+                            partials.append(self.path[i])
+                    else:
+                        yield _node_finished(cpn_obj)
+
+                def _append_path(cpn_id):
+                    nonlocal other_branch
+                    if other_branch:
+                        return
+                    if self.path[-1] == cpn_id:
+                        return
+                    self.path.append(cpn_id)
+
+                def _extend_path(cpn_ids):
+                    nonlocal other_branch
+                    if other_branch:
+                        return
+                    for cpn_id in cpn_ids:
+                        _append_path(cpn_id)
+
+                if cpn_obj.component_name.lower() == "iterationitem" and cpn_obj.end():
+                    iter = cpn_obj.get_parent()
+                    yield _node_finished(iter)
+                    _extend_path(self.get_component(cpn["parent_id"])["downstream"])
+                elif cpn_obj.component_name.lower() in ["categorize", "switch"]:
+                    _extend_path(cpn_obj.output("_next"))
+                elif cpn_obj.component_name.lower() == "iteration":
+                    _append_path(cpn_obj.get_start())
+                elif not cpn["downstream"] and cpn_obj.get_parent():
+                    _append_path(cpn_obj.get_parent().get_start())
+                else:
+                    _extend_path(cpn["downstream"])
+
+            if self.error:
+                logging.error(f"Runtime Error: {self.error}")
+                break
+            idx = to
+
+            if any([self.get_component_obj(c).component_name.lower() == "userfillup" for c in self.path[idx:]]):
+                path = [c for c in self.path[idx:] if self.get_component(c)["obj"].component_name.lower() == "userfillup"]
+                path.extend([c for c in self.path[idx:] if self.get_component(c)["obj"].component_name.lower() != "userfillup"])
+                another_inputs = {}
+                tips = ""
+                for c in path:
+                    o = self.get_component_obj(c)
+                    if o.component_name.lower() == "userfillup":
+                        another_inputs.update(o.get_input_elements())
+                        if o.get_param("enable_tips"):
+                            tips = o.get_param("tips")
+                self.path = path
+                yield decorate("user_inputs", {"inputs": another_inputs, "tips": tips})
+                return
+
+        self.path = self.path[:idx]
+        if not self.error:
+            yield decorate("workflow_finished",
+                       {
+                           "inputs": kwargs.get("inputs"),
+                           "outputs": self.get_component_obj(self.path[-1]).output(),
+                           "elapsed_time": time.perf_counter() - st,
+                           "created_at": st,
+                       })
+            self.history.append(("assistant", self.get_component_obj(self.path[-1]).output()))
+
+    def is_reff(self, exp: str) -> bool:
+        exp = exp.strip("{").strip("}")
+        if exp.find("@") < 0:
+            return exp in self.globals
+        arr = exp.split("@")
+        if len(arr) != 2:
+            return False
+        if self.get_component(arr[0]) is None:
+            return False
+        return True
+
+    def get_history(self, window_size):
+        convs = []
+        if window_size <= 0:
+            return convs
+        for role, obj in self.history[window_size * -2:]:
+            if isinstance(obj, dict):
+                convs.append({"role": role, "content": obj.get("content", "")})
+            else:
+                convs.append({"role": role, "content": str(obj)})
+        return convs
+
+    def add_user_input(self, question):
+        self.history.append(("user", question))
+
+    def get_prologue(self):
+        return self.components["begin"]["obj"]._param.prologue
+
+    def get_mode(self):
+        return self.components["begin"]["obj"]._param.mode
+
+    def set_global_param(self, **kwargs):
+        self.globals.update(kwargs)
+
+    def get_preset_param(self):
+        return self.components["begin"]["obj"]._param.inputs
+
+    def get_component_input_elements(self, cpnnm):
+        return self.components[cpnnm]["obj"].get_input_elements()
+
+    def get_files(self, files: Union[None, list[dict]]) -> list[str]:
+        if not files:
+            return  []
+        def image_to_base64(file):
+            return "data:{};base64,{}".format(file["mime_type"],
+                                        base64.b64encode(FileService.get_blob(file["created_by"], file["id"])).decode("utf-8"))
+        exe = ThreadPoolExecutor(max_workers=5)
+        threads = []
+        for file in files:
+            if file["mime_type"].find("image") >=0:
+                threads.append(exe.submit(image_to_base64, file))
+                continue
+            threads.append(exe.submit(FileService.parse, file["name"], FileService.get_blob(file["created_by"], file["id"]), True, file["created_by"]))
+        return [th.result() for th in threads]
+
+    def tool_use_callback(self, agent_id: str, func_name: str, params: dict, result: Any, elapsed_time=None):
+        agent_ids = agent_id.split("-->")
+        agent_name = self.get_component_name(agent_ids[0])
+        path = agent_name if len(agent_ids) < 2 else agent_name+"-->"+"-->".join(agent_ids[1:])
+        try:
+            bin = REDIS_CONN.get(f"{self.task_id}-{self.message_id}-logs")
+            if bin:
+                obj = json.loads(bin.encode("utf-8"))
+                if obj[-1]["component_id"] == agent_ids[0]:
+                    obj[-1]["trace"].append({"path": path, "tool_name": func_name, "arguments": params, "result": result, "elapsed_time": elapsed_time})
+                else:
+                    obj.append({
+                    "component_id": agent_ids[0],
+                    "trace": [{"path": path, "tool_name": func_name, "arguments": params, "result": result, "elapsed_time": elapsed_time}]
+                })
+            else:
+                obj = [{
+                    "component_id": agent_ids[0],
+                    "trace": [{"path": path, "tool_name": func_name, "arguments": params, "result": result, "elapsed_time": elapsed_time}]
+                }]
+            REDIS_CONN.set_obj(f"{self.task_id}-{self.message_id}-logs", obj, 60*10)
+        except Exception as e:
+            logging.exception(e)
+
+    def add_reference(self, chunks: list[object], doc_infos: list[object]):
+        if not self.retrieval:
+            self.retrieval = [{"chunks": {}, "doc_aggs": {}}]
+
+        r = self.retrieval[-1]
+        for ck in chunks_format({"chunks": chunks}):
+            cid = hash_str2int(ck["id"], 500)
+            # cid = uuid.uuid5(uuid.NAMESPACE_DNS, ck["id"])
+            if cid not in r:
+                r["chunks"][cid] = ck
+
+        for doc in doc_infos:
+            if doc["doc_name"] not in r:
+                r["doc_aggs"][doc["doc_name"]] = doc
+
+    def get_reference(self):
+        if not self.retrieval:
+            return {"chunks": {}, "doc_aggs": {}}
+        return self.retrieval[-1]
+
+    def add_memory(self, user:str, assist:str, summ: str):
+        self.memory.append((user, assist, summ))
+
+    def get_memory(self) -> list[Tuple]:
+        return self.memory
+
+    def get_component_thoughts(self, cpn_id) -> str:
+        return self.components.get(cpn_id)["obj"].thoughts()
+

agent/component/__init__.py

@@ -0,0 +1,58 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+import os
+import importlib
+import inspect
+from types import ModuleType
+from typing import Dict, Type
+
+_package_path = os.path.dirname(__file__)
+__all_classes: Dict[str, Type] = {}
+
+def _import_submodules() -> None:
+    for filename in os.listdir(_package_path): # noqa: F821
+        if filename.startswith("__") or not filename.endswith(".py") or filename.startswith("base"):
+            continue
+        module_name = filename[:-3]
+
+        try:
+            module = importlib.import_module(f".{module_name}", package=__name__)
+            _extract_classes_from_module(module)  # noqa: F821
+        except ImportError as e:
+            print(f"Warning: Failed to import module {module_name}: {str(e)}")
+
+def _extract_classes_from_module(module: ModuleType) -> None:
+    for name, obj in inspect.getmembers(module):
+        if (inspect.isclass(obj) and
+                obj.__module__ == module.__name__ and not name.startswith("_")):
+            __all_classes[name] = obj
+            globals()[name] = obj
+
+_import_submodules()
+
+__all__ = list(__all_classes.keys()) + ["__all_classes"]
+
+del _package_path, _import_submodules, _extract_classes_from_module
+
+
+def component_class(class_name):
+    for mdl in ["agent.component", "agent.tools", "rag.flow"]:
+        try:
+            return getattr(importlib.import_module(mdl), class_name)
+        except Exception:
+            pass
+    assert False, f"Can't import {class_name}"

agent/component/agent_with_tools.py

@@ -0,0 +1,352 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import re
+from concurrent.futures import ThreadPoolExecutor
+from copy import deepcopy
+from functools import partial
+from typing import Any
+
+import json_repair
+from timeit import default_timer as timer
+from agent.tools.base import LLMToolPluginCallSession, ToolParamBase, ToolBase, ToolMeta
+from api.db.services.llm_service import LLMBundle
+from api.db.services.tenant_llm_service import TenantLLMService
+from api.db.services.mcp_server_service import MCPServerService
+from api.utils.api_utils import timeout
+from rag.prompts.generator import next_step, COMPLETE_TASK, analyze_task, \
+    citation_prompt, reflect, rank_memories, kb_prompt, citation_plus, full_question, message_fit_in
+from rag.utils.mcp_tool_call_conn import MCPToolCallSession, mcp_tool_metadata_to_openai_tool
+from agent.component.llm import LLMParam, LLM
+
+
+class AgentParam(LLMParam, ToolParamBase):
+    """
+    Define the Agent component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+                "name": "agent",
+                "description": "This is an agent for a specific task.",
+                "parameters": {
+                    "user_prompt": {
+                        "type": "string",
+                        "description": "This is the order you need to send to the agent.",
+                        "default": "",
+                        "required": True
+                    },
+                    "reasoning": {
+                        "type": "string",
+                        "description": (
+                            "Supervisor's reasoning for choosing the this agent. "
+                            "Explain why this agent is being invoked and what is expected of it."
+                        ),
+                        "required": True
+                    },
+                    "context": {
+                        "type": "string",
+                        "description": (
+                                "All relevant background information, prior facts, decisions, "
+                                "and state needed by the agent to solve the current query. "
+                                "Should be as detailed and self-contained as possible."
+                            ),
+                        "required": True
+                    },
+                }
+            }
+        super().__init__()
+        self.function_name = "agent"
+        self.tools = []
+        self.mcp = []
+        self.max_rounds = 5
+        self.description = ""
+
+
+class Agent(LLM, ToolBase):
+    component_name = "Agent"
+
+    def __init__(self, canvas, id, param: LLMParam):
+        LLM.__init__(self, canvas, id, param)
+        self.tools = {}
+        for cpn in self._param.tools:
+            cpn = self._load_tool_obj(cpn)
+            self.tools[cpn.get_meta()["function"]["name"]] = cpn
+
+        self.chat_mdl = LLMBundle(self._canvas.get_tenant_id(), TenantLLMService.llm_id2llm_type(self._param.llm_id), self._param.llm_id,
+                                  max_retries=self._param.max_retries,
+                                  retry_interval=self._param.delay_after_error,
+                                  max_rounds=self._param.max_rounds,
+                                  verbose_tool_use=True
+                                  )
+        self.tool_meta = [v.get_meta() for _,v in self.tools.items()]
+
+        for mcp in self._param.mcp:
+            _, mcp_server = MCPServerService.get_by_id(mcp["mcp_id"])
+            tool_call_session = MCPToolCallSession(mcp_server, mcp_server.variables)
+            for tnm, meta in mcp["tools"].items():
+                self.tool_meta.append(mcp_tool_metadata_to_openai_tool(meta))
+                self.tools[tnm] = tool_call_session
+        self.callback = partial(self._canvas.tool_use_callback, id)
+        self.toolcall_session = LLMToolPluginCallSession(self.tools, self.callback)
+        #self.chat_mdl.bind_tools(self.toolcall_session, self.tool_metas)
+
+    def _load_tool_obj(self, cpn: dict) -> object:
+        from agent.component import component_class
+        param = component_class(cpn["component_name"] + "Param")()
+        param.update(cpn["params"])
+        try:
+            param.check()
+        except Exception as e:
+            self.set_output("_ERROR", cpn["component_name"] + f" configuration error: {e}")
+            raise
+        cpn_id = f"{self._id}-->" + cpn.get("name", "").replace(" ", "_")
+        return component_class(cpn["component_name"])(self._canvas, cpn_id, param)
+
+    def get_meta(self) -> dict[str, Any]:
+        self._param.function_name= self._id.split("-->")[-1]
+        m = super().get_meta()
+        if hasattr(self._param, "user_prompt") and self._param.user_prompt:
+            m["function"]["parameters"]["properties"]["user_prompt"] = self._param.user_prompt
+        return m
+
+    def get_input_form(self) -> dict[str, dict]:
+        res = {}
+        for k, v in self.get_input_elements().items():
+            res[k] = {
+                "type": "line",
+                "name": v["name"]
+            }
+        for cpn in self._param.tools:
+            if not isinstance(cpn, LLM):
+                continue
+            res.update(cpn.get_input_form())
+        return res
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 20*60)))
+    def _invoke(self, **kwargs):
+        if kwargs.get("user_prompt"):
+            usr_pmt = ""
+            if kwargs.get("reasoning"):
+                usr_pmt += "\nREASONING:\n{}\n".format(kwargs["reasoning"])
+            if kwargs.get("context"):
+                usr_pmt += "\nCONTEXT:\n{}\n".format(kwargs["context"])
+            if usr_pmt:
+                usr_pmt += "\nQUERY:\n{}\n".format(str(kwargs["user_prompt"]))
+            else:
+                usr_pmt = str(kwargs["user_prompt"])
+            self._param.prompts = [{"role": "user", "content": usr_pmt}]
+
+        if not self.tools:
+            return LLM._invoke(self, **kwargs)
+
+        prompt, msg, user_defined_prompt = self._prepare_prompt_variables()
+
+        downstreams = self._canvas.get_component(self._id)["downstream"] if self._canvas.get_component(self._id) else []
+        ex = self.exception_handler()
+        if any([self._canvas.get_component_obj(cid).component_name.lower()=="message" for cid in downstreams]) and not self._param.output_structure and not (ex and ex["goto"]):
+            self.set_output("content", partial(self.stream_output_with_tools, prompt, msg, user_defined_prompt))
+            return
+
+        _, msg = message_fit_in([{"role": "system", "content": prompt}, *msg], int(self.chat_mdl.max_length * 0.97))
+        use_tools = []
+        ans = ""
+        for delta_ans, tk in self._react_with_tools_streamly(prompt, msg, use_tools, user_defined_prompt):
+            ans += delta_ans
+
+        if ans.find("**ERROR**") >= 0:
+            logging.error(f"Agent._chat got error. response: {ans}")
+            if self.get_exception_default_value():
+                self.set_output("content", self.get_exception_default_value())
+            else:
+                self.set_output("_ERROR", ans)
+            return
+
+        self.set_output("content", ans)
+        if use_tools:
+            self.set_output("use_tools", use_tools)
+        return ans
+
+    def stream_output_with_tools(self, prompt, msg, user_defined_prompt={}):
+        _, msg = message_fit_in([{"role": "system", "content": prompt}, *msg], int(self.chat_mdl.max_length * 0.97))
+        answer_without_toolcall = ""
+        use_tools = []
+        for delta_ans,_ in self._react_with_tools_streamly(prompt, msg, use_tools, user_defined_prompt):
+            if delta_ans.find("**ERROR**") >= 0:
+                if self.get_exception_default_value():
+                    self.set_output("content", self.get_exception_default_value())
+                    yield self.get_exception_default_value()
+                else:
+                    self.set_output("_ERROR", delta_ans)
+            answer_without_toolcall += delta_ans
+            yield delta_ans
+
+        self.set_output("content", answer_without_toolcall)
+        if use_tools:
+            self.set_output("use_tools", use_tools)
+
+    def _gen_citations(self, text):
+        retrievals = self._canvas.get_reference()
+        retrievals = {"chunks": list(retrievals["chunks"].values()), "doc_aggs": list(retrievals["doc_aggs"].values())}
+        formated_refer = kb_prompt(retrievals, self.chat_mdl.max_length, True)
+        for delta_ans in self._generate_streamly([{"role": "system", "content": citation_plus("\n\n".join(formated_refer))},
+                                                  {"role": "user", "content": text}
+                                                  ]):
+            yield delta_ans
+
+    def _react_with_tools_streamly(self, prompt, history: list[dict], use_tools, user_defined_prompt={}):
+        token_count = 0
+        tool_metas = self.tool_meta
+        hist = deepcopy(history)
+        last_calling = ""
+        if len(hist) > 3:
+            st = timer()
+            user_request = full_question(messages=history, chat_mdl=self.chat_mdl)
+            self.callback("Multi-turn conversation optimization", {}, user_request, elapsed_time=timer()-st)
+        else:
+            user_request = history[-1]["content"]
+
+        def use_tool(name, args):
+            nonlocal hist, use_tools, token_count,last_calling,user_request
+            logging.info(f"{last_calling=} == {name=}")
+            # Summarize of function calling
+            #if all([
+            #    isinstance(self.toolcall_session.get_tool_obj(name), Agent),
+            #    last_calling,
+            #    last_calling != name
+            #]):
+            #    self.toolcall_session.get_tool_obj(name).add2system_prompt(f"The chat history with other agents are as following: \n" + self.get_useful_memory(user_request, str(args["user_prompt"]),user_defined_prompt))
+            last_calling = name
+            tool_response = self.toolcall_session.tool_call(name, args)
+            use_tools.append({
+                "name": name,
+                "arguments": args,
+                "results": tool_response
+            })
+            # self.callback("add_memory", {}, "...")
+            #self.add_memory(hist[-2]["content"], hist[-1]["content"], name, args, str(tool_response), user_defined_prompt)
+
+            return name, tool_response
+
+        def complete():
+            nonlocal hist
+            need2cite = self._param.cite and self._canvas.get_reference()["chunks"] and self._id.find("-->") < 0
+            cited = False
+            if hist[0]["role"] == "system" and need2cite:
+                if len(hist) < 7:
+                    hist[0]["content"] += citation_prompt()
+                    cited = True
+            yield "", token_count
+
+            _hist = hist
+            if len(hist) > 12:
+                _hist = [hist[0], hist[1], *hist[-10:]]
+            entire_txt = ""
+            for delta_ans in self._generate_streamly(_hist):
+                if not need2cite or cited:
+                    yield delta_ans, 0
+                entire_txt += delta_ans
+            if not need2cite or cited:
+                return
+
+            st = timer()
+            txt = ""
+            for delta_ans in self._gen_citations(entire_txt):
+                yield delta_ans, 0
+                txt += delta_ans
+
+            self.callback("gen_citations", {}, txt, elapsed_time=timer()-st)
+
+        def append_user_content(hist, content):
+            if hist[-1]["role"] == "user":
+                hist[-1]["content"] += content
+            else:
+                hist.append({"role": "user", "content": content})
+
+        st = timer()
+        task_desc = analyze_task(self.chat_mdl, prompt, user_request, tool_metas, user_defined_prompt)
+        self.callback("analyze_task", {}, task_desc, elapsed_time=timer()-st)
+        for _ in range(self._param.max_rounds + 1):
+            response, tk = next_step(self.chat_mdl, hist, tool_metas, task_desc, user_defined_prompt)
+            # self.callback("next_step", {}, str(response)[:256]+"...")
+            token_count += tk
+            hist.append({"role": "assistant", "content": response})
+            try:
+                functions = json_repair.loads(re.sub(r"```.*", "", response))
+                if not isinstance(functions, list):
+                    raise TypeError(f"List should be returned, but `{functions}`")
+                for f in functions:
+                    if not isinstance(f, dict):
+                        raise TypeError(f"An object type should be returned, but `{f}`")
+                with ThreadPoolExecutor(max_workers=5) as executor:
+                    thr = []
+                    for func in functions:
+                        name = func["name"]
+                        args = func["arguments"]
+                        if name == COMPLETE_TASK:
+                            append_user_content(hist, f"Respond with a formal answer. FORGET(DO NOT mention) about `{COMPLETE_TASK}`. The language for the response MUST be as the same as the first user request.\n")
+                            for txt, tkcnt in complete():
+                                yield txt, tkcnt
+                            return
+
+                        thr.append(executor.submit(use_tool, name, args))
+
+                    st = timer()
+                    reflection = reflect(self.chat_mdl, hist, [th.result() for th in thr], user_defined_prompt)
+                    append_user_content(hist, reflection)
+                    self.callback("reflection", {}, str(reflection), elapsed_time=timer()-st)
+
+            except Exception as e:
+                logging.exception(msg=f"Wrong JSON argument format in LLM ReAct response: {e}")
+                e = f"\nTool call error, please correct the input parameter of response format and call it again.\n *** Exception ***\n{e}"
+                append_user_content(hist, str(e))
+
+        logging.warning( f"Exceed max rounds: {self._param.max_rounds}")
+        final_instruction = f"""
+{user_request}
+IMPORTANT: You have reached the conversation limit. Based on ALL the information and research you have gathered so far, please provide a DIRECT and COMPREHENSIVE final answer to the original request.
+Instructions:
+1. SYNTHESIZE all information collected during this conversation
+2. Provide a COMPLETE response using existing data - do not suggest additional research
+3. Structure your response as a FINAL DELIVERABLE, not a plan
+4. If information is incomplete, state what you found and provide the best analysis possible with available data
+5. DO NOT mention conversation limits or suggest further steps
+6. Focus on delivering VALUE with the information already gathered
+Respond immediately with your final comprehensive answer.
+        """
+        append_user_content(hist, final_instruction)
+
+        for txt, tkcnt in complete():
+            yield txt, tkcnt
+
+    def get_useful_memory(self, goal: str, sub_goal:str, topn=3, user_defined_prompt:dict={}) -> str:
+        # self.callback("get_useful_memory", {"topn": 3}, "...")
+        mems = self._canvas.get_memory()
+        rank = rank_memories(self.chat_mdl, goal, sub_goal, [summ for (user, assist, summ) in mems], user_defined_prompt)
+        try:
+            rank = json_repair.loads(re.sub(r"```.*", "", rank))[:topn]
+            mems = [mems[r] for r in rank]
+            return "\n\n".join([f"User: {u}\nAgent: {a}" for u, a,_ in mems])
+        except Exception as e:
+            logging.exception(e)
+
+        return "Error occurred."
+
+    def reset(self):
+        for k, cpn in self.tools.items():
+            cpn.reset()
+

agent/component/base.py

@@ -0,0 +1,564 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+import re
+import time
+from abc import ABC
+import builtins
+import json
+import os
+import logging
+from typing import Any, List, Union
+import pandas as pd
+import trio
+from agent import settings
+from api.utils.api_utils import timeout
+
+
+_FEEDED_DEPRECATED_PARAMS = "_feeded_deprecated_params"
+_DEPRECATED_PARAMS = "_deprecated_params"
+_USER_FEEDED_PARAMS = "_user_feeded_params"
+_IS_RAW_CONF = "_is_raw_conf"
+
+
+class ComponentParamBase(ABC):
+    def __init__(self):
+        self.message_history_window_size = 13
+        self.inputs = {}
+        self.outputs = {}
+        self.description = ""
+        self.max_retries = 0
+        self.delay_after_error = 2.0
+        self.exception_method = None
+        self.exception_default_value = None
+        self.exception_goto = None
+        self.debug_inputs = {}
+
+    def set_name(self, name: str):
+        self._name = name
+        return self
+
+    def check(self):
+        raise NotImplementedError("Parameter Object should be checked.")
+
+    @classmethod
+    def _get_or_init_deprecated_params_set(cls):
+        if not hasattr(cls, _DEPRECATED_PARAMS):
+            setattr(cls, _DEPRECATED_PARAMS, set())
+        return getattr(cls, _DEPRECATED_PARAMS)
+
+    def _get_or_init_feeded_deprecated_params_set(self, conf=None):
+        if not hasattr(self, _FEEDED_DEPRECATED_PARAMS):
+            if conf is None:
+                setattr(self, _FEEDED_DEPRECATED_PARAMS, set())
+            else:
+                setattr(
+                    self,
+                    _FEEDED_DEPRECATED_PARAMS,
+                    set(conf[_FEEDED_DEPRECATED_PARAMS]),
+                )
+        return getattr(self, _FEEDED_DEPRECATED_PARAMS)
+
+    def _get_or_init_user_feeded_params_set(self, conf=None):
+        if not hasattr(self, _USER_FEEDED_PARAMS):
+            if conf is None:
+                setattr(self, _USER_FEEDED_PARAMS, set())
+            else:
+                setattr(self, _USER_FEEDED_PARAMS, set(conf[_USER_FEEDED_PARAMS]))
+        return getattr(self, _USER_FEEDED_PARAMS)
+
+    def get_user_feeded(self):
+        return self._get_or_init_user_feeded_params_set()
+
+    def get_feeded_deprecated_params(self):
+        return self._get_or_init_feeded_deprecated_params_set()
+
+    @property
+    def _deprecated_params_set(self):
+        return {name: True for name in self.get_feeded_deprecated_params()}
+
+    def __str__(self):
+        return json.dumps(self.as_dict(), ensure_ascii=False)
+
+    def as_dict(self):
+        def _recursive_convert_obj_to_dict(obj):
+            ret_dict = {}
+            if isinstance(obj, dict):
+                for k,v in obj.items():
+                    if isinstance(v, dict) or (v and type(v).__name__ not in dir(builtins)):
+                        ret_dict[k] = _recursive_convert_obj_to_dict(v)
+                    else:
+                        ret_dict[k] = v
+                return ret_dict
+
+            for attr_name in list(obj.__dict__):
+                if attr_name in [_FEEDED_DEPRECATED_PARAMS, _DEPRECATED_PARAMS, _USER_FEEDED_PARAMS, _IS_RAW_CONF]:
+                    continue
+                # get attr
+                attr = getattr(obj, attr_name)
+                if isinstance(attr, pd.DataFrame):
+                    ret_dict[attr_name] = attr.to_dict()
+                    continue
+                if isinstance(attr, dict) or (attr and type(attr).__name__ not in dir(builtins)):
+                    ret_dict[attr_name] = _recursive_convert_obj_to_dict(attr)
+                else:
+                    ret_dict[attr_name] = attr
+
+            return ret_dict
+
+        return _recursive_convert_obj_to_dict(self)
+
+    def update(self, conf, allow_redundant=False):
+        update_from_raw_conf = conf.get(_IS_RAW_CONF, True)
+        if update_from_raw_conf:
+            deprecated_params_set = self._get_or_init_deprecated_params_set()
+            feeded_deprecated_params_set = (
+                self._get_or_init_feeded_deprecated_params_set()
+            )
+            user_feeded_params_set = self._get_or_init_user_feeded_params_set()
+            setattr(self, _IS_RAW_CONF, False)
+        else:
+            feeded_deprecated_params_set = (
+                self._get_or_init_feeded_deprecated_params_set(conf)
+            )
+            user_feeded_params_set = self._get_or_init_user_feeded_params_set(conf)
+
+        def _recursive_update_param(param, config, depth, prefix):
+            if depth > settings.PARAM_MAXDEPTH:
+                raise ValueError("Param define nesting too deep!!!, can not parse it")
+
+            inst_variables = param.__dict__
+            redundant_attrs = []
+            for config_key, config_value in config.items():
+                # redundant attr
+                if config_key not in inst_variables:
+                    if not update_from_raw_conf and config_key.startswith("_"):
+                        setattr(param, config_key, config_value)
+                    else:
+                        setattr(param, config_key, config_value)
+                        # redundant_attrs.append(config_key)
+                    continue
+
+                full_config_key = f"{prefix}{config_key}"
+
+                if update_from_raw_conf:
+                    # add user feeded params
+                    user_feeded_params_set.add(full_config_key)
+
+                    # update user feeded deprecated param set
+                    if full_config_key in deprecated_params_set:
+                        feeded_deprecated_params_set.add(full_config_key)
+
+                # supported attr
+                attr = getattr(param, config_key)
+                if type(attr).__name__ in dir(builtins) or attr is None:
+                    setattr(param, config_key, config_value)
+
+                else:
+                    # recursive set obj attr
+                    sub_params = _recursive_update_param(
+                        attr, config_value, depth + 1, prefix=f"{prefix}{config_key}."
+                    )
+                    setattr(param, config_key, sub_params)
+
+            if not allow_redundant and redundant_attrs:
+                raise ValueError(
+                    f"cpn `{getattr(self, '_name', type(self))}` has redundant parameters: `{[redundant_attrs]}`"
+                )
+
+            return param
+
+        return _recursive_update_param(param=self, config=conf, depth=0, prefix="")
+
+    def extract_not_builtin(self):
+        def _get_not_builtin_types(obj):
+            ret_dict = {}
+            for variable in obj.__dict__:
+                attr = getattr(obj, variable)
+                if attr and type(attr).__name__ not in dir(builtins):
+                    ret_dict[variable] = _get_not_builtin_types(attr)
+
+            return ret_dict
+
+        return _get_not_builtin_types(self)
+
+    def validate(self):
+        self.builtin_types = dir(builtins)
+        self.func = {
+            "ge": self._greater_equal_than,
+            "le": self._less_equal_than,
+            "in": self._in,
+            "not_in": self._not_in,
+            "range": self._range,
+        }
+        home_dir = os.path.abspath(os.path.dirname(os.path.realpath(__file__)))
+        param_validation_path_prefix = home_dir + "/param_validation/"
+
+        param_name = type(self).__name__
+        param_validation_path = "/".join(
+            [param_validation_path_prefix, param_name + ".json"]
+        )
+
+        validation_json = None
+
+        try:
+            with open(param_validation_path, "r") as fin:
+                validation_json = json.loads(fin.read())
+        except BaseException:
+            return
+
+        self._validate_param(self, validation_json)
+
+    def _validate_param(self, param_obj, validation_json):
+        default_section = type(param_obj).__name__
+        var_list = param_obj.__dict__
+
+        for variable in var_list:
+            attr = getattr(param_obj, variable)
+
+            if type(attr).__name__ in self.builtin_types or attr is None:
+                if variable not in validation_json:
+                    continue
+
+                validation_dict = validation_json[default_section][variable]
+                value = getattr(param_obj, variable)
+                value_legal = False
+
+                for op_type in validation_dict:
+                    if self.func[op_type](value, validation_dict[op_type]):
+                        value_legal = True
+                        break
+
+                if not value_legal:
+                    raise ValueError(
+                        "Please check runtime conf, {} = {} does not match user-parameter restriction".format(
+                            variable, value
+                        )
+                    )
+
+            elif variable in validation_json:
+                self._validate_param(attr, validation_json)
+
+    @staticmethod
+    def check_string(param, descr):
+        if type(param).__name__ not in ["str"]:
+            raise ValueError(
+                descr + " {} not supported, should be string type".format(param)
+            )
+
+    @staticmethod
+    def check_empty(param, descr):
+        if not param:
+            raise ValueError(
+                descr + " does not support empty value."
+            )
+
+    @staticmethod
+    def check_positive_integer(param, descr):
+        if type(param).__name__ not in ["int", "long"] or param <= 0:
+            raise ValueError(
+                descr + " {} not supported, should be positive integer".format(param)
+            )
+
+    @staticmethod
+    def check_positive_number(param, descr):
+        if type(param).__name__ not in ["float", "int", "long"] or param <= 0:
+            raise ValueError(
+                descr + " {} not supported, should be positive numeric".format(param)
+            )
+
+    @staticmethod
+    def check_nonnegative_number(param, descr):
+        if type(param).__name__ not in ["float", "int", "long"] or param < 0:
+            raise ValueError(
+                descr
+                + " {} not supported, should be non-negative numeric".format(param)
+            )
+
+    @staticmethod
+    def check_decimal_float(param, descr):
+        if type(param).__name__ not in ["float", "int"] or param < 0 or param > 1:
+            raise ValueError(
+                descr
+                + " {} not supported, should be a float number in range [0, 1]".format(
+                    param
+                )
+            )
+
+    @staticmethod
+    def check_boolean(param, descr):
+        if type(param).__name__ != "bool":
+            raise ValueError(
+                descr + " {} not supported, should be bool type".format(param)
+            )
+
+    @staticmethod
+    def check_open_unit_interval(param, descr):
+        if type(param).__name__ not in ["float"] or param <= 0 or param >= 1:
+            raise ValueError(
+                descr + " should be a numeric number between 0 and 1 exclusively"
+            )
+
+    @staticmethod
+    def check_valid_value(param, descr, valid_values):
+        if param not in valid_values:
+            raise ValueError(
+                descr
+                + " {} is not supported, it should be in {}".format(param, valid_values)
+            )
+
+    @staticmethod
+    def check_defined_type(param, descr, types):
+        if type(param).__name__ not in types:
+            raise ValueError(
+                descr + " {} not supported, should be one of {}".format(param, types)
+            )
+
+    @staticmethod
+    def check_and_change_lower(param, valid_list, descr=""):
+        if type(param).__name__ != "str":
+            raise ValueError(
+                descr
+                + " {} not supported, should be one of {}".format(param, valid_list)
+            )
+
+        lower_param = param.lower()
+        if lower_param in valid_list:
+            return lower_param
+        else:
+            raise ValueError(
+                descr
+                + " {} not supported, should be one of {}".format(param, valid_list)
+            )
+
+    @staticmethod
+    def _greater_equal_than(value, limit):
+        return value >= limit - settings.FLOAT_ZERO
+
+    @staticmethod
+    def _less_equal_than(value, limit):
+        return value <= limit + settings.FLOAT_ZERO
+
+    @staticmethod
+    def _range(value, ranges):
+        in_range = False
+        for left_limit, right_limit in ranges:
+            if (
+                    left_limit - settings.FLOAT_ZERO
+                    <= value
+                    <= right_limit + settings.FLOAT_ZERO
+            ):
+                in_range = True
+                break
+
+        return in_range
+
+    @staticmethod
+    def _in(value, right_value_list):
+        return value in right_value_list
+
+    @staticmethod
+    def _not_in(value, wrong_value_list):
+        return value not in wrong_value_list
+
+    def _warn_deprecated_param(self, param_name, descr):
+        if self._deprecated_params_set.get(param_name):
+            logging.warning(
+                f"{descr} {param_name} is deprecated and ignored in this version."
+            )
+
+    def _warn_to_deprecate_param(self, param_name, descr, new_param):
+        if self._deprecated_params_set.get(param_name):
+            logging.warning(
+                f"{descr} {param_name} will be deprecated in future release; "
+                f"please use {new_param} instead."
+            )
+            return True
+        return False
+
+
+class ComponentBase(ABC):
+    component_name: str
+    thread_limiter = trio.CapacityLimiter(int(os.environ.get('MAX_CONCURRENT_CHATS', 10)))
+    variable_ref_patt = r"\{* *\{([a-zA-Z:0-9]+@[A-Za-z:0-9_.-]+|sys\.[a-z_]+)\} *\}*"
+
+    def __str__(self):
+        """
+        {
+            "component_name": "Begin",
+            "params": {}
+        }
+        """
+        return """{{
+            "component_name": "{}",
+            "params": {}
+        }}""".format(self.component_name,
+                     self._param
+        )
+
+    def __init__(self, canvas, id, param: ComponentParamBase):
+        from agent.canvas import Graph  # Local import to avoid cyclic dependency
+        assert isinstance(canvas, Graph), "canvas must be an instance of Canvas"
+        self._canvas = canvas
+        self._id = id
+        self._param = param
+        self._param.check()
+
+    def invoke(self, **kwargs) -> dict[str, Any]:
+        self.set_output("_created_time", time.perf_counter())
+        try:
+            self._invoke(**kwargs)
+        except Exception as e:
+            if self.get_exception_default_value():
+                self.set_exception_default_value()
+            else:
+                self.set_output("_ERROR", str(e))
+            logging.exception(e)
+        self._param.debug_inputs = {}
+        self.set_output("_elapsed_time", time.perf_counter() - self.output("_created_time"))
+        return self.output()
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 10*60)))
+    def _invoke(self, **kwargs):
+        raise NotImplementedError()
+
+    def output(self, var_nm: str=None) -> Union[dict[str, Any], Any]:
+        if var_nm:
+            return self._param.outputs.get(var_nm, {}).get("value", "")
+        return {k: o.get("value") for k,o in self._param.outputs.items()}
+
+    def set_output(self, key: str, value: Any):
+        if key not in self._param.outputs:
+            self._param.outputs[key] = {"value": None, "type": str(type(value))}
+        self._param.outputs[key]["value"] = value
+
+    def error(self):
+        return self._param.outputs.get("_ERROR", {}).get("value")
+
+    def reset(self, only_output=False):
+        for k in self._param.outputs.keys():
+            self._param.outputs[k]["value"] = None
+        if only_output:
+            return
+        for k in self._param.inputs.keys():
+            self._param.inputs[k]["value"] = None
+        self._param.debug_inputs = {}
+
+    def get_input(self, key: str=None) -> Union[Any, dict[str, Any]]:
+        if key:
+            return self._param.inputs.get(key, {}).get("value")
+
+        res = {}
+        for var, o in self.get_input_elements().items():
+            v = self.get_param(var)
+            if v is None:
+                continue
+            if isinstance(v, str) and self._canvas.is_reff(v):
+                self.set_input_value(var, self._canvas.get_variable_value(v))
+            else:
+                self.set_input_value(var, v)
+            res[var] = self.get_input_value(var)
+        return res
+
+    def get_input_values(self) -> Union[Any, dict[str, Any]]:
+        if self._param.debug_inputs:
+            return self._param.debug_inputs
+
+        return {var: self.get_input_value(var) for var, o in self.get_input_elements().items()}
+
+    def get_input_elements_from_text(self, txt: str) -> dict[str, dict[str, str]]:
+        res = {}
+        for r in re.finditer(self.variable_ref_patt, txt, flags=re.IGNORECASE|re.DOTALL):
+            exp = r.group(1)
+            cpn_id, var_nm = exp.split("@") if exp.find("@")>0 else ("", exp)
+            res[exp] = {
+                "name": (self._canvas.get_component_name(cpn_id) +f"@{var_nm}") if cpn_id else exp,
+                "value": self._canvas.get_variable_value(exp),
+                "_retrival": self._canvas.get_variable_value(f"{cpn_id}@_references") if cpn_id else None,
+                "_cpn_id": cpn_id
+            }
+        return res
+
+    def get_input_elements(self) -> dict[str, Any]:
+        return self._param.inputs
+
+    def get_input_form(self) -> dict[str, dict]:
+        return self._param.get_input_form()
+
+    def set_input_value(self, key: str, value: Any) -> None:
+        if key not in self._param.inputs:
+            self._param.inputs[key] = {"value": None}
+        self._param.inputs[key]["value"] = value
+
+    def get_input_value(self, key: str) -> Any:
+        if key not in self._param.inputs:
+            return None
+        return self._param.inputs[key].get("value")
+
+    def get_component_name(self, cpn_id) -> str:
+        return self._canvas.get_component(cpn_id)["obj"].component_name.lower()
+
+    def get_param(self, name):
+        if hasattr(self._param, name):
+            return getattr(self._param, name)
+
+    def debug(self, **kwargs):
+        return self._invoke(**kwargs)
+
+    def get_parent(self) -> Union[object, None]:
+        pid = self._canvas.get_component(self._id).get("parent_id")
+        if not pid:
+            return
+        return self._canvas.get_component(pid)["obj"]
+
+    def get_upstream(self) -> List[str]:
+        cpn_nms = self._canvas.get_component(self._id)['upstream']
+        return cpn_nms
+
+    def get_downstream(self) -> List[str]:
+        cpn_nms = self._canvas.get_component(self._id)['downstream']
+        return cpn_nms
+
+    @staticmethod
+    def string_format(content: str, kv: dict[str, str]) -> str:
+        for n, v in kv.items():
+            def repl(_match, val=v):
+                return str(val) if val is not None else ""
+            content = re.sub(
+                r"\{%s\}" % re.escape(n),
+                repl,
+                content
+            )
+        return content
+
+    def exception_handler(self):
+        if not self._param.exception_method:
+            return
+        return {
+            "goto": self._param.exception_goto,
+            "default_value": self._param.exception_default_value
+        }
+
+    def get_exception_default_value(self):
+        if self._param.exception_method != "comment":
+            return ""
+        return self._param.exception_default_value
+
+    def set_exception_default_value(self):
+        self.set_output("result", self.get_exception_default_value())
+
+    def thoughts(self) -> str:
+        raise NotImplementedError()

agent/component/begin.py

@@ -0,0 +1,52 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from agent.component.fillup import UserFillUpParam, UserFillUp
+
+
+class BeginParam(UserFillUpParam):
+
+    """
+    Define the Begin component parameters.
+    """
+    def __init__(self):
+        super().__init__()
+        self.mode = "conversational"
+        self.prologue = "Hi! I'm your smart assistant. What can I do for you?"
+
+    def check(self):
+        self.check_valid_value(self.mode, "The 'mode' should be either `conversational` or `task`", ["conversational", "task"])
+
+    def get_input_form(self) -> dict[str, dict]:
+        return getattr(self, "inputs")
+
+
+class Begin(UserFillUp):
+    component_name = "Begin"
+
+    def _invoke(self, **kwargs):
+        for k, v in kwargs.get("inputs", {}).items():
+            if isinstance(v, dict) and v.get("type", "").lower().find("file") >=0:
+                if v.get("optional") and v.get("value", None) is None:
+                    v = None
+                else:
+                    v = self._canvas.get_files([v["value"]])
+            else:
+                v = v.get("value")
+            self.set_output(k, v)
+            self.set_input_value(k, v)
+
+    def thoughts(self) -> str:
+        return ""

agent/component/categorize.py

@@ -0,0 +1,137 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import re
+from abc import ABC
+
+from api.db import LLMType
+from api.db.services.llm_service import LLMBundle
+from agent.component.llm import LLMParam, LLM
+from api.utils.api_utils import timeout
+from rag.llm.chat_model import ERROR_PREFIX
+
+
+class CategorizeParam(LLMParam):
+
+    """
+    Define the categorize component parameters.
+    """
+    def __init__(self):
+        super().__init__()
+        self.category_description = {}
+        self.query = "sys.query"
+        self.message_history_window_size = 1
+        self.update_prompt()
+
+    def check(self):
+        self.check_positive_integer(self.message_history_window_size, "[Categorize] Message window size > 0")
+        self.check_empty(self.category_description, "[Categorize] Category examples")
+        for k, v in self.category_description.items():
+            if not k:
+                raise ValueError("[Categorize] Category name can not be empty!")
+            if not v.get("to"):
+                raise ValueError(f"[Categorize] 'To' of category {k} can not be empty!")
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "query": {
+                "type": "line",
+                "name": "Query"
+            }
+        }
+
+    def update_prompt(self):
+        cate_lines = []
+        for c, desc in self.category_description.items():
+            for line in desc.get("examples", []):
+                if not line:
+                    continue
+                cate_lines.append("USER: \"" + re.sub(r"\n", "    ", line, flags=re.DOTALL) + "\" → "+c)
+
+        descriptions = []
+        for c, desc in self.category_description.items():
+            if desc.get("description"):
+                descriptions.append(
+                    "\n------\nCategory: {}\nDescription: {}".format(c, desc["description"]))
+
+        self.sys_prompt = """
+You are an advanced classification system that categorizes user questions into specific types. Analyze the input question and classify it into ONE of the following categories:
+{}
+
+Here's description of each category:
+ - {}
+
+---- Instructions ----
+ - Consider both explicit mentions and implied context
+ - Prioritize the most specific applicable category
+ - Return only the category name without explanations
+ - Use "Other" only when no other category fits
+
+ """.format(
+            "\n - ".join(list(self.category_description.keys())),
+            "\n".join(descriptions)
+        )
+
+        if cate_lines:
+            self.sys_prompt += """
+---- Examples ----
+{}
+""".format("\n".join(cate_lines))
+
+
+class Categorize(LLM, ABC):
+    component_name = "Categorize"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 10*60)))
+    def _invoke(self, **kwargs):
+        msg = self._canvas.get_history(self._param.message_history_window_size)
+        if not msg:
+            msg = [{"role": "user", "content": ""}]
+        if kwargs.get("sys.query"):
+            msg[-1]["content"] = kwargs["sys.query"]
+            self.set_input_value("sys.query", kwargs["sys.query"])
+        else:
+            msg[-1]["content"] = self._canvas.get_variable_value(self._param.query)
+            self.set_input_value(self._param.query, msg[-1]["content"])
+        self._param.update_prompt()
+        chat_mdl = LLMBundle(self._canvas.get_tenant_id(), LLMType.CHAT, self._param.llm_id)
+
+        user_prompt = """
+---- Real Data ----
+{} →
+""".format(" | ".join(["{}: \"{}\"".format(c["role"].upper(), re.sub(r"\n", "", c["content"], flags=re.DOTALL)) for c in msg]))
+        ans = chat_mdl.chat(self._param.sys_prompt, [{"role": "user", "content": user_prompt}], self._param.gen_conf())
+        logging.info(f"input: {user_prompt}, answer: {str(ans)}")
+        if ERROR_PREFIX in ans:
+            raise Exception(ans)
+        # Count the number of times each category appears in the answer.
+        category_counts = {}
+        for c in self._param.category_description.keys():
+            count = ans.lower().count(c.lower())
+            category_counts[c] = count
+
+        cpn_ids = list(self._param.category_description.items())[-1][1]["to"]
+        max_category = list(self._param.category_description.keys())[0]
+        if any(category_counts.values()):
+            max_category = max(category_counts.items(), key=lambda x: x[1])[0]
+            cpn_ids = self._param.category_description[max_category]["to"]
+
+        self.set_output("category_name", max_category)
+        self.set_output("_next", cpn_ids)
+
+    def thoughts(self) -> str:
+        return "Which should it falls into {}? ...".format(",".join([f"`{c}`" for c, _ in self._param.category_description.items()]))

agent/component/fillup.py

@@ -0,0 +1,40 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from agent.component.base import ComponentBase, ComponentParamBase
+
+
+class UserFillUpParam(ComponentParamBase):
+
+    def __init__(self):
+        super().__init__()
+        self.enable_tips = True
+        self.tips = "Please fill up the form"
+
+    def check(self) -> bool:
+        return True
+
+
+class UserFillUp(ComponentBase):
+    component_name = "UserFillUp"
+
+    def _invoke(self, **kwargs):
+        for k, v in kwargs.get("inputs", {}).items():
+            self.set_output(k, v)
+
+    def thoughts(self) -> str:
+        return "Waiting for your input..."
+
+

agent/component/invoke.py

@@ -0,0 +1,135 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import json
+import logging
+import os
+import re
+import time
+from abc import ABC
+
+import requests
+
+from agent.component.base import ComponentBase, ComponentParamBase
+from api.utils.api_utils import timeout
+from deepdoc.parser import HtmlParser
+
+
+class InvokeParam(ComponentParamBase):
+    """
+    Define the Crawler component parameters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.proxy = None
+        self.headers = ""
+        self.method = "get"
+        self.variables = []
+        self.url = ""
+        self.timeout = 60
+        self.clean_html = False
+        self.datatype = "json"  # New parameter to determine data posting type
+
+    def check(self):
+        self.check_valid_value(self.method.lower(), "Type of content from the crawler", ["get", "post", "put"])
+        self.check_empty(self.url, "End point URL")
+        self.check_positive_integer(self.timeout, "Timeout time in second")
+        self.check_boolean(self.clean_html, "Clean HTML")
+        self.check_valid_value(self.datatype.lower(), "Data post type", ["json", "formdata"])  # Check for valid datapost value
+
+
+class Invoke(ComponentBase, ABC):
+    component_name = "Invoke"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 3)))
+    def _invoke(self, **kwargs):
+        args = {}
+        for para in self._param.variables:
+            if para.get("value"):
+                args[para["key"]] = para["value"]
+            else:
+                args[para["key"]] = self._canvas.get_variable_value(para["ref"])
+
+        url = self._param.url.strip()
+
+        def replace_variable(match):
+            var_name = match.group(1)
+            try:
+                value = self._canvas.get_variable_value(var_name)
+                return str(value or "")
+            except Exception:
+                return ""
+
+        # {base_url} or {component_id@variable_name}
+        url = re.sub(r"\{([a-zA-Z_][a-zA-Z0-9_.@-]*)\}", replace_variable, url)
+
+        if url.find("http") != 0:
+            url = "http://" + url
+
+        method = self._param.method.lower()
+        headers = {}
+        if self._param.headers:
+            headers = json.loads(self._param.headers)
+        proxies = None
+        if re.sub(r"https?:?/?/?", "", self._param.proxy):
+            proxies = {"http": self._param.proxy, "https": self._param.proxy}
+
+        last_e = ""
+        for _ in range(self._param.max_retries + 1):
+            try:
+                if method == "get":
+                    response = requests.get(url=url, params=args, headers=headers, proxies=proxies, timeout=self._param.timeout)
+                    if self._param.clean_html:
+                        sections = HtmlParser()(None, response.content)
+                        self.set_output("result", "\n".join(sections))
+                    else:
+                        self.set_output("result", response.text)
+
+                if method == "put":
+                    if self._param.datatype.lower() == "json":
+                        response = requests.put(url=url, json=args, headers=headers, proxies=proxies, timeout=self._param.timeout)
+                    else:
+                        response = requests.put(url=url, data=args, headers=headers, proxies=proxies, timeout=self._param.timeout)
+                    if self._param.clean_html:
+                        sections = HtmlParser()(None, response.content)
+                        self.set_output("result", "\n".join(sections))
+                    else:
+                        self.set_output("result", response.text)
+
+                if method == "post":
+                    if self._param.datatype.lower() == "json":
+                        response = requests.post(url=url, json=args, headers=headers, proxies=proxies, timeout=self._param.timeout)
+                    else:
+                        response = requests.post(url=url, data=args, headers=headers, proxies=proxies, timeout=self._param.timeout)
+                    if self._param.clean_html:
+                        self.set_output("result", "\n".join(sections))
+                    else:
+                        self.set_output("result", response.text)
+
+                return self.output("result")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"Http request error: {e}")
+                time.sleep(self._param.delay_after_error)
+
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"Http request error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return "Waiting for the server respond..."

agent/component/iteration.py

@@ -0,0 +1,60 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from abc import ABC
+from agent.component.base import ComponentBase, ComponentParamBase
+
+
+class IterationParam(ComponentParamBase):
+    """
+    Define the Iteration component parameters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.items_ref = ""
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "items": {
+                "type": "json",
+                "name": "Items"
+            }
+        }
+
+    def check(self):
+        return True
+
+
+class Iteration(ComponentBase, ABC):
+    component_name = "Iteration"
+
+    def get_start(self):
+        for cid in self._canvas.components.keys():
+            if self._canvas.get_component(cid)["obj"].component_name.lower() != "iterationitem":
+                continue
+            if self._canvas.get_component(cid)["parent_id"] == self._id:
+                return cid
+
+    def _invoke(self, **kwargs):
+        arr = self._canvas.get_variable_value(self._param.items_ref)
+        if not isinstance(arr, list):
+            self.set_output("_ERROR", self._param.items_ref + " must be an array, but its type is "+str(type(arr)))
+
+    def thoughts(self) -> str:
+        return "Need to process {} items.".format(len(self._canvas.get_variable_value(self._param.items_ref)))
+
+
+

agent/component/iterationitem.py

@@ -0,0 +1,83 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from abc import ABC
+from agent.component.base import ComponentBase, ComponentParamBase
+
+
+class IterationItemParam(ComponentParamBase):
+    """
+    Define the IterationItem component parameters.
+    """
+    def check(self):
+        return True
+
+
+class IterationItem(ComponentBase, ABC):
+    component_name = "IterationItem"
+
+    def __init__(self, canvas, id, param: ComponentParamBase):
+        super().__init__(canvas, id, param)
+        self._idx = 0
+
+    def _invoke(self, **kwargs):
+        parent = self.get_parent()
+        arr = self._canvas.get_variable_value(parent._param.items_ref)
+        if not isinstance(arr, list):
+            self._idx = -1
+            raise Exception(parent._param.items_ref + " must be an array, but its type is "+str(type(arr)))
+
+        if self._idx > 0:
+            self.output_collation()
+
+        if self._idx >= len(arr):
+            self._idx = -1
+            return
+
+        self.set_output("item", arr[self._idx])
+        self.set_output("index", self._idx)
+
+        self._idx += 1
+
+    def output_collation(self):
+        pid = self.get_parent()._id
+        for cid in self._canvas.components.keys():
+            obj = self._canvas.get_component_obj(cid)
+            p = obj.get_parent()
+            if not p:
+                continue
+            if p._id != pid:
+                continue
+
+            if p.component_name.lower() in ["categorize", "message", "switch", "userfillup", "interationitem"]:
+                continue
+
+            for k, o in p._param.outputs.items():
+                if "ref" not in o:
+                    continue
+                _cid, var = o["ref"].split("@")
+                if _cid != cid:
+                    continue
+                res = p.output(k)
+                if not res:
+                    res = []
+                res.append(obj.output(var))
+                p.set_output(k, res)
+
+    def end(self):
+        return self._idx == -1
+
+    def thoughts(self) -> str:
+        return "Next turn..."

agent/component/llm.py

@@ -0,0 +1,286 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import json
+import logging
+import os
+import re
+from copy import deepcopy
+from typing import Any, Generator
+import json_repair
+from functools import partial
+from api.db import LLMType
+from api.db.services.llm_service import LLMBundle
+from api.db.services.tenant_llm_service import TenantLLMService
+from agent.component.base import ComponentBase, ComponentParamBase
+from api.utils.api_utils import timeout
+from rag.prompts.generator import tool_call_summary, message_fit_in, citation_prompt
+
+
+class LLMParam(ComponentParamBase):
+    """
+    Define the LLM component parameters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.llm_id = ""
+        self.sys_prompt = ""
+        self.prompts = [{"role": "user", "content": "{sys.query}"}]
+        self.max_tokens = 0
+        self.temperature = 0
+        self.top_p = 0
+        self.presence_penalty = 0
+        self.frequency_penalty = 0
+        self.output_structure = None
+        self.cite = True
+        self.visual_files_var = None
+
+    def check(self):
+        self.check_decimal_float(float(self.temperature), "[Agent] Temperature")
+        self.check_decimal_float(float(self.presence_penalty), "[Agent] Presence penalty")
+        self.check_decimal_float(float(self.frequency_penalty), "[Agent] Frequency penalty")
+        self.check_nonnegative_number(int(self.max_tokens), "[Agent] Max tokens")
+        self.check_decimal_float(float(self.top_p), "[Agent] Top P")
+        self.check_empty(self.llm_id, "[Agent] LLM")
+        self.check_empty(self.sys_prompt, "[Agent] System prompt")
+        self.check_empty(self.prompts, "[Agent] User prompt")
+
+    def gen_conf(self):
+        conf = {}
+        def get_attr(nm):
+            try:
+                return getattr(self, nm)
+            except Exception:
+                pass
+
+        if int(self.max_tokens) > 0 and get_attr("maxTokensEnabled"):
+            conf["max_tokens"] = int(self.max_tokens)
+        if float(self.temperature) > 0 and get_attr("temperatureEnabled"):
+            conf["temperature"] = float(self.temperature)
+        if float(self.top_p) > 0 and get_attr("topPEnabled"):
+            conf["top_p"] = float(self.top_p)
+        if float(self.presence_penalty) > 0 and get_attr("presencePenaltyEnabled"):
+            conf["presence_penalty"] = float(self.presence_penalty)
+        if float(self.frequency_penalty) > 0 and get_attr("frequencyPenaltyEnabled"):
+            conf["frequency_penalty"] = float(self.frequency_penalty)
+        return conf
+
+
+class LLM(ComponentBase):
+    component_name = "LLM"
+
+    def __init__(self, canvas, component_id, param: ComponentParamBase):
+        super().__init__(canvas, component_id, param)
+        self.chat_mdl = LLMBundle(self._canvas.get_tenant_id(), TenantLLMService.llm_id2llm_type(self._param.llm_id),
+                                  self._param.llm_id, max_retries=self._param.max_retries,
+                                  retry_interval=self._param.delay_after_error
+                                  )
+        self.imgs = []
+
+    def get_input_form(self) -> dict[str, dict]:
+        res = {}
+        for k, v in self.get_input_elements().items():
+            res[k] = {
+                "type": "line",
+                "name": v["name"]
+            }
+        return res
+
+    def get_input_elements(self) -> dict[str, Any]:
+        res = self.get_input_elements_from_text(self._param.sys_prompt)
+        if isinstance(self._param.prompts, str):
+            self._param.prompts = [{"role": "user", "content": self._param.prompts}]
+        for prompt in self._param.prompts:
+            d = self.get_input_elements_from_text(prompt["content"])
+            res.update(d)
+        return res
+
+    def set_debug_inputs(self, inputs: dict[str, dict]):
+        self._param.debug_inputs = inputs
+
+    def add2system_prompt(self, txt):
+        self._param.sys_prompt += txt
+
+    def _sys_prompt_and_msg(self, msg, args):
+        if isinstance(self._param.prompts, str):
+            self._param.prompts = [{"role": "user", "content": self._param.prompts}]
+        for p in self._param.prompts:
+            if msg and msg[-1]["role"] == p["role"]:
+                continue
+            p = deepcopy(p)
+            p["content"] = self.string_format(p["content"], args)
+            msg.append(p)
+        return msg, self.string_format(self._param.sys_prompt, args)
+
+    def _prepare_prompt_variables(self):
+        if self._param.visual_files_var:
+            self.imgs = self._canvas.get_variable_value(self._param.visual_files_var)
+            if not self.imgs:
+                self.imgs = []
+            self.imgs = [img for img in self.imgs if img[:len("data:image/")] == "data:image/"]
+            if self.imgs and TenantLLMService.llm_id2llm_type(self._param.llm_id) == LLMType.CHAT.value:
+                self.chat_mdl = LLMBundle(self._canvas.get_tenant_id(), LLMType.IMAGE2TEXT.value,
+                                          self._param.llm_id, max_retries=self._param.max_retries,
+                                          retry_interval=self._param.delay_after_error
+                                          )
+
+
+        args = {}
+        vars = self.get_input_elements() if not self._param.debug_inputs else self._param.debug_inputs
+        for k, o in vars.items():
+            args[k] = o["value"]
+            if not isinstance(args[k], str):
+                try:
+                    args[k] = json.dumps(args[k], ensure_ascii=False)
+                except Exception:
+                    args[k] = str(args[k])
+            self.set_input_value(k, args[k])
+
+        msg, sys_prompt = self._sys_prompt_and_msg(self._canvas.get_history(self._param.message_history_window_size)[:-1], args)
+        user_defined_prompt, sys_prompt = self._extract_prompts(sys_prompt)
+        if self._param.cite and self._canvas.get_reference()["chunks"]:
+            sys_prompt += citation_prompt(user_defined_prompt)
+
+        return sys_prompt, msg, user_defined_prompt
+
+    def _extract_prompts(self, sys_prompt):
+        pts = {}
+        for tag in ["TASK_ANALYSIS", "PLAN_GENERATION", "REFLECTION", "CONTEXT_SUMMARY", "CONTEXT_RANKING", "CITATION_GUIDELINES"]:
+            r = re.search(rf"<{tag}>(.*?)</{tag}>", sys_prompt, flags=re.DOTALL|re.IGNORECASE)
+            if not r:
+                continue
+            pts[tag.lower()] = r.group(1)
+            sys_prompt = re.sub(rf"<{tag}>(.*?)</{tag}>", "", sys_prompt, flags=re.DOTALL|re.IGNORECASE)
+        return pts, sys_prompt
+
+    def _generate(self, msg:list[dict], **kwargs) -> str:
+        if not self.imgs:
+            return self.chat_mdl.chat(msg[0]["content"], msg[1:], self._param.gen_conf(), **kwargs)
+        return self.chat_mdl.chat(msg[0]["content"], msg[1:], self._param.gen_conf(), images=self.imgs, **kwargs)
+
+    def _generate_streamly(self, msg:list[dict], **kwargs) -> Generator[str, None, None]:
+        ans = ""
+        last_idx = 0
+        endswith_think = False
+        def delta(txt):
+            nonlocal ans, last_idx, endswith_think
+            delta_ans = txt[last_idx:]
+            ans = txt
+
+            if delta_ans.find("<think>") == 0:
+                last_idx += len("<think>")
+                return "<think>"
+            elif delta_ans.find("<think>") > 0:
+                delta_ans = txt[last_idx:last_idx+delta_ans.find("<think>")]
+                last_idx += delta_ans.find("<think>")
+                return delta_ans
+            elif delta_ans.endswith("</think>"):
+                endswith_think = True
+            elif endswith_think:
+                endswith_think = False
+                return "</think>"
+
+            last_idx = len(ans)
+            if ans.endswith("</think>"):
+                last_idx -= len("</think>")
+            return re.sub(r"(<think>|</think>)", "", delta_ans)
+
+        if not self.imgs:
+            for txt in self.chat_mdl.chat_streamly(msg[0]["content"], msg[1:], self._param.gen_conf(), **kwargs):
+                yield delta(txt)
+        else:
+            for txt in self.chat_mdl.chat_streamly(msg[0]["content"], msg[1:], self._param.gen_conf(), images=self.imgs, **kwargs):
+                yield delta(txt)
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 10*60)))
+    def _invoke(self, **kwargs):
+        def clean_formated_answer(ans: str) -> str:
+            ans = re.sub(r"^.*</think>", "", ans, flags=re.DOTALL)
+            ans = re.sub(r"^.*```json", "", ans, flags=re.DOTALL)
+            return re.sub(r"```\n*$", "", ans, flags=re.DOTALL)
+
+        prompt, msg, _ = self._prepare_prompt_variables()
+        error: str = ""
+
+        if self._param.output_structure:
+            prompt += "\nThe output MUST follow this JSON format:\n"+json.dumps(self._param.output_structure, ensure_ascii=False, indent=2)
+            prompt += "\nRedundant information is FORBIDDEN."
+            for _ in range(self._param.max_retries+1):
+                _, msg = message_fit_in([{"role": "system", "content": prompt}, *msg], int(self.chat_mdl.max_length * 0.97))
+                error = ""
+                ans = self._generate(msg)
+                msg.pop(0)
+                if ans.find("**ERROR**") >= 0:
+                    logging.error(f"LLM response error: {ans}")
+                    error = ans
+                    continue
+                try:
+                    self.set_output("structured_content", json_repair.loads(clean_formated_answer(ans)))
+                    return
+                except Exception:
+                    msg.append({"role": "user", "content": "The answer can't not be parsed as JSON"})
+                    error = "The answer can't not be parsed as JSON"
+            if error:
+                self.set_output("_ERROR", error)
+            return
+
+        downstreams = self._canvas.get_component(self._id)["downstream"] if self._canvas.get_component(self._id) else []
+        ex = self.exception_handler()
+        if any([self._canvas.get_component_obj(cid).component_name.lower()=="message" for cid in downstreams]) and not self._param.output_structure and not (ex and ex["goto"]):
+            self.set_output("content", partial(self._stream_output, prompt, msg))
+            return
+
+        for _ in range(self._param.max_retries+1):
+            _, msg = message_fit_in([{"role": "system", "content": prompt}, *msg], int(self.chat_mdl.max_length * 0.97))
+            error = ""
+            ans = self._generate(msg)
+            msg.pop(0)
+            if ans.find("**ERROR**") >= 0:
+                logging.error(f"LLM response error: {ans}")
+                error = ans
+                continue
+            self.set_output("content", ans)
+            break
+
+        if error:
+            if self.get_exception_default_value():
+                self.set_output("content", self.get_exception_default_value())
+            else:
+                self.set_output("_ERROR", error)
+
+    def _stream_output(self, prompt, msg):
+        _, msg = message_fit_in([{"role": "system", "content": prompt}, *msg], int(self.chat_mdl.max_length * 0.97))
+        answer = ""
+        for ans in self._generate_streamly(msg):
+            if ans.find("**ERROR**") >= 0:
+                if self.get_exception_default_value():
+                    self.set_output("content", self.get_exception_default_value())
+                    yield self.get_exception_default_value()
+                else:
+                    self.set_output("_ERROR", ans)
+                return
+            yield ans
+            answer += ans
+        self.set_output("content", answer)
+
+    def add_memory(self, user:str, assist:str, func_name: str, params: dict, results: str, user_defined_prompt:dict={}):
+        summ = tool_call_summary(self.chat_mdl, func_name, params, results, user_defined_prompt)
+        logging.info(f"[MEMORY]: {summ}")
+        self._canvas.add_memory(user, assist, summ)
+
+    def thoughts(self) -> str:
+        _, msg,_ = self._prepare_prompt_variables()
+        return "⌛Give me a moment—starting from: \n\n" + re.sub(r"(User's query:|[\\]+)", '', msg[-1]['content'], flags=re.DOTALL) + "\n\nI’ll figure out our best next move."

agent/component/message.py

@@ -0,0 +1,150 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import json
+import os
+import random
+import re
+from functools import partial
+from typing import Any
+
+from agent.component.base import ComponentBase, ComponentParamBase
+from jinja2 import Template as Jinja2Template
+
+from api.utils.api_utils import timeout
+
+
+class MessageParam(ComponentParamBase):
+    """
+    Define the Message component parameters.
+    """
+    def __init__(self):
+        super().__init__()
+        self.content = []
+        self.stream = True
+        self.outputs = {
+            "content": {
+                "type": "str"
+            }
+        }
+
+    def check(self):
+        self.check_empty(self.content, "[Message] Content")
+        self.check_boolean(self.stream, "[Message] stream")
+        return True
+
+
+class Message(ComponentBase):
+    component_name = "Message"
+
+    def get_kwargs(self, script:str, kwargs:dict = {}, delimiter:str=None) -> tuple[str, dict[str, str | list | Any]]:
+        for k,v in self.get_input_elements_from_text(script).items():
+            if k in kwargs:
+                continue
+            v = v["value"]
+            if not v:
+                v = ""
+            ans = ""
+            if isinstance(v, partial):
+                for t in v():
+                    ans += t
+            elif isinstance(v, list) and delimiter:
+                ans = delimiter.join([str(vv) for vv in v])
+            elif not isinstance(v, str):
+                try:
+                    ans = json.dumps(v, ensure_ascii=False)
+                except Exception:
+                    pass
+            else:
+                ans = v
+            if not ans:
+                ans = ""
+            kwargs[k] = ans
+            self.set_input_value(k, ans)
+
+        _kwargs = {}
+        for n, v in kwargs.items():
+            _n = re.sub("[@:.]", "_", n)
+            script = re.sub(r"\{%s\}" % re.escape(n), _n, script)
+            _kwargs[_n] = v
+        return script, _kwargs
+
+    def _stream(self, rand_cnt:str):
+        s = 0
+        all_content = ""
+        cache = {}
+        for r in re.finditer(self.variable_ref_patt, rand_cnt, flags=re.DOTALL):
+            all_content += rand_cnt[s: r.start()]
+            yield rand_cnt[s: r.start()]
+            s = r.end()
+            exp = r.group(1)
+            if exp in cache:
+                yield cache[exp]
+                all_content += cache[exp]
+                continue
+
+            v = self._canvas.get_variable_value(exp)
+            if not v:
+                v = ""
+            if isinstance(v, partial):
+                cnt = ""
+                for t in v():
+                    all_content += t
+                    cnt += t
+                    yield t
+
+                continue
+            elif not isinstance(v, str):
+                try:
+                    v = json.dumps(v, ensure_ascii=False, indent=2)
+                except Exception:
+                    v = str(v)
+            yield v
+            all_content += v
+            cache[exp] = v
+
+        if s < len(rand_cnt):
+            all_content += rand_cnt[s: ]
+            yield rand_cnt[s: ]
+
+        self.set_output("content", all_content)
+
+    def _is_jinjia2(self, content:str) -> bool:
+        patt = [
+            r"\{%.*%\}", "{{", "}}"
+        ]
+        return any([re.search(p, content) for p in patt])
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 10*60)))
+    def _invoke(self, **kwargs):
+        rand_cnt = random.choice(self._param.content)
+        if self._param.stream and not self._is_jinjia2(rand_cnt):
+            self.set_output("content", partial(self._stream, rand_cnt))
+            return
+
+        rand_cnt, kwargs = self.get_kwargs(rand_cnt, kwargs)
+        template = Jinja2Template(rand_cnt)
+        try:
+            content = template.render(kwargs)
+        except Exception:
+            pass
+
+        for n, v in kwargs.items():
+            content = re.sub(n, v, content)
+
+        self.set_output("content", content)
+
+    def thoughts(self) -> str:
+        return ""

agent/component/string_transform.py

@@ -0,0 +1,100 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import os
+import re
+from abc import ABC
+from jinja2 import Template as Jinja2Template
+from agent.component.base import ComponentParamBase
+from api.utils.api_utils import timeout
+from .message import Message
+
+
+class StringTransformParam(ComponentParamBase):
+    """
+    Define the code sandbox component parameters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.method = "split"
+        self.script = ""
+        self.split_ref = ""
+        self.delimiters = [","]
+        self.outputs = {"result": {"value": "", "type": "string"}}
+
+    def check(self):
+        self.check_valid_value(self.method, "Support method", ["split", "merge"])
+        self.check_empty(self.delimiters, "delimiters")
+
+
+class StringTransform(Message, ABC):
+    component_name = "StringTransform"
+
+    def get_input_form(self) -> dict[str, dict]:
+        if self._param.method == "split":
+            return {
+                "line": {
+                    "name": "String",
+                    "type": "line"
+                }
+            }
+        return {k: {
+            "name": o["name"],
+            "type": "line"
+        } for k, o in self.get_input_elements_from_text(self._param.script).items()}
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 10*60)))
+    def _invoke(self, **kwargs):
+        if self._param.method == "split":
+            self._split(kwargs.get("line"))
+        else:
+            self._merge(kwargs)
+
+    def _split(self, line:str|None = None):
+        var = self._canvas.get_variable_value(self._param.split_ref) if not line else line
+        if not var:
+            var = ""
+        assert isinstance(var, str), "The input variable is not a string: {}".format(type(var))
+        self.set_input_value(self._param.split_ref, var)
+        res = []
+        for i,s in enumerate(re.split(r"(%s)"%("|".join([re.escape(d) for d in self._param.delimiters])), var, flags=re.DOTALL)):
+            if i % 2 == 1:
+                continue
+            res.append(s)
+        self.set_output("result", res)
+
+    def _merge(self, kwargs:dict[str, str] = {}):
+        script = self._param.script
+        script, kwargs = self.get_kwargs(script, kwargs, self._param.delimiters[0])
+
+        if self._is_jinjia2(script):
+            template = Jinja2Template(script)
+            try:
+                script = template.render(kwargs)
+            except Exception:
+                pass
+
+        for k,v in kwargs.items():
+            if not v:
+                v = ""
+            script = re.sub(k, lambda match: v, script)
+
+        self.set_output("result", script)
+
+    def thoughts(self) -> str:
+        return f"It's {self._param.method}ing."
+
+

agent/component/switch.py

@@ -0,0 +1,131 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import numbers
+import os
+from abc import ABC
+from typing import Any
+
+from agent.component.base import ComponentBase, ComponentParamBase
+from api.utils.api_utils import timeout
+
+
+class SwitchParam(ComponentParamBase):
+    """
+    Define the Switch component parameters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        """
+        {
+            "logical_operator" : "and | or"
+            "items" : [
+                            {"cpn_id": "categorize:0", "operator": "contains", "value": ""},
+                            {"cpn_id": "categorize:0", "operator": "contains", "value": ""},...],
+            "to": ""
+        }
+        """
+        self.conditions = []
+        self.end_cpn_ids = []
+        self.operators = ['contains', 'not contains', 'start with', 'end with', 'empty', 'not empty', '=', '≠', '>',
+                          '<', '≥', '≤']
+
+    def check(self):
+        self.check_empty(self.conditions, "[Switch] conditions")
+        for cond in self.conditions:
+            if not cond["to"]:
+                raise ValueError("[Switch] 'To' can not be empty!")
+        self.check_empty(self.end_cpn_ids, "[Switch] the ELSE/Other destination can not be empty.")
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "urls": {
+                "name": "URLs",
+                "type": "line"
+            }
+        }
+
+class Switch(ComponentBase, ABC):
+    component_name = "Switch"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 3)))
+    def _invoke(self, **kwargs):
+        for cond in self._param.conditions:
+            res = []
+            for item in cond["items"]:
+                if not item["cpn_id"]:
+                    continue
+                cpn_v = self._canvas.get_variable_value(item["cpn_id"])
+                self.set_input_value(item["cpn_id"], cpn_v)
+                operatee = item.get("value", "")
+                if isinstance(cpn_v, numbers.Number):
+                    operatee = float(operatee)
+                res.append(self.process_operator(cpn_v, item["operator"], operatee))
+                if cond["logical_operator"] != "and" and any(res):
+                    self.set_output("next", [self._canvas.get_component_name(cpn_id) for cpn_id in cond["to"]])
+                    self.set_output("_next", cond["to"])
+                    return
+
+            if all(res):
+                self.set_output("next", [self._canvas.get_component_name(cpn_id) for cpn_id in cond["to"]])
+                self.set_output("_next", cond["to"])
+                return
+
+        self.set_output("next", [self._canvas.get_component_name(cpn_id) for cpn_id in self._param.end_cpn_ids])
+        self.set_output("_next", self._param.end_cpn_ids)
+
+    def process_operator(self, input: Any, operator: str, value: Any) -> bool:
+        if operator == "contains":
+            return True if value.lower() in input.lower() else False
+        elif operator == "not contains":
+            return True if value.lower() not in input.lower() else False
+        elif operator == "start with":
+            return True if input.lower().startswith(value.lower()) else False
+        elif operator == "end with":
+            return True if input.lower().endswith(value.lower()) else False
+        elif operator == "empty":
+            return True if not input else False
+        elif operator == "not empty":
+            return True if input else False
+        elif operator == "=":
+            return True if input == value else False
+        elif operator == "≠":
+            return True if input != value else False
+        elif operator == ">":
+            try:
+                return True if float(input) > float(value) else False
+            except Exception:
+                return True if input > value else False
+        elif operator == "<":
+            try:
+                return True if float(input) < float(value) else False
+            except Exception:
+                return True if input < value else False
+        elif operator == "≥":
+            try:
+                return True if float(input) >= float(value) else False
+            except Exception:
+                return True if input >= value else False
+        elif operator == "≤":
+            try:
+                return True if float(input) <= float(value) else False
+            except Exception:
+                return True if input <= value else False
+
+        raise ValueError('Not supported operator' + operator)
+
+    def thoughts(self) -> str:
+        return "I’m weighing a few options and will pick the next step shortly."

agent/settings.py

@@ -0,0 +1,18 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+FLOAT_ZERO = 1e-8
+PARAM_MAXDEPTH = 5

agent/templates/generate_SEO_blog.json

@@ -0,0 +1,906 @@
+{
+    "id": 8,
+    "title": {
+        "en": "Generate SEO Blog",
+        "zh": "生成SEO博客"},
+    "description": {
+        "en": "This is a multi-agent version of the SEO blog generation workflow. It simulates a small team of AI “writers”, where each agent plays a specialized role — just like a real editorial team.",
+        "zh": "多智能体架构可根据简单的用户输入自动生成完整的SEO博客文章。模拟小型“作家”团队，其中每个智能体扮演一个专业角色——就像真正的编辑团队。"},
+    "canvas_type": "Agent",
+    "dsl": {
+            "components": {
+                "Agent:LuckyApplesGrab": {
+                    "downstream": [
+                        "Message:ModernSwansThrow"
+                    ],
+                    "obj": {
+                        "component_name": "Agent",
+                        "params": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_comment": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": null,
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.5,
+                            "llm_id": "deepseek-chat@DeepSeek",
+                            "maxTokensEnabled": false,
+                            "max_retries": 3,
+                            "max_rounds": 3,
+                            "max_tokens": 4096,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "parameter": "Precise",
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.5,
+                            "prompts": [
+                                {
+                                    "content": "The user query is {sys.query}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "# Role\n\nYou are the **Lead Agent**, responsible for initiating the multi-agent SEO blog generation process. You will receive the user\u2019s topic and blog goal, interpret the intent, and coordinate the downstream writing agents.\n\n# Goals\n\n1. Parse the user's initial input.\n\n2. Generate a high-level blog intent summary and writing plan.\n\n3. Provide clear instructions to the following Sub_Agents:\n\n   - `Outline Agent` \u2192 Create the blog outline.\n\n   - `Body Agent` \u2192 Write all sections based on outline.\n\n   - `Editor Agent` \u2192 Polish and finalize the blog post.\n\n4. Merge outputs into a complete, readable blog draft in Markdown format.\n\n# Input\n\nYou will receive:\n\n- Blog topic\n\n- Target audience\n\n- Blog goal (e.g., SEO, education, product marketing)\n\n# Output Format\n\n```markdown\n\n## Parsed Writing Plan\n\n- **Topic**: [Extracted from user input]\n\n- **Audience**: [Summarized from user input]\n\n- **Intent**: [Inferred goal and style]\n\n- **Blog Type**: [e.g., Tutorial / Informative Guide / Marketing Content]\n\n- **Long-tail Keywords**: \n\n  - keyword 1\n\n  - keyword 2\n\n  - keyword 3\n\n  - ...\n\n## Instructions for Outline Agent\n\nPlease generate a structured outline including H2 and H3 headings. Assign 1\u20132 relevant keywords to each section. Keep it aligned with the user\u2019s intent and audience level.\n\n## Instructions for Body Agent\n\nWrite the full content based on the outline. Each section should be concise (500\u2013600 words), informative, and optimized for SEO. Use `Tavily Search` only when additional examples or context are needed.\n\n## Instructions for Editor Agent\n\nReview and refine the combined content. Improve transitions, ensure keyword integration, and add a meta title + meta description. Maintain Markdown formatting.\n\n\n## Guides\n\n- Do not generate blog content directly.\n\n- Focus on correct intent recognition and instruction generation.\n\n- Keep communication to downstream agents simple, scoped, and accurate.\n\n\n## Input Examples (and how to handle them)\n\nInput: \"I want to write about RAGFlow.\"\n\u2192 Output: Informative Guide, Audience: AI developers, Intent: explain what RAGFlow is and its use cases\n\nInput: \"Need a blog to promote our prompt design tool.\"\n\u2192 Output: Marketing Content, Audience: product managers or tool adopters, Intent: raise awareness and interest in the product\n\nInput: \"How to get more Google traffic using AI\"\n\u2192 Output: How-to, Audience: SEO marketers, Intent: guide readers on applying AI for SEO growth",
+                            "temperature": "0.1",
+                            "temperatureEnabled": true,
+                            "tools": [
+                                {
+                                    "component_name": "Agent",
+                                    "id": "Agent:SlickSpidersTurn",
+                                    "name": "Outline Agent",
+                                    "params": {
+                                        "delay_after_error": 1,
+                                        "description": "Generates a clear and SEO-friendly blog outline using H2/H3 headings based on the topic, audience, and intent provided by the lead agent. Each section includes suggested keywords for optimized downstream writing.\n",
+                                        "exception_comment": "",
+                                        "exception_default_value": "",
+                                        "exception_goto": [],
+                                        "exception_method": null,
+                                        "frequencyPenaltyEnabled": false,
+                                        "frequency_penalty": 0.3,
+                                        "llm_id": "deepseek-chat@DeepSeek",
+                                        "maxTokensEnabled": false,
+                                        "max_retries": 3,
+                                        "max_rounds": 2,
+                                        "max_tokens": 4096,
+                                        "mcp": [],
+                                        "message_history_window_size": 12,
+                                        "outputs": {
+                                            "content": {
+                                                "type": "string",
+                                                "value": ""
+                                            }
+                                        },
+                                        "parameter": "Balance",
+                                        "presencePenaltyEnabled": false,
+                                        "presence_penalty": 0.2,
+                                        "prompts": [
+                                            {
+                                                "content": "{sys.query}",
+                                                "role": "user"
+                                            }
+                                        ],
+                                        "sys_prompt": "# Role\n\nYou are the **Outline Agent**, a sub-agent in a multi-agent SEO blog writing system. You operate under the instruction of the `Lead Agent`, and your sole responsibility is to create a clear, well-structured, and SEO-optimized blog outline.\n\n# Tool Access:\n\n- You have access to a search tool called `Tavily Search`.\n\n- If you are unsure how to structure a section, you may call this tool to search for related blog outlines or content from Google.\n\n- Do not overuse it. Your job is to extract **structure**, not to write paragraphs.\n\n\n# Goals\n\n1. Create a well-structured outline with appropriate H2 and H3 headings.\n\n2. Ensure logical flow from introduction to conclusion.\n\n3. Assign 1\u20132 suggested long-tail keywords to each major section for SEO alignment.\n\n4. Make the structure suitable for downstream paragraph writing.\n\n\n\n\n#Note\n\n- Use concise, scannable section titles.\n\n- Do not write full paragraphs.\n\n- Prioritize clarity, logical progression, and SEO alignment.\n\n\n\n- If the blog type is \u201cTutorial\u201d or \u201cHow-to\u201d, include step-based sections.\n\n\n# Input\n\nYou will receive:\n\n- Writing Type (e.g., Tutorial, Informative Guide)\n\n- Target Audience\n\n- User Intent Summary\n\n- 3\u20135 long-tail keywords\n\n\nUse this information to design a structure that both informs readers and maximizes search engine visibility.\n\n# Output Format\n\n```markdown\n\n## Blog Title (suggested)\n\n[Give a short, SEO-friendly title suggestion]\n\n## Outline\n\n### Introduction\n\n- Purpose of the article\n\n- Brief context\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 1]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 2]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 3]\n\n- [Optional H3 Subsection Title A]\n\n  - [Explanation of sub-point]\n\n- [Optional H3 Subsection Title B]\n\n  - [Explanation of sub-point]\n\n- **Suggested keywords**: [keyword1]\n\n### Conclusion\n\n- Recap key takeaways\n\n- Optional CTA (Call to Action)\n\n- **Suggested keywords**: [keyword3]\n\n",
+                                        "temperature": 0.5,
+                                        "temperatureEnabled": true,
+                                        "tools": [
+                                            {
+                                                "component_name": "TavilySearch",
+                                                "name": "TavilySearch",
+                                                "params": {
+                                                    "api_key": "",
+                                                    "days": 7,
+                                                    "exclude_domains": [],
+                                                    "include_answer": false,
+                                                    "include_domains": [],
+                                                    "include_image_descriptions": false,
+                                                    "include_images": false,
+                                                    "include_raw_content": true,
+                                                    "max_results": 5,
+                                                    "outputs": {
+                                                        "formalized_content": {
+                                                            "type": "string",
+                                                            "value": ""
+                                                        },
+                                                        "json": {
+                                                            "type": "Array<Object>",
+                                                            "value": []
+                                                        }
+                                                    },
+                                                    "query": "sys.query",
+                                                    "search_depth": "basic",
+                                                    "topic": "general"
+                                                }
+                                            }
+                                        ],
+                                        "topPEnabled": false,
+                                        "top_p": 0.85,
+                                        "user_prompt": "This is the order you need to send to the agent.",
+                                        "visual_files_var": ""
+                                    }
+                                },
+                                {
+                                    "component_name": "Agent",
+                                    "id": "Agent:IcyPawsRescue",
+                                    "name": "Body Agent",
+                                    "params": {
+                                        "delay_after_error": 1,
+                                        "description": "Writes the full blog content section-by-section following the outline structure. It integrates target keywords naturally and uses Tavily Search only when additional facts or examples are needed.\n",
+                                        "exception_comment": "",
+                                        "exception_default_value": "",
+                                        "exception_goto": [],
+                                        "exception_method": null,
+                                        "frequencyPenaltyEnabled": false,
+                                        "frequency_penalty": 0.5,
+                                        "llm_id": "deepseek-chat@DeepSeek",
+                                        "maxTokensEnabled": false,
+                                        "max_retries": 3,
+                                        "max_rounds": 3,
+                                        "max_tokens": 4096,
+                                        "mcp": [],
+                                        "message_history_window_size": 12,
+                                        "outputs": {
+                                            "content": {
+                                                "type": "string",
+                                                "value": ""
+                                            }
+                                        },
+                                        "parameter": "Precise",
+                                        "presencePenaltyEnabled": false,
+                                        "presence_penalty": 0.5,
+                                        "prompts": [
+                                            {
+                                                "content": "{sys.query}",
+                                                "role": "user"
+                                            }
+                                        ],
+                                        "sys_prompt": "# Role\n\nYou are the **Body Agent**, a sub-agent in a multi-agent SEO blog writing system. You operate under the instruction of the `Lead Agent`, and your job is to write the full blog content based on the outline created by the `OutlineWriter_Agent`.\n\n\n\n# Tool Access:\n\nYou can use the `Tavily Search` tool to retrieve relevant content, statistics, or examples to support each section you're writing.\n\nUse it **only** when the provided outline lacks enough information, or if the section requires factual grounding.\n\nAlways cite the original link or indicate source where possible.\n\n\n# Goals\n\n1. Write each section (based on H2/H3 structure) as a complete and natural blog paragraph.\n\n2. Integrate the suggested long-tail keywords naturally into each section.\n\n3. When appropriate, use the `Tavily Search` tool to enrich your writing with relevant facts, examples, or quotes.\n\n4. Ensure each section is clear, engaging, and informative, suitable for both human readers and search engines.\n\n\n# Style Guidelines\n\n- Write in a tone appropriate to the audience. Be explanatory, not promotional, unless it's a marketing blog.\n\n- Avoid generic filler content. Prioritize clarity, structure, and value.\n\n- Ensure SEO keywords are embedded seamlessly, not forcefully.\n\n\n\n- Maintain writing rhythm. Vary sentence lengths. Use transitions between ideas.\n\n\n# Input\n\n\nYou will receive:\n\n- Blog title\n\n- Structured outline (including section titles, keywords, and descriptions)\n\n- Target audience\n\n- Blog type and user intent\n\nYou must **follow the outline strictly**. Write content **section-by-section**, based on the structure.\n\n\n# Output Format\n\n```markdown\n\n## H2: [Section Title]\n\n[Your generated content for this section \u2014 500-600 words, using keywords naturally.]\n\n",
+                                        "temperature": 0.2,
+                                        "temperatureEnabled": true,
+                                        "tools": [
+                                            {
+                                                "component_name": "TavilySearch",
+                                                "name": "TavilySearch",
+                                                "params": {
+                                                    "api_key": "",
+                                                    "days": 7,
+                                                    "exclude_domains": [],
+                                                    "include_answer": false,
+                                                    "include_domains": [],
+                                                    "include_image_descriptions": false,
+                                                    "include_images": false,
+                                                    "include_raw_content": true,
+                                                    "max_results": 5,
+                                                    "outputs": {
+                                                        "formalized_content": {
+                                                            "type": "string",
+                                                            "value": ""
+                                                        },
+                                                        "json": {
+                                                            "type": "Array<Object>",
+                                                            "value": []
+                                                        }
+                                                    },
+                                                    "query": "sys.query",
+                                                    "search_depth": "basic",
+                                                    "topic": "general"
+                                                }
+                                            }
+                                        ],
+                                        "topPEnabled": false,
+                                        "top_p": 0.75,
+                                        "user_prompt": "This is the order you need to send to the agent.",
+                                        "visual_files_var": ""
+                                    }
+                                },
+                                {
+                                    "component_name": "Agent",
+                                    "id": "Agent:TenderAdsAllow",
+                                    "name": "Editor Agent",
+                                    "params": {
+                                        "delay_after_error": 1,
+                                        "description": "Polishes and finalizes the entire blog post. Enhances clarity, checks keyword usage, improves flow, and generates a meta title and description for SEO. Operates after all sections are completed.\n\n",
+                                        "exception_comment": "",
+                                        "exception_default_value": "",
+                                        "exception_goto": [],
+                                        "exception_method": null,
+                                        "frequencyPenaltyEnabled": false,
+                                        "frequency_penalty": 0.5,
+                                        "llm_id": "deepseek-chat@DeepSeek",
+                                        "maxTokensEnabled": false,
+                                        "max_retries": 3,
+                                        "max_rounds": 2,
+                                        "max_tokens": 4096,
+                                        "mcp": [],
+                                        "message_history_window_size": 12,
+                                        "outputs": {
+                                            "content": {
+                                                "type": "string",
+                                                "value": ""
+                                            }
+                                        },
+                                        "parameter": "Precise",
+                                        "presencePenaltyEnabled": false,
+                                        "presence_penalty": 0.5,
+                                        "prompts": [
+                                            {
+                                                "content": "{sys.query}",
+                                                "role": "user"
+                                            }
+                                        ],
+                                        "sys_prompt": "# Role\n\nYou are the **Editor Agent**, the final agent in a multi-agent SEO blog writing workflow. You are responsible for finalizing the blog post for both human readability and SEO effectiveness.\n\n# Goals\n\n1. Polish the entire blog content for clarity, coherence, and style.\n\n2. Improve transitions between sections, ensure logical flow.\n\n3. Verify that keywords are used appropriately and effectively.\n\n4. Conduct a lightweight SEO audit \u2014 checking keyword density, structure (H1/H2/H3), and overall searchability.\n\n\n\n## Integration Responsibilities\n\n- Maintain alignment with Lead Agent's original intent and audience\n\n- Preserve the structure and keyword strategy from Outline Agent\n\n- Enhance and polish Body Agent's content without altering core information\n\n# Style Guidelines\n\n- Be precise. Avoid bloated or vague language.\n\n- Maintain an informative and engaging tone, suitable to the target audience.\n\n- Do not remove keywords unless absolutely necessary for clarity.\n\n- Ensure paragraph flow and section continuity.\n\n\n\n# Input\n\nYou will receive:\n\n- Full blog content, written section-by-section\n\n- Original outline with suggested keywords\n\n- Target audience and writing type\n\n# Output Format\n\n```markdown\n\n[The revised, fully polished blog post content goes here.]\n",
+                                        "temperature": 0.2,
+                                        "temperatureEnabled": true,
+                                        "tools": [],
+                                        "topPEnabled": false,
+                                        "top_p": 0.75,
+                                        "user_prompt": "This is the order you need to send to the agent.",
+                                        "visual_files_var": ""
+                                    }
+                                }
+                            ],
+                            "topPEnabled": false,
+                            "top_p": 0.75,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        }
+                    },
+                    "upstream": [
+                        "begin"
+                    ]
+                },
+                "Message:ModernSwansThrow": {
+                    "downstream": [],
+                    "obj": {
+                        "component_name": "Message",
+                        "params": {
+                            "content": [
+                                "{Agent:LuckyApplesGrab@content}"
+                            ]
+                        }
+                    },
+                    "upstream": [
+                        "Agent:LuckyApplesGrab"
+                    ]
+                },
+                "begin": {
+                    "downstream": [
+                        "Agent:LuckyApplesGrab"
+                    ],
+                    "obj": {
+                        "component_name": "Begin",
+                        "params": {
+                            "enablePrologue": true,
+                            "inputs": {},
+                            "mode": "conversational",
+                            "prologue": "Hi! I'm your SEO blog assistant.\n\nTo get started, please tell me:\n1. What topic you want the blog to cover\n2. Who is the target audience\n3. What you hope to achieve with this blog (e.g., SEO traffic, teaching beginners, promoting a product)\n"
+                        }
+                    },
+                    "upstream": []
+                }
+            },
+            "globals": {
+                "sys.conversation_turns": 0,
+                "sys.files": [],
+                "sys.query": "",
+                "sys.user_id": ""
+            },
+            "graph": {
+                "edges": [
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__beginstart-Agent:LuckyApplesGrabend",
+                        "source": "begin",
+                        "sourceHandle": "start",
+                        "target": "Agent:LuckyApplesGrab",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:LuckyApplesGrabstart-Message:ModernSwansThrowend",
+                        "source": "Agent:LuckyApplesGrab",
+                        "sourceHandle": "start",
+                        "target": "Message:ModernSwansThrow",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:LuckyApplesGrabagentBottom-Agent:SlickSpidersTurnagentTop",
+                        "source": "Agent:LuckyApplesGrab",
+                        "sourceHandle": "agentBottom",
+                        "target": "Agent:SlickSpidersTurn",
+                        "targetHandle": "agentTop"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:LuckyApplesGrabagentBottom-Agent:IcyPawsRescueagentTop",
+                        "source": "Agent:LuckyApplesGrab",
+                        "sourceHandle": "agentBottom",
+                        "target": "Agent:IcyPawsRescue",
+                        "targetHandle": "agentTop"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:LuckyApplesGrabagentBottom-Agent:TenderAdsAllowagentTop",
+                        "source": "Agent:LuckyApplesGrab",
+                        "sourceHandle": "agentBottom",
+                        "target": "Agent:TenderAdsAllow",
+                        "targetHandle": "agentTop"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:SlickSpidersTurntool-Tool:ThreeWallsRingend",
+                        "source": "Agent:SlickSpidersTurn",
+                        "sourceHandle": "tool",
+                        "target": "Tool:ThreeWallsRing",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:IcyPawsRescuetool-Tool:FloppyJokesItchend",
+                        "source": "Agent:IcyPawsRescue",
+                        "sourceHandle": "tool",
+                        "target": "Tool:FloppyJokesItch",
+                        "targetHandle": "end"
+                    }
+                ],
+                "nodes": [
+                    {
+                        "data": {
+                            "form": {
+                                "enablePrologue": true,
+                                "inputs": {},
+                                "mode": "conversational",
+                                "prologue": "Hi! I'm your SEO blog assistant.\n\nTo get started, please tell me:\n1. What topic you want the blog to cover\n2. Who is the target audience\n3. What you hope to achieve with this blog (e.g., SEO traffic, teaching beginners, promoting a product)\n"
+                            },
+                            "label": "Begin",
+                            "name": "begin"
+                        },
+                        "dragging": false,
+                        "id": "begin",
+                        "measured": {
+                            "height": 48,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 38.19445084117184,
+                            "y": 183.9781832844475
+                        },
+                        "selected": false,
+                        "sourcePosition": "left",
+                        "targetPosition": "right",
+                        "type": "beginNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.5,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 3,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Precise",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.5,
+                                "prompts": [
+                                    {
+                                        "content": "The user query is {sys.query}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Lead Agent**, responsible for initiating the multi-agent SEO blog generation process. You will receive the user\u2019s topic and blog goal, interpret the intent, and coordinate the downstream writing agents.\n\n# Goals\n\n1. Parse the user's initial input.\n\n2. Generate a high-level blog intent summary and writing plan.\n\n3. Provide clear instructions to the following Sub_Agents:\n\n   - `Outline Agent` \u2192 Create the blog outline.\n\n   - `Body Agent` \u2192 Write all sections based on outline.\n\n   - `Editor Agent` \u2192 Polish and finalize the blog post.\n\n4. Merge outputs into a complete, readable blog draft in Markdown format.\n\n# Input\n\nYou will receive:\n\n- Blog topic\n\n- Target audience\n\n- Blog goal (e.g., SEO, education, product marketing)\n\n# Output Format\n\n```markdown\n\n## Parsed Writing Plan\n\n- **Topic**: [Extracted from user input]\n\n- **Audience**: [Summarized from user input]\n\n- **Intent**: [Inferred goal and style]\n\n- **Blog Type**: [e.g., Tutorial / Informative Guide / Marketing Content]\n\n- **Long-tail Keywords**: \n\n  - keyword 1\n\n  - keyword 2\n\n  - keyword 3\n\n  - ...\n\n## Instructions for Outline Agent\n\nPlease generate a structured outline including H2 and H3 headings. Assign 1\u20132 relevant keywords to each section. Keep it aligned with the user\u2019s intent and audience level.\n\n## Instructions for Body Agent\n\nWrite the full content based on the outline. Each section should be concise (500\u2013600 words), informative, and optimized for SEO. Use `Tavily Search` only when additional examples or context are needed.\n\n## Instructions for Editor Agent\n\nReview and refine the combined content. Improve transitions, ensure keyword integration, and add a meta title + meta description. Maintain Markdown formatting.\n\n\n## Guides\n\n- Do not generate blog content directly.\n\n- Focus on correct intent recognition and instruction generation.\n\n- Keep communication to downstream agents simple, scoped, and accurate.\n\n\n## Input Examples (and how to handle them)\n\nInput: \"I want to write about RAGFlow.\"\n\u2192 Output: Informative Guide, Audience: AI developers, Intent: explain what RAGFlow is and its use cases\n\nInput: \"Need a blog to promote our prompt design tool.\"\n\u2192 Output: Marketing Content, Audience: product managers or tool adopters, Intent: raise awareness and interest in the product\n\nInput: \"How to get more Google traffic using AI\"\n\u2192 Output: How-to, Audience: SEO marketers, Intent: guide readers on applying AI for SEO growth",
+                                "temperature": "0.1",
+                                "temperatureEnabled": true,
+                                "tools": [],
+                                "topPEnabled": false,
+                                "top_p": 0.75,
+                                "user_prompt": "",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Lead Agent"
+                        },
+                        "id": "Agent:LuckyApplesGrab",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 350,
+                            "y": 200
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "content": [
+                                    "{Agent:LuckyApplesGrab@content}"
+                                ]
+                            },
+                            "label": "Message",
+                            "name": "Response"
+                        },
+                        "dragging": false,
+                        "id": "Message:ModernSwansThrow",
+                        "measured": {
+                            "height": 56,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 669.394830760932,
+                            "y": 190.72421137520644
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "messageNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "Generates a clear and SEO-friendly blog outline using H2/H3 headings based on the topic, audience, and intent provided by the lead agent. Each section includes suggested keywords for optimized downstream writing.\n",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.3,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 2,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Balance",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.2,
+                                "prompts": [
+                                    {
+                                        "content": "{sys.query}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Outline Agent**, a sub-agent in a multi-agent SEO blog writing system. You operate under the instruction of the `Lead Agent`, and your sole responsibility is to create a clear, well-structured, and SEO-optimized blog outline.\n\n# Tool Access:\n\n- You have access to a search tool called `Tavily Search`.\n\n- If you are unsure how to structure a section, you may call this tool to search for related blog outlines or content from Google.\n\n- Do not overuse it. Your job is to extract **structure**, not to write paragraphs.\n\n\n# Goals\n\n1. Create a well-structured outline with appropriate H2 and H3 headings.\n\n2. Ensure logical flow from introduction to conclusion.\n\n3. Assign 1\u20132 suggested long-tail keywords to each major section for SEO alignment.\n\n4. Make the structure suitable for downstream paragraph writing.\n\n\n\n\n#Note\n\n- Use concise, scannable section titles.\n\n- Do not write full paragraphs.\n\n- Prioritize clarity, logical progression, and SEO alignment.\n\n\n\n- If the blog type is \u201cTutorial\u201d or \u201cHow-to\u201d, include step-based sections.\n\n\n# Input\n\nYou will receive:\n\n- Writing Type (e.g., Tutorial, Informative Guide)\n\n- Target Audience\n\n- User Intent Summary\n\n- 3\u20135 long-tail keywords\n\n\nUse this information to design a structure that both informs readers and maximizes search engine visibility.\n\n# Output Format\n\n```markdown\n\n## Blog Title (suggested)\n\n[Give a short, SEO-friendly title suggestion]\n\n## Outline\n\n### Introduction\n\n- Purpose of the article\n\n- Brief context\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 1]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 2]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 3]\n\n- [Optional H3 Subsection Title A]\n\n  - [Explanation of sub-point]\n\n- [Optional H3 Subsection Title B]\n\n  - [Explanation of sub-point]\n\n- **Suggested keywords**: [keyword1]\n\n### Conclusion\n\n- Recap key takeaways\n\n- Optional CTA (Call to Action)\n\n- **Suggested keywords**: [keyword3]\n\n",
+                                "temperature": 0.5,
+                                "temperatureEnabled": true,
+                                "tools": [
+                                    {
+                                        "component_name": "TavilySearch",
+                                        "name": "TavilySearch",
+                                        "params": {
+                                            "api_key": "",
+                                            "days": 7,
+                                            "exclude_domains": [],
+                                            "include_answer": false,
+                                            "include_domains": [],
+                                            "include_image_descriptions": false,
+                                            "include_images": false,
+                                            "include_raw_content": true,
+                                            "max_results": 5,
+                                            "outputs": {
+                                                "formalized_content": {
+                                                    "type": "string",
+                                                    "value": ""
+                                                },
+                                                "json": {
+                                                    "type": "Array<Object>",
+                                                    "value": []
+                                                }
+                                            },
+                                            "query": "sys.query",
+                                            "search_depth": "basic",
+                                            "topic": "general"
+                                        }
+                                    }
+                                ],
+                                "topPEnabled": false,
+                                "top_p": 0.85,
+                                "user_prompt": "This is the order you need to send to the agent.",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Outline Agent"
+                        },
+                        "dragging": false,
+                        "id": "Agent:SlickSpidersTurn",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 100.60137004146719,
+                            "y": 411.67654846431367
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "Writes the full blog content section-by-section following the outline structure. It integrates target keywords naturally and uses Tavily Search only when additional facts or examples are needed.\n",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.5,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 3,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Precise",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.5,
+                                "prompts": [
+                                    {
+                                        "content": "{sys.query}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Body Agent**, a sub-agent in a multi-agent SEO blog writing system. You operate under the instruction of the `Lead Agent`, and your job is to write the full blog content based on the outline created by the `OutlineWriter_Agent`.\n\n\n\n# Tool Access:\n\nYou can use the `Tavily Search` tool to retrieve relevant content, statistics, or examples to support each section you're writing.\n\nUse it **only** when the provided outline lacks enough information, or if the section requires factual grounding.\n\nAlways cite the original link or indicate source where possible.\n\n\n# Goals\n\n1. Write each section (based on H2/H3 structure) as a complete and natural blog paragraph.\n\n2. Integrate the suggested long-tail keywords naturally into each section.\n\n3. When appropriate, use the `Tavily Search` tool to enrich your writing with relevant facts, examples, or quotes.\n\n4. Ensure each section is clear, engaging, and informative, suitable for both human readers and search engines.\n\n\n# Style Guidelines\n\n- Write in a tone appropriate to the audience. Be explanatory, not promotional, unless it's a marketing blog.\n\n- Avoid generic filler content. Prioritize clarity, structure, and value.\n\n- Ensure SEO keywords are embedded seamlessly, not forcefully.\n\n\n\n- Maintain writing rhythm. Vary sentence lengths. Use transitions between ideas.\n\n\n# Input\n\n\nYou will receive:\n\n- Blog title\n\n- Structured outline (including section titles, keywords, and descriptions)\n\n- Target audience\n\n- Blog type and user intent\n\nYou must **follow the outline strictly**. Write content **section-by-section**, based on the structure.\n\n\n# Output Format\n\n```markdown\n\n## H2: [Section Title]\n\n[Your generated content for this section \u2014 500-600 words, using keywords naturally.]\n\n",
+                                "temperature": 0.2,
+                                "temperatureEnabled": true,
+                                "tools": [
+                                    {
+                                        "component_name": "TavilySearch",
+                                        "name": "TavilySearch",
+                                        "params": {
+                                            "api_key": "",
+                                            "days": 7,
+                                            "exclude_domains": [],
+                                            "include_answer": false,
+                                            "include_domains": [],
+                                            "include_image_descriptions": false,
+                                            "include_images": false,
+                                            "include_raw_content": true,
+                                            "max_results": 5,
+                                            "outputs": {
+                                                "formalized_content": {
+                                                    "type": "string",
+                                                    "value": ""
+                                                },
+                                                "json": {
+                                                    "type": "Array<Object>",
+                                                    "value": []
+                                                }
+                                            },
+                                            "query": "sys.query",
+                                            "search_depth": "basic",
+                                            "topic": "general"
+                                        }
+                                    }
+                                ],
+                                "topPEnabled": false,
+                                "top_p": 0.75,
+                                "user_prompt": "This is the order you need to send to the agent.",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Body Agent"
+                        },
+                        "dragging": false,
+                        "id": "Agent:IcyPawsRescue",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 439.3374395738501,
+                            "y": 366.1408588516909
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "Polishes and finalizes the entire blog post. Enhances clarity, checks keyword usage, improves flow, and generates a meta title and description for SEO. Operates after all sections are completed.\n\n",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.5,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 2,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Precise",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.5,
+                                "prompts": [
+                                    {
+                                        "content": "{sys.query}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Editor Agent**, the final agent in a multi-agent SEO blog writing workflow. You are responsible for finalizing the blog post for both human readability and SEO effectiveness.\n\n# Goals\n\n1. Polish the entire blog content for clarity, coherence, and style.\n\n2. Improve transitions between sections, ensure logical flow.\n\n3. Verify that keywords are used appropriately and effectively.\n\n4. Conduct a lightweight SEO audit \u2014 checking keyword density, structure (H1/H2/H3), and overall searchability.\n\n\n\n## Integration Responsibilities\n\n- Maintain alignment with Lead Agent's original intent and audience\n\n- Preserve the structure and keyword strategy from Outline Agent\n\n- Enhance and polish Body Agent's content without altering core information\n\n# Style Guidelines\n\n- Be precise. Avoid bloated or vague language.\n\n- Maintain an informative and engaging tone, suitable to the target audience.\n\n- Do not remove keywords unless absolutely necessary for clarity.\n\n- Ensure paragraph flow and section continuity.\n\n\n\n# Input\n\nYou will receive:\n\n- Full blog content, written section-by-section\n\n- Original outline with suggested keywords\n\n- Target audience and writing type\n\n# Output Format\n\n```markdown\n\n[The revised, fully polished blog post content goes here.]\n",
+                                "temperature": 0.2,
+                                "temperatureEnabled": true,
+                                "tools": [],
+                                "topPEnabled": false,
+                                "top_p": 0.75,
+                                "user_prompt": "This is the order you need to send to the agent.",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Editor Agent"
+                        },
+                        "dragging": false,
+                        "id": "Agent:TenderAdsAllow",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 730.8513124709204,
+                            "y": 327.351197329827
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "description": "This is an agent for a specific task.",
+                                "user_prompt": "This is the order you need to send to the agent."
+                            },
+                            "label": "Tool",
+                            "name": "flow.tool_0"
+                        },
+                        "dragging": false,
+                        "id": "Tool:ThreeWallsRing",
+                        "measured": {
+                            "height": 48,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": -26.93431957115564,
+                            "y": 531.4384641920368
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "toolNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "description": "This is an agent for a specific task.",
+                                "user_prompt": "This is the order you need to send to the agent."
+                            },
+                            "label": "Tool",
+                            "name": "flow.tool_1"
+                        },
+                        "dragging": false,
+                        "id": "Tool:FloppyJokesItch",
+                        "measured": {
+                            "height": 48,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 414.6786783453011,
+                            "y": 499.39483076093194
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "toolNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "This is a multi-agent version of the SEO blog generation workflow. It simulates a small team of AI \u201cwriters\u201d, where each agent plays a specialized role \u2014 just like a real editorial team.\n\nInstead of one AI doing everything in order, this version uses a **Lead Agent** to assign tasks to different sub-agents, who then write and edit the blog in parallel. The Lead Agent manages everything and produces the final output.\n\n### Why use multi-agent format?\n\n- Better control over each stage of writing  \n- Easier to reuse agents across tasks  \n- More human-like workflow (planning \u2192 writing \u2192 editing \u2192 publishing)  \n- Easier to scale and customize for advanced users\n\n### Flow Summary:\n\n1. `LeadWriter_Agent` takes your input and creates a plan\n2. It sends that plan to:\n   - `OutlineWriter_Agent`: build blog structure\n   - `BodyWriter_Agent`: write full content\n   - `FinalEditor_Agent`: polish and finalize\n3. `LeadWriter_Agent` collects all results and outputs the final blog post\n"
+                            },
+                            "label": "Note",
+                            "name": "Workflow Overall Description"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 208,
+                        "id": "Note:ElevenVansInvent",
+                        "measured": {
+                            "height": 208,
+                            "width": 518
+                        },
+                        "position": {
+                            "x": -336.6586460874556,
+                            "y": 113.43253511344867
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 518
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis is the central agent that controls the entire writing process.\n\n**What it does**:\n- Reads your blog topic and intent\n- Generates a clear writing plan (topic, audience, goal, keywords)\n- Sends instructions to all sub-agents\n- Waits for their responses and checks quality\n- If any section is missing or weak, it can request a rewrite\n- Finally, it assembles all parts into a complete blog and sends it back to you\n"
+                            },
+                            "label": "Note",
+                            "name": "Lead Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 146,
+                        "id": "Note:EmptyClubsGreet",
+                        "measured": {
+                            "height": 146,
+                            "width": 334
+                        },
+                        "position": {
+                            "x": 390.1408623279084,
+                            "y": 2.6521144030202493
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 334
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis agent is responsible for building the blog's structure. It creates an outline that shows what the article will cover and how it's organized.\n\n**What it does**:\n- Suggests a blog title that matches the topic and keywords  \n- Breaks the article into sections using H2 and H3 headers  \n- Adds a short description of what each section should include  \n- Assigns SEO keywords to each section for better search visibility  \n- Uses search data (via Tavily Search) to find how similar blogs are structured"
+                            },
+                            "label": "Note",
+                            "name": "Outline Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 157,
+                        "id": "Note:CurlyTigersDouble",
+                        "measured": {
+                            "height": 157,
+                            "width": 394
+                        },
+                        "position": {
+                            "x": -60.03139680691618,
+                            "y": 595.8208080534818
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 394
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis agent is in charge of writing the full blog content, section by section, based on the outline it receives.\n\n**What it does**:\n- Takes each section heading from the outline (H2 / H3)\n- Writes a complete paragraph (150\u2013220 words) under each section\n- Naturally includes the keywords provided for that section\n- Uses the Tavily Search tool to add real-world examples, definitions, or facts if needed\n- Makes sure each section is clear, useful, and easy to read\n"
+                            },
+                            "label": "Note",
+                            "name": "Body Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 164,
+                        "id": "Note:StrongKingsCamp",
+                        "measured": {
+                            "height": 164,
+                            "width": 408
+                        },
+                        "position": {
+                            "x": 446.54943226110845,
+                            "y": 590.9443887062529
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 408
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis agent reviews, polishes, and finalizes the blog post written by the BodyWriter_Agent. It ensures everything is clean, smooth, and SEO-compliant.\n\n**What it does**:\n- Improves grammar, sentence flow, and transitions  \n- Makes sure the content reads naturally and professionally  \n- Checks whether keywords are present and well integrated (but not overused)  \n- Verifies that the structure follows the correct H1/H2/H3 format  \n"
+                            },
+                            "label": "Note",
+                            "name": "Editor Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 147,
+                        "id": "Note:OpenOttersShow",
+                        "measured": {
+                            "height": 147,
+                            "width": 357
+                        },
+                        "position": {
+                            "x": 976.6858726228803,
+                            "y": 422.7404806291804
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 357
+                    }
+                ]
+            },
+            "history": [],
+            "messages": [],
+            "path": [],
+            "retrieval": []
+        },
+    "avatar": "data:image/jpeg;base64,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"
+}

agent/templates/knowledge_base_report.json

@@ -0,0 +1,331 @@
+{
+    "id": 20,
+    "title": {
+        "en": "Report Agent Using Knowledge Base",
+        "zh": "知识库检索智能体"},
+    "description": {
+        "en": "A report generation assistant using local knowledge base, with advanced capabilities in task planning, reasoning, and reflective analysis. Recommended for academic research paper Q&A",
+        "zh": "一个使用本地知识库的报告生成助手，具备高级能力，包括任务规划、推理和反思性分析。推荐用于学术研究论文问答。"},
+    "canvas_type": "Agent",
+    "dsl": {
+        "components": {
+            "Agent:NewPumasLick": {
+                "downstream": [
+                    "Message:OrangeYearsShine"
+                ],
+                "obj": {
+                    "component_name": "Agent",
+                    "params": {
+                        "delay_after_error": 1,
+                        "description": "",
+                        "exception_comment": "",
+                        "exception_default_value": "",
+                        "exception_goto": [],
+                        "exception_method": null,
+                        "frequencyPenaltyEnabled": false,
+                        "frequency_penalty": 0.5,
+                        "llm_id": "qwen3-235b-a22b-instruct-2507@Tongyi-Qianwen",
+                        "maxTokensEnabled": true,
+                        "max_retries": 3,
+                        "max_rounds": 3,
+                        "max_tokens": 128000,
+                        "mcp": [],
+                        "message_history_window_size": 12,
+                        "outputs": {
+                            "content": {
+                                "type": "string",
+                                "value": ""
+                            }
+                        },
+                        "parameter": "Precise",
+                        "presencePenaltyEnabled": false,
+                        "presence_penalty": 0.5,
+                        "prompts": [
+                            {
+                                "content": "# User Query\n {sys.query}",
+                                "role": "user"
+                            }
+                        ],
+                        "sys_prompt": "## Role & Task\nYou are a **\u201cKnowledge Base Retrieval Q\\&A Agent\u201d** whose goal is to break down the user\u2019s question into retrievable subtasks, and then produce a multi-source-verified, structured, and actionable research report using the internal knowledge base.\n## Execution Framework (Detailed Steps & Key Points)\n1. **Assessment & Decomposition**\n   * Actions:\n     * Automatically extract: main topic, subtopics, entities (people/organizations/products/technologies), time window, geographic/business scope.\n     * Output as a list: N facts/data points that must be collected (*N* ranges from 5\u201320 depending on question complexity).\n2. **Query Type Determination (Rule-Based)**\n   * Example rules:\n     * If the question involves a single issue but requests \u201cmethod comparison/multiple explanations\u201d \u2192 use **depth-first**.\n     * If the question can naturally be split into \u22653 independent sub-questions \u2192 use **breadth-first**.\n     * If the question can be answered by a single fact/specification/definition \u2192 use **simple query**.\n3. **Research Plan Formulation**\n   * Depth-first: define 3\u20135 perspectives (methodology/stakeholders/time dimension/technical route, etc.), assign search keywords, target document types, and output format for each perspective.\n   * Breadth-first: list subtasks, prioritize them, and assign search terms.\n   * Simple query: directly provide the search sentence and required fields.\n4. **Retrieval Execution**\n   * After retrieval: perform coverage check (does it contain the key facts?) and quality check (source diversity, authority, latest update time).\n   * If standards are not met, automatically loop: rewrite queries (synonyms/cross-domain terms) and retry \u22643 times, or flag as requiring external search.\n5. **Integration & Reasoning**\n   * Build the answer using a **fact\u2013evidence\u2013reasoning** chain. For each conclusion, attach 1\u20132 strongest pieces of evidence.\n---\n## Quality Gate Checklist (Verify at Each Stage)\n* **Stage 1 (Decomposition)**:\n  * [ ] Key concepts and expected outputs identified\n  * [ ] Required facts/data points listed\n* **Stage 2 (Retrieval)**:\n  * [ ] Meets quality standards (see above)\n  * [ ] If not met: execute query iteration\n* **Stage 3 (Generation)**:\n  * [ ] Each conclusion has at least one direct evidence source\n  * [ ] State assumptions/uncertainties\n  * [ ] Provide next-step suggestions or experiment/retrieval plans\n  * [ ] Final length and depth match user expectations (comply with word count/format if specified)\n---\n## Core Principles\n1. **Strict reliance on the knowledge base**: answers must be **fully bounded** by the content retrieved from the knowledge base.\n2. **No fabrication**: do not generate, infer, or create information that is not explicitly present in the knowledge base.\n3. **Accuracy first**: prefer incompleteness over inaccurate content.\n4. **Output format**:\n   * Hierarchically clear modular structure\n   * Logical grouping according to the MECE principle\n   * Professionally presented formatting\n   * Step-by-step cognitive guidance\n   * Reasonable use of headings and dividers for clarity\n   * *Italicize* key parameters\n   * **Bold** critical information\n5. **LaTeX formula requirements**:\n   * Inline formulas: start and end with `$`\n   * Block formulas: start and end with `$$`, each `$$` on its own line\n   * Block formula content must comply with LaTeX math syntax\n   * Verify formula correctness\n---\n## Additional Notes (Interaction & Failure Strategy)\n* If the knowledge base does not cover critical facts: explicitly inform the user (with sample wording)\n* For time-sensitive issues: enforce time filtering in the search request, and indicate the latest retrieval date in the answer.\n* Language requirement: answer in the user\u2019s preferred language\n",
+                        "temperature": "0.1",
+                        "temperatureEnabled": true,
+                        "tools": [
+                            {
+                                "component_name": "Retrieval",
+                                "name": "Retrieval",
+                                "params": {
+                                    "cross_languages": [],
+                                    "description": "",
+                                    "empty_response": "",
+                                    "kb_ids": [],
+                                    "keywords_similarity_weight": 0.7,
+                                    "outputs": {
+                                        "formalized_content": {
+                                            "type": "string",
+                                            "value": ""
+                                        }
+                                    },
+                                    "rerank_id": "",
+                                    "similarity_threshold": 0.2,
+                                    "top_k": 1024,
+                                    "top_n": 8,
+                                    "use_kg": false
+                                }
+                            }
+                        ],
+                        "topPEnabled": false,
+                        "top_p": 0.75,
+                        "user_prompt": "",
+                        "visual_files_var": ""
+                    }
+                },
+                "upstream": [
+                    "begin"
+                ]
+            },
+            "Message:OrangeYearsShine": {
+                "downstream": [],
+                "obj": {
+                    "component_name": "Message",
+                    "params": {
+                        "content": [
+                            "{Agent:NewPumasLick@content}"
+                        ]
+                    }
+                },
+                "upstream": [
+                    "Agent:NewPumasLick"
+                ]
+            },
+            "begin": {
+                "downstream": [
+                    "Agent:NewPumasLick"
+                ],
+                "obj": {
+                    "component_name": "Begin",
+                    "params": {
+                        "enablePrologue": true,
+                        "inputs": {},
+                        "mode": "conversational",
+                        "prologue": "\u4f60\u597d\uff01 \u6211\u662f\u4f60\u7684\u52a9\u7406\uff0c\u6709\u4ec0\u4e48\u53ef\u4ee5\u5e2e\u5230\u4f60\u7684\u5417\uff1f"
+                    }
+                },
+                "upstream": []
+            }
+        },
+        "globals": {
+            "sys.conversation_turns": 0,
+            "sys.files": [],
+            "sys.query": "",
+            "sys.user_id": ""
+        },
+        "graph": {
+            "edges": [
+                {
+                    "data": {
+                        "isHovered": false
+                    },
+                    "id": "xy-edge__beginstart-Agent:NewPumasLickend",
+                    "source": "begin",
+                    "sourceHandle": "start",
+                    "target": "Agent:NewPumasLick",
+                    "targetHandle": "end"
+                },
+                {
+                    "data": {
+                        "isHovered": false
+                    },
+                    "id": "xy-edge__Agent:NewPumasLickstart-Message:OrangeYearsShineend",
+                    "markerEnd": "logo",
+                    "source": "Agent:NewPumasLick",
+                    "sourceHandle": "start",
+                    "style": {
+                        "stroke": "rgba(91, 93, 106, 1)",
+                        "strokeWidth": 1
+                    },
+                    "target": "Message:OrangeYearsShine",
+                    "targetHandle": "end",
+                    "type": "buttonEdge",
+                    "zIndex": 1001
+                },
+                {
+                    "data": {
+                        "isHovered": false
+                    },
+                    "id": "xy-edge__Agent:NewPumasLicktool-Tool:AllBirdsNailend",
+                    "selected": false,
+                    "source": "Agent:NewPumasLick",
+                    "sourceHandle": "tool",
+                    "target": "Tool:AllBirdsNail",
+                    "targetHandle": "end"
+                }
+            ],
+            "nodes": [
+                {
+                    "data": {
+                        "form": {
+                            "enablePrologue": true,
+                            "inputs": {},
+                            "mode": "conversational",
+                            "prologue": "\u4f60\u597d\uff01 \u6211\u662f\u4f60\u7684\u52a9\u7406\uff0c\u6709\u4ec0\u4e48\u53ef\u4ee5\u5e2e\u5230\u4f60\u7684\u5417\uff1f"
+                        },
+                        "label": "Begin",
+                        "name": "begin"
+                    },
+                    "dragging": false,
+                    "id": "begin",
+                    "measured": {
+                        "height": 48,
+                        "width": 200
+                    },
+                    "position": {
+                        "x": -9.569875358221438,
+                        "y": 205.84018385864917
+                    },
+                    "selected": false,
+                    "sourcePosition": "left",
+                    "targetPosition": "right",
+                    "type": "beginNode"
+                },
+                {
+                    "data": {
+                        "form": {
+                            "content": [
+                                "{Agent:NewPumasLick@content}"
+                            ]
+                        },
+                        "label": "Message",
+                        "name": "Response"
+                    },
+                    "dragging": false,
+                    "id": "Message:OrangeYearsShine",
+                    "measured": {
+                        "height": 56,
+                        "width": 200
+                    },
+                    "position": {
+                        "x": 734.4061285881053,
+                        "y": 199.9706031723009
+                    },
+                    "selected": false,
+                    "sourcePosition": "right",
+                    "targetPosition": "left",
+                    "type": "messageNode"
+                },
+                {
+                    "data": {
+                        "form": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_comment": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": null,
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.5,
+                            "llm_id": "qwen3-235b-a22b-instruct-2507@Tongyi-Qianwen",
+                            "maxTokensEnabled": true,
+                            "max_retries": 3,
+                            "max_rounds": 3,
+                            "max_tokens": 128000,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "parameter": "Precise",
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.5,
+                            "prompts": [
+                                {
+                                    "content": "# User Query\n {sys.query}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "## Role & Task\nYou are a **\u201cKnowledge Base Retrieval Q\\&A Agent\u201d** whose goal is to break down the user\u2019s question into retrievable subtasks, and then produce a multi-source-verified, structured, and actionable research report using the internal knowledge base.\n## Execution Framework (Detailed Steps & Key Points)\n1. **Assessment & Decomposition**\n   * Actions:\n     * Automatically extract: main topic, subtopics, entities (people/organizations/products/technologies), time window, geographic/business scope.\n     * Output as a list: N facts/data points that must be collected (*N* ranges from 5\u201320 depending on question complexity).\n2. **Query Type Determination (Rule-Based)**\n   * Example rules:\n     * If the question involves a single issue but requests \u201cmethod comparison/multiple explanations\u201d \u2192 use **depth-first**.\n     * If the question can naturally be split into \u22653 independent sub-questions \u2192 use **breadth-first**.\n     * If the question can be answered by a single fact/specification/definition \u2192 use **simple query**.\n3. **Research Plan Formulation**\n   * Depth-first: define 3\u20135 perspectives (methodology/stakeholders/time dimension/technical route, etc.), assign search keywords, target document types, and output format for each perspective.\n   * Breadth-first: list subtasks, prioritize them, and assign search terms.\n   * Simple query: directly provide the search sentence and required fields.\n4. **Retrieval Execution**\n   * After retrieval: perform coverage check (does it contain the key facts?) and quality check (source diversity, authority, latest update time).\n   * If standards are not met, automatically loop: rewrite queries (synonyms/cross-domain terms) and retry \u22643 times, or flag as requiring external search.\n5. **Integration & Reasoning**\n   * Build the answer using a **fact\u2013evidence\u2013reasoning** chain. For each conclusion, attach 1\u20132 strongest pieces of evidence.\n---\n## Quality Gate Checklist (Verify at Each Stage)\n* **Stage 1 (Decomposition)**:\n  * [ ] Key concepts and expected outputs identified\n  * [ ] Required facts/data points listed\n* **Stage 2 (Retrieval)**:\n  * [ ] Meets quality standards (see above)\n  * [ ] If not met: execute query iteration\n* **Stage 3 (Generation)**:\n  * [ ] Each conclusion has at least one direct evidence source\n  * [ ] State assumptions/uncertainties\n  * [ ] Provide next-step suggestions or experiment/retrieval plans\n  * [ ] Final length and depth match user expectations (comply with word count/format if specified)\n---\n## Core Principles\n1. **Strict reliance on the knowledge base**: answers must be **fully bounded** by the content retrieved from the knowledge base.\n2. **No fabrication**: do not generate, infer, or create information that is not explicitly present in the knowledge base.\n3. **Accuracy first**: prefer incompleteness over inaccurate content.\n4. **Output format**:\n   * Hierarchically clear modular structure\n   * Logical grouping according to the MECE principle\n   * Professionally presented formatting\n   * Step-by-step cognitive guidance\n   * Reasonable use of headings and dividers for clarity\n   * *Italicize* key parameters\n   * **Bold** critical information\n5. **LaTeX formula requirements**:\n   * Inline formulas: start and end with `$`\n   * Block formulas: start and end with `$$`, each `$$` on its own line\n   * Block formula content must comply with LaTeX math syntax\n   * Verify formula correctness\n---\n## Additional Notes (Interaction & Failure Strategy)\n* If the knowledge base does not cover critical facts: explicitly inform the user (with sample wording)\n* For time-sensitive issues: enforce time filtering in the search request, and indicate the latest retrieval date in the answer.\n* Language requirement: answer in the user\u2019s preferred language\n",
+                            "temperature": "0.1",
+                            "temperatureEnabled": true,
+                            "tools": [
+                                {
+                                    "component_name": "Retrieval",
+                                    "name": "Retrieval",
+                                    "params": {
+                                        "cross_languages": [],
+                                        "description": "",
+                                        "empty_response": "",
+                                        "kb_ids": [],
+                                        "keywords_similarity_weight": 0.7,
+                                        "outputs": {
+                                            "formalized_content": {
+                                                "type": "string",
+                                                "value": ""
+                                            }
+                                        },
+                                        "rerank_id": "",
+                                        "similarity_threshold": 0.2,
+                                        "top_k": 1024,
+                                        "top_n": 8,
+                                        "use_kg": false
+                                    }
+                                }
+                            ],
+                            "topPEnabled": false,
+                            "top_p": 0.75,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        },
+                        "label": "Agent",
+                        "name": "Knowledge Base Agent"
+                    },
+                    "dragging": false,
+                    "id": "Agent:NewPumasLick",
+                    "measured": {
+                        "height": 84,
+                        "width": 200
+                    },
+                    "position": {
+                        "x": 347.00048227952215,
+                        "y": 186.49109364794631
+                    },
+                    "selected": false,
+                    "sourcePosition": "right",
+                    "targetPosition": "left",
+                    "type": "agentNode"
+                },
+                {
+                    "data": {
+                        "form": {
+                            "description": "This is an agent for a specific task.",
+                            "user_prompt": "This is the order you need to send to the agent."
+                        },
+                        "label": "Tool",
+                        "name": "flow.tool_10"
+                    },
+                    "dragging": false,
+                    "id": "Tool:AllBirdsNail",
+                    "measured": {
+                        "height": 48,
+                        "width": 200
+                    },
+                    "position": {
+                        "x": 220.24819746977118,
+                        "y": 403.31576836482583
+                    },
+                    "selected": false,
+                    "sourcePosition": "right",
+                    "targetPosition": "left",
+                    "type": "toolNode"
+                }
+            ]
+        },
+        "history": [],
+        "memory": [],
+        "messages": [],
+        "path": [],
+        "retrieval": []
+    },
+    "avatar": "data:image/png;base64,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"
+}

agent/templates/knowledge_base_report_r.json

@@ -0,0 +1,331 @@
+{
+    "id": 21,
+    "title": {
+        "en": "Report Agent Using Knowledge Base", 
+        "zh": "知识库检索智能体"},
+    "description": {
+        "en": "A report generation assistant using local knowledge base, with advanced capabilities in task planning, reasoning, and reflective analysis. Recommended for academic research paper Q&A",
+        "zh": "一个使用本地知识库的报告生成助手，具备高级能力，包括任务规划、推理和反思性分析。推荐用于学术研究论文问答。"},
+    "canvas_type": "Recommended",
+    "dsl": {
+        "components": {
+            "Agent:NewPumasLick": {
+                "downstream": [
+                    "Message:OrangeYearsShine"
+                ],
+                "obj": {
+                    "component_name": "Agent",
+                    "params": {
+                        "delay_after_error": 1,
+                        "description": "",
+                        "exception_comment": "",
+                        "exception_default_value": "",
+                        "exception_goto": [],
+                        "exception_method": null,
+                        "frequencyPenaltyEnabled": false,
+                        "frequency_penalty": 0.5,
+                        "llm_id": "qwen3-235b-a22b-instruct-2507@Tongyi-Qianwen",
+                        "maxTokensEnabled": true,
+                        "max_retries": 3,
+                        "max_rounds": 3,
+                        "max_tokens": 128000,
+                        "mcp": [],
+                        "message_history_window_size": 12,
+                        "outputs": {
+                            "content": {
+                                "type": "string",
+                                "value": ""
+                            }
+                        },
+                        "parameter": "Precise",
+                        "presencePenaltyEnabled": false,
+                        "presence_penalty": 0.5,
+                        "prompts": [
+                            {
+                                "content": "# User Query\n {sys.query}",
+                                "role": "user"
+                            }
+                        ],
+                        "sys_prompt": "## Role & Task\nYou are a **\u201cKnowledge Base Retrieval Q\\&A Agent\u201d** whose goal is to break down the user\u2019s question into retrievable subtasks, and then produce a multi-source-verified, structured, and actionable research report using the internal knowledge base.\n## Execution Framework (Detailed Steps & Key Points)\n1. **Assessment & Decomposition**\n   * Actions:\n     * Automatically extract: main topic, subtopics, entities (people/organizations/products/technologies), time window, geographic/business scope.\n     * Output as a list: N facts/data points that must be collected (*N* ranges from 5\u201320 depending on question complexity).\n2. **Query Type Determination (Rule-Based)**\n   * Example rules:\n     * If the question involves a single issue but requests \u201cmethod comparison/multiple explanations\u201d \u2192 use **depth-first**.\n     * If the question can naturally be split into \u22653 independent sub-questions \u2192 use **breadth-first**.\n     * If the question can be answered by a single fact/specification/definition \u2192 use **simple query**.\n3. **Research Plan Formulation**\n   * Depth-first: define 3\u20135 perspectives (methodology/stakeholders/time dimension/technical route, etc.), assign search keywords, target document types, and output format for each perspective.\n   * Breadth-first: list subtasks, prioritize them, and assign search terms.\n   * Simple query: directly provide the search sentence and required fields.\n4. **Retrieval Execution**\n   * After retrieval: perform coverage check (does it contain the key facts?) and quality check (source diversity, authority, latest update time).\n   * If standards are not met, automatically loop: rewrite queries (synonyms/cross-domain terms) and retry \u22643 times, or flag as requiring external search.\n5. **Integration & Reasoning**\n   * Build the answer using a **fact\u2013evidence\u2013reasoning** chain. For each conclusion, attach 1\u20132 strongest pieces of evidence.\n---\n## Quality Gate Checklist (Verify at Each Stage)\n* **Stage 1 (Decomposition)**:\n  * [ ] Key concepts and expected outputs identified\n  * [ ] Required facts/data points listed\n* **Stage 2 (Retrieval)**:\n  * [ ] Meets quality standards (see above)\n  * [ ] If not met: execute query iteration\n* **Stage 3 (Generation)**:\n  * [ ] Each conclusion has at least one direct evidence source\n  * [ ] State assumptions/uncertainties\n  * [ ] Provide next-step suggestions or experiment/retrieval plans\n  * [ ] Final length and depth match user expectations (comply with word count/format if specified)\n---\n## Core Principles\n1. **Strict reliance on the knowledge base**: answers must be **fully bounded** by the content retrieved from the knowledge base.\n2. **No fabrication**: do not generate, infer, or create information that is not explicitly present in the knowledge base.\n3. **Accuracy first**: prefer incompleteness over inaccurate content.\n4. **Output format**:\n   * Hierarchically clear modular structure\n   * Logical grouping according to the MECE principle\n   * Professionally presented formatting\n   * Step-by-step cognitive guidance\n   * Reasonable use of headings and dividers for clarity\n   * *Italicize* key parameters\n   * **Bold** critical information\n5. **LaTeX formula requirements**:\n   * Inline formulas: start and end with `$`\n   * Block formulas: start and end with `$$`, each `$$` on its own line\n   * Block formula content must comply with LaTeX math syntax\n   * Verify formula correctness\n---\n## Additional Notes (Interaction & Failure Strategy)\n* If the knowledge base does not cover critical facts: explicitly inform the user (with sample wording)\n* For time-sensitive issues: enforce time filtering in the search request, and indicate the latest retrieval date in the answer.\n* Language requirement: answer in the user\u2019s preferred language\n",
+                        "temperature": "0.1",
+                        "temperatureEnabled": true,
+                        "tools": [
+                            {
+                                "component_name": "Retrieval",
+                                "name": "Retrieval",
+                                "params": {
+                                    "cross_languages": [],
+                                    "description": "",
+                                    "empty_response": "",
+                                    "kb_ids": [],
+                                    "keywords_similarity_weight": 0.7,
+                                    "outputs": {
+                                        "formalized_content": {
+                                            "type": "string",
+                                            "value": ""
+                                        }
+                                    },
+                                    "rerank_id": "",
+                                    "similarity_threshold": 0.2,
+                                    "top_k": 1024,
+                                    "top_n": 8,
+                                    "use_kg": false
+                                }
+                            }
+                        ],
+                        "topPEnabled": false,
+                        "top_p": 0.75,
+                        "user_prompt": "",
+                        "visual_files_var": ""
+                    }
+                },
+                "upstream": [
+                    "begin"
+                ]
+            },
+            "Message:OrangeYearsShine": {
+                "downstream": [],
+                "obj": {
+                    "component_name": "Message",
+                    "params": {
+                        "content": [
+                            "{Agent:NewPumasLick@content}"
+                        ]
+                    }
+                },
+                "upstream": [
+                    "Agent:NewPumasLick"
+                ]
+            },
+            "begin": {
+                "downstream": [
+                    "Agent:NewPumasLick"
+                ],
+                "obj": {
+                    "component_name": "Begin",
+                    "params": {
+                        "enablePrologue": true,
+                        "inputs": {},
+                        "mode": "conversational",
+                        "prologue": "\u4f60\u597d\uff01 \u6211\u662f\u4f60\u7684\u52a9\u7406\uff0c\u6709\u4ec0\u4e48\u53ef\u4ee5\u5e2e\u5230\u4f60\u7684\u5417\uff1f"
+                    }
+                },
+                "upstream": []
+            }
+        },
+        "globals": {
+            "sys.conversation_turns": 0,
+            "sys.files": [],
+            "sys.query": "",
+            "sys.user_id": ""
+        },
+        "graph": {
+            "edges": [
+                {
+                    "data": {
+                        "isHovered": false
+                    },
+                    "id": "xy-edge__beginstart-Agent:NewPumasLickend",
+                    "source": "begin",
+                    "sourceHandle": "start",
+                    "target": "Agent:NewPumasLick",
+                    "targetHandle": "end"
+                },
+                {
+                    "data": {
+                        "isHovered": false
+                    },
+                    "id": "xy-edge__Agent:NewPumasLickstart-Message:OrangeYearsShineend",
+                    "markerEnd": "logo",
+                    "source": "Agent:NewPumasLick",
+                    "sourceHandle": "start",
+                    "style": {
+                        "stroke": "rgba(91, 93, 106, 1)",
+                        "strokeWidth": 1
+                    },
+                    "target": "Message:OrangeYearsShine",
+                    "targetHandle": "end",
+                    "type": "buttonEdge",
+                    "zIndex": 1001
+                },
+                {
+                    "data": {
+                        "isHovered": false
+                    },
+                    "id": "xy-edge__Agent:NewPumasLicktool-Tool:AllBirdsNailend",
+                    "selected": false,
+                    "source": "Agent:NewPumasLick",
+                    "sourceHandle": "tool",
+                    "target": "Tool:AllBirdsNail",
+                    "targetHandle": "end"
+                }
+            ],
+            "nodes": [
+                {
+                    "data": {
+                        "form": {
+                            "enablePrologue": true,
+                            "inputs": {},
+                            "mode": "conversational",
+                            "prologue": "\u4f60\u597d\uff01 \u6211\u662f\u4f60\u7684\u52a9\u7406\uff0c\u6709\u4ec0\u4e48\u53ef\u4ee5\u5e2e\u5230\u4f60\u7684\u5417\uff1f"
+                        },
+                        "label": "Begin",
+                        "name": "begin"
+                    },
+                    "dragging": false,
+                    "id": "begin",
+                    "measured": {
+                        "height": 48,
+                        "width": 200
+                    },
+                    "position": {
+                        "x": -9.569875358221438,
+                        "y": 205.84018385864917
+                    },
+                    "selected": false,
+                    "sourcePosition": "left",
+                    "targetPosition": "right",
+                    "type": "beginNode"
+                },
+                {
+                    "data": {
+                        "form": {
+                            "content": [
+                                "{Agent:NewPumasLick@content}"
+                            ]
+                        },
+                        "label": "Message",
+                        "name": "Response"
+                    },
+                    "dragging": false,
+                    "id": "Message:OrangeYearsShine",
+                    "measured": {
+                        "height": 56,
+                        "width": 200
+                    },
+                    "position": {
+                        "x": 734.4061285881053,
+                        "y": 199.9706031723009
+                    },
+                    "selected": false,
+                    "sourcePosition": "right",
+                    "targetPosition": "left",
+                    "type": "messageNode"
+                },
+                {
+                    "data": {
+                        "form": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_comment": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": null,
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.5,
+                            "llm_id": "qwen3-235b-a22b-instruct-2507@Tongyi-Qianwen",
+                            "maxTokensEnabled": true,
+                            "max_retries": 3,
+                            "max_rounds": 3,
+                            "max_tokens": 128000,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "parameter": "Precise",
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.5,
+                            "prompts": [
+                                {
+                                    "content": "# User Query\n {sys.query}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "## Role & Task\nYou are a **\u201cKnowledge Base Retrieval Q\\&A Agent\u201d** whose goal is to break down the user\u2019s question into retrievable subtasks, and then produce a multi-source-verified, structured, and actionable research report using the internal knowledge base.\n## Execution Framework (Detailed Steps & Key Points)\n1. **Assessment & Decomposition**\n   * Actions:\n     * Automatically extract: main topic, subtopics, entities (people/organizations/products/technologies), time window, geographic/business scope.\n     * Output as a list: N facts/data points that must be collected (*N* ranges from 5\u201320 depending on question complexity).\n2. **Query Type Determination (Rule-Based)**\n   * Example rules:\n     * If the question involves a single issue but requests \u201cmethod comparison/multiple explanations\u201d \u2192 use **depth-first**.\n     * If the question can naturally be split into \u22653 independent sub-questions \u2192 use **breadth-first**.\n     * If the question can be answered by a single fact/specification/definition \u2192 use **simple query**.\n3. **Research Plan Formulation**\n   * Depth-first: define 3\u20135 perspectives (methodology/stakeholders/time dimension/technical route, etc.), assign search keywords, target document types, and output format for each perspective.\n   * Breadth-first: list subtasks, prioritize them, and assign search terms.\n   * Simple query: directly provide the search sentence and required fields.\n4. **Retrieval Execution**\n   * After retrieval: perform coverage check (does it contain the key facts?) and quality check (source diversity, authority, latest update time).\n   * If standards are not met, automatically loop: rewrite queries (synonyms/cross-domain terms) and retry \u22643 times, or flag as requiring external search.\n5. **Integration & Reasoning**\n   * Build the answer using a **fact\u2013evidence\u2013reasoning** chain. For each conclusion, attach 1\u20132 strongest pieces of evidence.\n---\n## Quality Gate Checklist (Verify at Each Stage)\n* **Stage 1 (Decomposition)**:\n  * [ ] Key concepts and expected outputs identified\n  * [ ] Required facts/data points listed\n* **Stage 2 (Retrieval)**:\n  * [ ] Meets quality standards (see above)\n  * [ ] If not met: execute query iteration\n* **Stage 3 (Generation)**:\n  * [ ] Each conclusion has at least one direct evidence source\n  * [ ] State assumptions/uncertainties\n  * [ ] Provide next-step suggestions or experiment/retrieval plans\n  * [ ] Final length and depth match user expectations (comply with word count/format if specified)\n---\n## Core Principles\n1. **Strict reliance on the knowledge base**: answers must be **fully bounded** by the content retrieved from the knowledge base.\n2. **No fabrication**: do not generate, infer, or create information that is not explicitly present in the knowledge base.\n3. **Accuracy first**: prefer incompleteness over inaccurate content.\n4. **Output format**:\n   * Hierarchically clear modular structure\n   * Logical grouping according to the MECE principle\n   * Professionally presented formatting\n   * Step-by-step cognitive guidance\n   * Reasonable use of headings and dividers for clarity\n   * *Italicize* key parameters\n   * **Bold** critical information\n5. **LaTeX formula requirements**:\n   * Inline formulas: start and end with `$`\n   * Block formulas: start and end with `$$`, each `$$` on its own line\n   * Block formula content must comply with LaTeX math syntax\n   * Verify formula correctness\n---\n## Additional Notes (Interaction & Failure Strategy)\n* If the knowledge base does not cover critical facts: explicitly inform the user (with sample wording)\n* For time-sensitive issues: enforce time filtering in the search request, and indicate the latest retrieval date in the answer.\n* Language requirement: answer in the user\u2019s preferred language\n",
+                            "temperature": "0.1",
+                            "temperatureEnabled": true,
+                            "tools": [
+                                {
+                                    "component_name": "Retrieval",
+                                    "name": "Retrieval",
+                                    "params": {
+                                        "cross_languages": [],
+                                        "description": "",
+                                        "empty_response": "",
+                                        "kb_ids": [],
+                                        "keywords_similarity_weight": 0.7,
+                                        "outputs": {
+                                            "formalized_content": {
+                                                "type": "string",
+                                                "value": ""
+                                            }
+                                        },
+                                        "rerank_id": "",
+                                        "similarity_threshold": 0.2,
+                                        "top_k": 1024,
+                                        "top_n": 8,
+                                        "use_kg": false
+                                    }
+                                }
+                            ],
+                            "topPEnabled": false,
+                            "top_p": 0.75,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        },
+                        "label": "Agent",
+                        "name": "Knowledge Base Agent"
+                    },
+                    "dragging": false,
+                    "id": "Agent:NewPumasLick",
+                    "measured": {
+                        "height": 84,
+                        "width": 200
+                    },
+                    "position": {
+                        "x": 347.00048227952215,
+                        "y": 186.49109364794631
+                    },
+                    "selected": false,
+                    "sourcePosition": "right",
+                    "targetPosition": "left",
+                    "type": "agentNode"
+                },
+                {
+                    "data": {
+                        "form": {
+                            "description": "This is an agent for a specific task.",
+                            "user_prompt": "This is the order you need to send to the agent."
+                        },
+                        "label": "Tool",
+                        "name": "flow.tool_10"
+                    },
+                    "dragging": false,
+                    "id": "Tool:AllBirdsNail",
+                    "measured": {
+                        "height": 48,
+                        "width": 200
+                    },
+                    "position": {
+                        "x": 220.24819746977118,
+                        "y": 403.31576836482583
+                    },
+                    "selected": false,
+                    "sourcePosition": "right",
+                    "targetPosition": "left",
+                    "type": "toolNode"
+                }
+            ]
+        },
+        "history": [],
+        "memory": [],
+        "messages": [],
+        "path": [],
+        "retrieval": []
+    },
+    "avatar": "data:image/png;base64,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"
+}

agent/templates/market_generate_seo_blog.json

@@ -0,0 +1,919 @@
+{
+    "id": 12,
+    "title": {
+        "en": "Generate SEO Blog",
+        "zh": "生成SEO博客"},
+    "description": {
+        "en": "This workflow automatically generates a complete SEO-optimized blog article based on a simple user input. You don’t need any writing experience. Just provide a topic or short request — the system will handle the rest.",
+        "zh": "此工作流根据简单的用户输入自动生成完整的SEO博客文章。你无需任何写作经验，只需提供一个主题或简短请求，系统将处理其余部分。"},
+    "canvas_type": "Marketing",
+    "dsl": {
+            "components": {
+                "Agent:BetterSitesSend": {
+                    "downstream": [
+                        "Agent:EagerNailsRemain"
+                    ],
+                    "obj": {
+                        "component_name": "Agent",
+                        "params": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_comment": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": null,
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.3,
+                            "llm_id": "deepseek-chat@DeepSeek",
+                            "maxTokensEnabled": false,
+                            "max_retries": 3,
+                            "max_rounds": 3,
+                            "max_tokens": 4096,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "parameter": "Balance",
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.2,
+                            "prompts": [
+                                {
+                                    "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "# Role\n\nYou are the **Outline_Agent**, responsible for generating a clear and SEO-optimized blog outline based on the user's parsed writing intent and keyword strategy.\n\n# Tool Access:\n\n- You have access to a search tool called `Tavily Search`.\n\n- If you are unsure how to structure a section, you may call this tool to search for related blog outlines or content from Google.\n\n- Do not overuse it. Your job is to extract **structure**, not to write paragraphs.\n\n\n# Goals\n\n1. Create a well-structured outline with appropriate H2 and H3 headings.\n\n2. Ensure logical flow from introduction to conclusion.\n\n3. Assign 1\u20132 suggested long-tail keywords to each major section for SEO alignment.\n\n4. Make the structure suitable for downstream paragraph writing.\n\n\n\n\n#Note\n\n- Use concise, scannable section titles.\n\n- Do not write full paragraphs.\n\n- Prioritize clarity, logical progression, and SEO alignment.\n\n\n\n- If the blog type is \u201cTutorial\u201d or \u201cHow-to\u201d, include step-based sections.\n\n\n# Input\n\nYou will receive:\n\n- Writing Type (e.g., Tutorial, Informative Guide)\n\n- Target Audience\n\n- User Intent Summary\n\n- 3\u20135 long-tail keywords\n\n\nUse this information to design a structure that both informs readers and maximizes search engine visibility.\n\n# Output Format\n\n```markdown\n\n## Blog Title (suggested)\n\n[Give a short, SEO-friendly title suggestion]\n\n## Outline\n\n### Introduction\n\n- Purpose of the article\n\n- Brief context\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 1]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 2]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 3]\n\n- [Optional H3 Subsection Title A]\n\n  - [Explanation of sub-point]\n\n- [Optional H3 Subsection Title B]\n\n  - [Explanation of sub-point]\n\n- **Suggested keywords**: [keyword1]\n\n### Conclusion\n\n- Recap key takeaways\n\n- Optional CTA (Call to Action)\n\n- **Suggested keywords**: [keyword3]\n\n",
+                            "temperature": 0.5,
+                            "temperatureEnabled": true,
+                            "tools": [
+                                {
+                                    "component_name": "TavilySearch",
+                                    "name": "TavilySearch",
+                                    "params": {
+                                        "api_key": "",
+                                        "days": 7,
+                                        "exclude_domains": [],
+                                        "include_answer": false,
+                                        "include_domains": [],
+                                        "include_image_descriptions": false,
+                                        "include_images": false,
+                                        "include_raw_content": true,
+                                        "max_results": 5,
+                                        "outputs": {
+                                            "formalized_content": {
+                                                "type": "string",
+                                                "value": ""
+                                            },
+                                            "json": {
+                                                "type": "Array<Object>",
+                                                "value": []
+                                            }
+                                        },
+                                        "query": "sys.query",
+                                        "search_depth": "basic",
+                                        "topic": "general"
+                                    }
+                                }
+                            ],
+                            "topPEnabled": false,
+                            "top_p": 0.85,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        }
+                    },
+                    "upstream": [
+                        "Agent:ClearRabbitsScream"
+                    ]
+                },
+                "Agent:ClearRabbitsScream": {
+                    "downstream": [
+                        "Agent:BetterSitesSend"
+                    ],
+                    "obj": {
+                        "component_name": "Agent",
+                        "params": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_comment": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": null,
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.5,
+                            "llm_id": "deepseek-chat@DeepSeek",
+                            "maxTokensEnabled": false,
+                            "max_retries": 3,
+                            "max_rounds": 1,
+                            "max_tokens": 4096,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "parameter": "Precise",
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.5,
+                            "prompts": [
+                                {
+                                    "content": "The user query is {sys.query}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "# Role\n\nYou are the **Parse_And_Keyword_Agent**, responsible for interpreting a user's blog writing request and generating a structured writing intent summary and keyword strategy for SEO-optimized content generation.\n\n# Goals\n\n1. Extract and infer the user's true writing intent, even if the input is informal or vague.\n\n2. Identify the writing type, target audience, and implied goal.\n\n3. Suggest 3\u20135 long-tail keywords based on the input and context.\n\n4. Output all data in a Markdown format for downstream agents.\n\n# Operating Guidelines\n\n\n- If the user's input lacks clarity, make reasonable and **conservative** assumptions based on SEO best practices.\n\n- Always choose one clear \"Writing Type\" from the list below.\n\n- Your job is not to write the blog \u2014 only to structure the brief.\n\n# Output Format\n\n```markdown\n## Writing Type\n\n[Choose one: Tutorial / Informative Guide / Marketing Content / Case Study / Opinion Piece / How-to / Comparison Article]\n\n## Target Audience\n\n[Try to be specific based on clues in the input: e.g., marketing managers, junior developers, SEO beginners]\n\n## User Intent Summary\n\n[A 1\u20132 sentence summary of what the user wants to achieve with the blog post]\n\n## Suggested Long-tail Keywords\n\n- keyword 1\n\n- keyword 2\n\n- keyword 3\n\n- keyword 4 (optional)\n\n- keyword 5 (optional)\n\n\n\n\n## Input Examples (and how to handle them)\n\nInput: \"I want to write about RAGFlow.\"\n\u2192 Output: Informative Guide, Audience: AI developers, Intent: explain what RAGFlow is and its use cases\n\nInput: \"Need a blog to promote our prompt design tool.\"\n\u2192 Output: Marketing Content, Audience: product managers or tool adopters, Intent: raise awareness and interest in the product\n\n\n\nInput: \"How to get more Google traffic using AI\"\n\u2192 Output: How-to, Audience: SEO marketers, Intent: guide readers on applying AI for SEO growth",
+                            "temperature": 0.2,
+                            "temperatureEnabled": true,
+                            "tools": [],
+                            "topPEnabled": false,
+                            "top_p": 0.75,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        }
+                    },
+                    "upstream": [
+                        "begin"
+                    ]
+                },
+                "Agent:EagerNailsRemain": {
+                    "downstream": [
+                        "Agent:LovelyHeadsOwn"
+                    ],
+                    "obj": {
+                        "component_name": "Agent",
+                        "params": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_comment": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": null,
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.5,
+                            "llm_id": "deepseek-chat@DeepSeek",
+                            "maxTokensEnabled": false,
+                            "max_retries": 3,
+                            "max_rounds": 5,
+                            "max_tokens": 4096,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "parameter": "Precise",
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.5,
+                            "prompts": [
+                                {
+                                    "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}\n\n\n\nThe Outline agent output is {Agent:BetterSitesSend@content}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "# Role\n\nYou are the **Body_Agent**, responsible for generating the full content of each section of an SEO-optimized blog based on the provided outline and keyword strategy.\n\n# Tool Access:\n\nYou can use the `Tavily Search` tool to retrieve relevant content, statistics, or examples to support each section you're writing.\n\nUse it **only** when the provided outline lacks enough information, or if the section requires factual grounding.\n\nAlways cite the original link or indicate source where possible.\n\n\n# Goals\n\n1. Write each section (based on H2/H3 structure) as a complete and natural blog paragraph.\n\n2. Integrate the suggested long-tail keywords naturally into each section.\n\n3. When appropriate, use the `Tavily Search` tool to enrich your writing with relevant facts, examples, or quotes.\n\n4. Ensure each section is clear, engaging, and informative, suitable for both human readers and search engines.\n\n\n# Style Guidelines\n\n- Write in a tone appropriate to the audience. Be explanatory, not promotional, unless it's a marketing blog.\n\n- Avoid generic filler content. Prioritize clarity, structure, and value.\n\n- Ensure SEO keywords are embedded seamlessly, not forcefully.\n\n\n\n- Maintain writing rhythm. Vary sentence lengths. Use transitions between ideas.\n\n\n# Input\n\n\nYou will receive:\n\n- Blog title\n\n- Structured outline (including section titles, keywords, and descriptions)\n\n- Target audience\n\n- Blog type and user intent\n\nYou must **follow the outline strictly**. Write content **section-by-section**, based on the structure.\n\n\n# Output Format\n\n```markdown\n\n## H2: [Section Title]\n\n[Your generated content for this section \u2014 500-600 words, using keywords naturally.]\n\n",
+                            "temperature": 0.2,
+                            "temperatureEnabled": true,
+                            "tools": [
+                                {
+                                    "component_name": "TavilySearch",
+                                    "name": "TavilySearch",
+                                    "params": {
+                                        "api_key": "",
+                                        "days": 7,
+                                        "exclude_domains": [],
+                                        "include_answer": false,
+                                        "include_domains": [],
+                                        "include_image_descriptions": false,
+                                        "include_images": false,
+                                        "include_raw_content": true,
+                                        "max_results": 5,
+                                        "outputs": {
+                                            "formalized_content": {
+                                                "type": "string",
+                                                "value": ""
+                                            },
+                                            "json": {
+                                                "type": "Array<Object>",
+                                                "value": []
+                                            }
+                                        },
+                                        "query": "sys.query",
+                                        "search_depth": "basic",
+                                        "topic": "general"
+                                    }
+                                }
+                            ],
+                            "topPEnabled": false,
+                            "top_p": 0.75,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        }
+                    },
+                    "upstream": [
+                        "Agent:BetterSitesSend"
+                    ]
+                },
+                "Agent:LovelyHeadsOwn": {
+                    "downstream": [
+                        "Message:LegalBeansBet"
+                    ],
+                    "obj": {
+                        "component_name": "Agent",
+                        "params": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_comment": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": null,
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.5,
+                            "llm_id": "deepseek-chat@DeepSeek",
+                            "maxTokensEnabled": false,
+                            "max_retries": 3,
+                            "max_rounds": 5,
+                            "max_tokens": 4096,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "parameter": "Precise",
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.5,
+                            "prompts": [
+                                {
+                                    "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}\n\nThe Outline agent output is {Agent:BetterSitesSend@content}\n\nThe Body agent output is {Agent:EagerNailsRemain@content}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "# Role\n\nYou are the **Editor_Agent**, responsible for finalizing the blog post for both human readability and SEO effectiveness.\n\n# Goals\n\n1. Polish the entire blog content for clarity, coherence, and style.\n\n2. Improve transitions between sections, ensure logical flow.\n\n3. Verify that keywords are used appropriately and effectively.\n\n4. Conduct a lightweight SEO audit \u2014 checking keyword density, structure (H1/H2/H3), and overall searchability.\n\n\n\n# Style Guidelines\n\n- Be precise. Avoid bloated or vague language.\n\n- Maintain an informative and engaging tone, suitable to the target audience.\n\n- Do not remove keywords unless absolutely necessary for clarity.\n\n- Ensure paragraph flow and section continuity.\n\n\n# Input\n\nYou will receive:\n\n- Full blog content, written section-by-section\n\n- Original outline with suggested keywords\n\n- Target audience and writing type\n\n# Output Format\n\n```markdown\n\n[The revised, fully polished blog post content goes here.]\n\n",
+                            "temperature": 0.2,
+                            "temperatureEnabled": true,
+                            "tools": [],
+                            "topPEnabled": false,
+                            "top_p": 0.75,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        }
+                    },
+                    "upstream": [
+                        "Agent:EagerNailsRemain"
+                    ]
+                },
+                "Message:LegalBeansBet": {
+                    "downstream": [],
+                    "obj": {
+                        "component_name": "Message",
+                        "params": {
+                            "content": [
+                                "{Agent:LovelyHeadsOwn@content}"
+                            ]
+                        }
+                    },
+                    "upstream": [
+                        "Agent:LovelyHeadsOwn"
+                    ]
+                },
+                "begin": {
+                    "downstream": [
+                        "Agent:ClearRabbitsScream"
+                    ],
+                    "obj": {
+                        "component_name": "Begin",
+                        "params": {
+                            "enablePrologue": true,
+                            "inputs": {},
+                            "mode": "conversational",
+                            "prologue": "Hi! I'm your SEO blog assistant.\n\nTo get started, please tell me:\n1. What topic you want the blog to cover\n2. Who is the target audience\n3. What you hope to achieve with this blog (e.g., SEO traffic, teaching beginners, promoting a product)\n"
+                        }
+                    },
+                    "upstream": []
+                }
+            },
+            "globals": {
+                "sys.conversation_turns": 0,
+                "sys.files": [],
+                "sys.query": "",
+                "sys.user_id": ""
+            },
+            "graph": {
+                "edges": [
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__beginstart-Agent:ClearRabbitsScreamend",
+                        "source": "begin",
+                        "sourceHandle": "start",
+                        "target": "Agent:ClearRabbitsScream",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:ClearRabbitsScreamstart-Agent:BetterSitesSendend",
+                        "source": "Agent:ClearRabbitsScream",
+                        "sourceHandle": "start",
+                        "target": "Agent:BetterSitesSend",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:BetterSitesSendtool-Tool:SharpPensBurnend",
+                        "source": "Agent:BetterSitesSend",
+                        "sourceHandle": "tool",
+                        "target": "Tool:SharpPensBurn",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:BetterSitesSendstart-Agent:EagerNailsRemainend",
+                        "source": "Agent:BetterSitesSend",
+                        "sourceHandle": "start",
+                        "target": "Agent:EagerNailsRemain",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "id": "xy-edge__Agent:EagerNailsRemaintool-Tool:WickedDeerHealend",
+                        "source": "Agent:EagerNailsRemain",
+                        "sourceHandle": "tool",
+                        "target": "Tool:WickedDeerHeal",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:EagerNailsRemainstart-Agent:LovelyHeadsOwnend",
+                        "source": "Agent:EagerNailsRemain",
+                        "sourceHandle": "start",
+                        "target": "Agent:LovelyHeadsOwn",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:LovelyHeadsOwnstart-Message:LegalBeansBetend",
+                        "source": "Agent:LovelyHeadsOwn",
+                        "sourceHandle": "start",
+                        "target": "Message:LegalBeansBet",
+                        "targetHandle": "end"
+                    }
+                ],
+                "nodes": [
+                    {
+                        "data": {
+                            "form": {
+                                "enablePrologue": true,
+                                "inputs": {},
+                                "mode": "conversational",
+                                "prologue": "Hi! I'm your SEO blog assistant.\n\nTo get started, please tell me:\n1. What topic you want the blog to cover\n2. Who is the target audience\n3. What you hope to achieve with this blog (e.g., SEO traffic, teaching beginners, promoting a product)\n"
+                            },
+                            "label": "Begin",
+                            "name": "begin"
+                        },
+                        "id": "begin",
+                        "measured": {
+                            "height": 48,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 50,
+                            "y": 200
+                        },
+                        "selected": false,
+                        "sourcePosition": "left",
+                        "targetPosition": "right",
+                        "type": "beginNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.5,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 1,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Precise",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.5,
+                                "prompts": [
+                                    {
+                                        "content": "The user query is {sys.query}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Parse_And_Keyword_Agent**, responsible for interpreting a user's blog writing request and generating a structured writing intent summary and keyword strategy for SEO-optimized content generation.\n\n# Goals\n\n1. Extract and infer the user's true writing intent, even if the input is informal or vague.\n\n2. Identify the writing type, target audience, and implied goal.\n\n3. Suggest 3\u20135 long-tail keywords based on the input and context.\n\n4. Output all data in a Markdown format for downstream agents.\n\n# Operating Guidelines\n\n\n- If the user's input lacks clarity, make reasonable and **conservative** assumptions based on SEO best practices.\n\n- Always choose one clear \"Writing Type\" from the list below.\n\n- Your job is not to write the blog \u2014 only to structure the brief.\n\n# Output Format\n\n```markdown\n## Writing Type\n\n[Choose one: Tutorial / Informative Guide / Marketing Content / Case Study / Opinion Piece / How-to / Comparison Article]\n\n## Target Audience\n\n[Try to be specific based on clues in the input: e.g., marketing managers, junior developers, SEO beginners]\n\n## User Intent Summary\n\n[A 1\u20132 sentence summary of what the user wants to achieve with the blog post]\n\n## Suggested Long-tail Keywords\n\n- keyword 1\n\n- keyword 2\n\n- keyword 3\n\n- keyword 4 (optional)\n\n- keyword 5 (optional)\n\n\n\n\n## Input Examples (and how to handle them)\n\nInput: \"I want to write about RAGFlow.\"\n\u2192 Output: Informative Guide, Audience: AI developers, Intent: explain what RAGFlow is and its use cases\n\nInput: \"Need a blog to promote our prompt design tool.\"\n\u2192 Output: Marketing Content, Audience: product managers or tool adopters, Intent: raise awareness and interest in the product\n\n\n\nInput: \"How to get more Google traffic using AI\"\n\u2192 Output: How-to, Audience: SEO marketers, Intent: guide readers on applying AI for SEO growth",
+                                "temperature": 0.2,
+                                "temperatureEnabled": true,
+                                "tools": [],
+                                "topPEnabled": false,
+                                "top_p": 0.75,
+                                "user_prompt": "",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Parse And Keyword Agent"
+                        },
+                        "dragging": false,
+                        "id": "Agent:ClearRabbitsScream",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 344.7766966202233,
+                            "y": 234.82202253184496
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.3,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 3,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Balance",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.2,
+                                "prompts": [
+                                    {
+                                        "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Outline_Agent**, responsible for generating a clear and SEO-optimized blog outline based on the user's parsed writing intent and keyword strategy.\n\n# Tool Access:\n\n- You have access to a search tool called `Tavily Search`.\n\n- If you are unsure how to structure a section, you may call this tool to search for related blog outlines or content from Google.\n\n- Do not overuse it. Your job is to extract **structure**, not to write paragraphs.\n\n\n# Goals\n\n1. Create a well-structured outline with appropriate H2 and H3 headings.\n\n2. Ensure logical flow from introduction to conclusion.\n\n3. Assign 1\u20132 suggested long-tail keywords to each major section for SEO alignment.\n\n4. Make the structure suitable for downstream paragraph writing.\n\n\n\n\n#Note\n\n- Use concise, scannable section titles.\n\n- Do not write full paragraphs.\n\n- Prioritize clarity, logical progression, and SEO alignment.\n\n\n\n- If the blog type is \u201cTutorial\u201d or \u201cHow-to\u201d, include step-based sections.\n\n\n# Input\n\nYou will receive:\n\n- Writing Type (e.g., Tutorial, Informative Guide)\n\n- Target Audience\n\n- User Intent Summary\n\n- 3\u20135 long-tail keywords\n\n\nUse this information to design a structure that both informs readers and maximizes search engine visibility.\n\n# Output Format\n\n```markdown\n\n## Blog Title (suggested)\n\n[Give a short, SEO-friendly title suggestion]\n\n## Outline\n\n### Introduction\n\n- Purpose of the article\n\n- Brief context\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 1]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 2]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 3]\n\n- [Optional H3 Subsection Title A]\n\n  - [Explanation of sub-point]\n\n- [Optional H3 Subsection Title B]\n\n  - [Explanation of sub-point]\n\n- **Suggested keywords**: [keyword1]\n\n### Conclusion\n\n- Recap key takeaways\n\n- Optional CTA (Call to Action)\n\n- **Suggested keywords**: [keyword3]\n\n",
+                                "temperature": 0.5,
+                                "temperatureEnabled": true,
+                                "tools": [
+                                    {
+                                        "component_name": "TavilySearch",
+                                        "name": "TavilySearch",
+                                        "params": {
+                                            "api_key": "",
+                                            "days": 7,
+                                            "exclude_domains": [],
+                                            "include_answer": false,
+                                            "include_domains": [],
+                                            "include_image_descriptions": false,
+                                            "include_images": false,
+                                            "include_raw_content": true,
+                                            "max_results": 5,
+                                            "outputs": {
+                                                "formalized_content": {
+                                                    "type": "string",
+                                                    "value": ""
+                                                },
+                                                "json": {
+                                                    "type": "Array<Object>",
+                                                    "value": []
+                                                }
+                                            },
+                                            "query": "sys.query",
+                                            "search_depth": "basic",
+                                            "topic": "general"
+                                        }
+                                    }
+                                ],
+                                "topPEnabled": false,
+                                "top_p": 0.85,
+                                "user_prompt": "",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Outline Agent"
+                        },
+                        "dragging": false,
+                        "id": "Agent:BetterSitesSend",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 613.4368763415628,
+                            "y": 164.3074269048589
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "description": "This is an agent for a specific task.",
+                                "user_prompt": "This is the order you need to send to the agent."
+                            },
+                            "label": "Tool",
+                            "name": "flow.tool_0"
+                        },
+                        "dragging": false,
+                        "id": "Tool:SharpPensBurn",
+                        "measured": {
+                            "height": 44,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 580.1877078861457,
+                            "y": 287.7669662022325
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "toolNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.5,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 5,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Precise",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.5,
+                                "prompts": [
+                                    {
+                                        "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}\n\n\n\nThe Outline agent output is {Agent:BetterSitesSend@content}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Body_Agent**, responsible for generating the full content of each section of an SEO-optimized blog based on the provided outline and keyword strategy.\n\n# Tool Access:\n\nYou can use the `Tavily Search` tool to retrieve relevant content, statistics, or examples to support each section you're writing.\n\nUse it **only** when the provided outline lacks enough information, or if the section requires factual grounding.\n\nAlways cite the original link or indicate source where possible.\n\n\n# Goals\n\n1. Write each section (based on H2/H3 structure) as a complete and natural blog paragraph.\n\n2. Integrate the suggested long-tail keywords naturally into each section.\n\n3. When appropriate, use the `Tavily Search` tool to enrich your writing with relevant facts, examples, or quotes.\n\n4. Ensure each section is clear, engaging, and informative, suitable for both human readers and search engines.\n\n\n# Style Guidelines\n\n- Write in a tone appropriate to the audience. Be explanatory, not promotional, unless it's a marketing blog.\n\n- Avoid generic filler content. Prioritize clarity, structure, and value.\n\n- Ensure SEO keywords are embedded seamlessly, not forcefully.\n\n\n\n- Maintain writing rhythm. Vary sentence lengths. Use transitions between ideas.\n\n\n# Input\n\n\nYou will receive:\n\n- Blog title\n\n- Structured outline (including section titles, keywords, and descriptions)\n\n- Target audience\n\n- Blog type and user intent\n\nYou must **follow the outline strictly**. Write content **section-by-section**, based on the structure.\n\n\n# Output Format\n\n```markdown\n\n## H2: [Section Title]\n\n[Your generated content for this section \u2014 500-600 words, using keywords naturally.]\n\n",
+                                "temperature": 0.2,
+                                "temperatureEnabled": true,
+                                "tools": [
+                                    {
+                                        "component_name": "TavilySearch",
+                                        "name": "TavilySearch",
+                                        "params": {
+                                            "api_key": "",
+                                            "days": 7,
+                                            "exclude_domains": [],
+                                            "include_answer": false,
+                                            "include_domains": [],
+                                            "include_image_descriptions": false,
+                                            "include_images": false,
+                                            "include_raw_content": true,
+                                            "max_results": 5,
+                                            "outputs": {
+                                                "formalized_content": {
+                                                    "type": "string",
+                                                    "value": ""
+                                                },
+                                                "json": {
+                                                    "type": "Array<Object>",
+                                                    "value": []
+                                                }
+                                            },
+                                            "query": "sys.query",
+                                            "search_depth": "basic",
+                                            "topic": "general"
+                                        }
+                                    }
+                                ],
+                                "topPEnabled": false,
+                                "top_p": 0.75,
+                                "user_prompt": "",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Body Agent"
+                        },
+                        "dragging": false,
+                        "id": "Agent:EagerNailsRemain",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 889.0614605692713,
+                            "y": 247.00973041799065
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "description": "This is an agent for a specific task.",
+                                "user_prompt": "This is the order you need to send to the agent."
+                            },
+                            "label": "Tool",
+                            "name": "flow.tool_1"
+                        },
+                        "dragging": false,
+                        "id": "Tool:WickedDeerHeal",
+                        "measured": {
+                            "height": 44,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 853.2006404239659,
+                            "y": 364.37541577229143
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "toolNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.5,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 5,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Precise",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.5,
+                                "prompts": [
+                                    {
+                                        "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}\n\nThe Outline agent output is {Agent:BetterSitesSend@content}\n\nThe Body agent output is {Agent:EagerNailsRemain@content}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Editor_Agent**, responsible for finalizing the blog post for both human readability and SEO effectiveness.\n\n# Goals\n\n1. Polish the entire blog content for clarity, coherence, and style.\n\n2. Improve transitions between sections, ensure logical flow.\n\n3. Verify that keywords are used appropriately and effectively.\n\n4. Conduct a lightweight SEO audit \u2014 checking keyword density, structure (H1/H2/H3), and overall searchability.\n\n\n\n# Style Guidelines\n\n- Be precise. Avoid bloated or vague language.\n\n- Maintain an informative and engaging tone, suitable to the target audience.\n\n- Do not remove keywords unless absolutely necessary for clarity.\n\n- Ensure paragraph flow and section continuity.\n\n\n# Input\n\nYou will receive:\n\n- Full blog content, written section-by-section\n\n- Original outline with suggested keywords\n\n- Target audience and writing type\n\n# Output Format\n\n```markdown\n\n[The revised, fully polished blog post content goes here.]\n\n",
+                                "temperature": 0.2,
+                                "temperatureEnabled": true,
+                                "tools": [],
+                                "topPEnabled": false,
+                                "top_p": 0.75,
+                                "user_prompt": "",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Editor Agent"
+                        },
+                        "dragging": false,
+                        "id": "Agent:LovelyHeadsOwn",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 1160.3332919804993,
+                            "y": 149.50806732882472
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "content": [
+                                    "{Agent:LovelyHeadsOwn@content}"
+                                ]
+                            },
+                            "label": "Message",
+                            "name": "Response"
+                        },
+                        "dragging": false,
+                        "id": "Message:LegalBeansBet",
+                        "measured": {
+                            "height": 56,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 1370.6665839609984,
+                            "y": 267.0323933738015
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "messageNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "This workflow automatically generates a complete SEO-optimized blog article based on a simple user input. You don\u2019t need any writing experience. Just provide a topic or short request \u2014 the system will handle the rest.\n\nThe process includes the following key stages:\n\n1. **Understanding your topic and goals**\n2. **Designing the blog structure**\n3. **Writing high-quality content**\n\n\n"
+                            },
+                            "label": "Note",
+                            "name": "Workflow Overall Description"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 205,
+                        "id": "Note:SlimyGhostsWear",
+                        "measured": {
+                            "height": 205,
+                            "width": 415
+                        },
+                        "position": {
+                            "x": -284.3143151688742,
+                            "y": 150.47632147913419
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 415
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis agent reads the user\u2019s input and figures out what kind of blog needs to be written.\n\n**What it does**:\n- Understands the main topic you want to write about  \n- Identifies who the blog is for (e.g., beginners, marketers, developers)  \n- Determines the writing purpose (e.g., SEO traffic, product promotion, education)  \n- Suggests 3\u20135 long-tail SEO keywords related to the topic"
+                            },
+                            "label": "Note",
+                            "name": "Parse And Keyword Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 152,
+                        "id": "Note:EmptyChairsShake",
+                        "measured": {
+                            "height": 152,
+                            "width": 340
+                        },
+                        "position": {
+                            "x": 295.04147626768133,
+                            "y": 372.2755718118446
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 340
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis agent builds the blog structure \u2014 just like writing a table of contents before you start writing the full article.\n\n**What it does**:\n- Suggests a clear blog title that includes important keywords  \n- Breaks the article into sections using H2 and H3 headings (like a professional blog layout)  \n- Assigns 1\u20132 recommended keywords to each section to help with SEO  \n- Follows the writing goal and target audience set in the previous step"
+                            },
+                            "label": "Note",
+                            "name": "Outline Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 146,
+                        "id": "Note:TallMelonsNotice",
+                        "measured": {
+                            "height": 146,
+                            "width": 343
+                        },
+                        "position": {
+                            "x": 598.5644991893463,
+                            "y": 5.801054564756448
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 343
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis agent is responsible for writing the actual content of the blog \u2014 paragraph by paragraph \u2014 based on the outline created earlier.\n\n**What it does**:\n- Looks at each H2/H3 section in the outline  \n- Writes 150\u2013220 words of clear, helpful, and well-structured content per section  \n- Includes the suggested SEO keywords naturally (not keyword stuffing)  \n- Uses real examples or facts if needed (by calling a web search tool like Tavily)"
+                            },
+                            "label": "Note",
+                            "name": "Body Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 137,
+                        "id": "Note:RipeCougarsBuild",
+                        "measured": {
+                            "height": 137,
+                            "width": 319
+                        },
+                        "position": {
+                            "x": 860.4854129814981,
+                            "y": 427.2196835690842
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 319
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis agent reviews the entire blog draft to make sure it is smooth, professional, and SEO-friendly. It acts like a human editor before publishing.\n\n**What it does**:\n- Polishes the writing: improves sentence clarity, fixes awkward phrasing  \n- Makes sure the content flows well from one section to the next  \n- Double-checks keyword usage: are they present, natural, and not overused?  \n- Verifies the blog structure (H1, H2, H3 headings) is correct  \n- Adds two key SEO elements:\n  - **Meta Title** (shows up in search results)\n  - **Meta Description** (summary for Google and social sharing)"
+                            },
+                            "label": "Note",
+                            "name": "Editor Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "height": 146,
+                        "id": "Note:OpenTurkeysSell",
+                        "measured": {
+                            "height": 146,
+                            "width": 320
+                        },
+                        "position": {
+                            "x": 1129,
+                            "y": -30
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 320
+                    }
+                ]
+            },
+            "history": [],
+            "messages": [],
+            "path": [],
+            "retrieval": []
+        },
+    "avatar": "data:image/jpeg;base64,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"
+}

agent/templates/seo_blog.json

@@ -0,0 +1,919 @@
+{
+    "id": 4,
+    "title": {
+        "en": "Generate SEO Blog",
+        "zh": "生成SEO博客"},
+    "description": {
+        "en": "This workflow automatically generates a complete SEO-optimized blog article based on a simple user input. You don’t need any writing experience. Just provide a topic or short request — the system will handle the rest.",
+        "zh": "此工作流根据简单的用户输入自动生成完整的SEO博客文章。你无需任何写作经验，只需提供一个主题或简短请求，系统将处理其余部分。"},
+    "canvas_type": "Recommended",
+    "dsl": {
+            "components": {
+                "Agent:BetterSitesSend": {
+                    "downstream": [
+                        "Agent:EagerNailsRemain"
+                    ],
+                    "obj": {
+                        "component_name": "Agent",
+                        "params": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_comment": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": null,
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.3,
+                            "llm_id": "deepseek-chat@DeepSeek",
+                            "maxTokensEnabled": false,
+                            "max_retries": 3,
+                            "max_rounds": 3,
+                            "max_tokens": 4096,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "parameter": "Balance",
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.2,
+                            "prompts": [
+                                {
+                                    "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "# Role\n\nYou are the **Outline_Agent**, responsible for generating a clear and SEO-optimized blog outline based on the user's parsed writing intent and keyword strategy.\n\n# Tool Access:\n\n- You have access to a search tool called `Tavily Search`.\n\n- If you are unsure how to structure a section, you may call this tool to search for related blog outlines or content from Google.\n\n- Do not overuse it. Your job is to extract **structure**, not to write paragraphs.\n\n\n# Goals\n\n1. Create a well-structured outline with appropriate H2 and H3 headings.\n\n2. Ensure logical flow from introduction to conclusion.\n\n3. Assign 1\u20132 suggested long-tail keywords to each major section for SEO alignment.\n\n4. Make the structure suitable for downstream paragraph writing.\n\n\n\n\n#Note\n\n- Use concise, scannable section titles.\n\n- Do not write full paragraphs.\n\n- Prioritize clarity, logical progression, and SEO alignment.\n\n\n\n- If the blog type is \u201cTutorial\u201d or \u201cHow-to\u201d, include step-based sections.\n\n\n# Input\n\nYou will receive:\n\n- Writing Type (e.g., Tutorial, Informative Guide)\n\n- Target Audience\n\n- User Intent Summary\n\n- 3\u20135 long-tail keywords\n\n\nUse this information to design a structure that both informs readers and maximizes search engine visibility.\n\n# Output Format\n\n```markdown\n\n## Blog Title (suggested)\n\n[Give a short, SEO-friendly title suggestion]\n\n## Outline\n\n### Introduction\n\n- Purpose of the article\n\n- Brief context\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 1]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 2]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 3]\n\n- [Optional H3 Subsection Title A]\n\n  - [Explanation of sub-point]\n\n- [Optional H3 Subsection Title B]\n\n  - [Explanation of sub-point]\n\n- **Suggested keywords**: [keyword1]\n\n### Conclusion\n\n- Recap key takeaways\n\n- Optional CTA (Call to Action)\n\n- **Suggested keywords**: [keyword3]\n\n",
+                            "temperature": 0.5,
+                            "temperatureEnabled": true,
+                            "tools": [
+                                {
+                                    "component_name": "TavilySearch",
+                                    "name": "TavilySearch",
+                                    "params": {
+                                        "api_key": "",
+                                        "days": 7,
+                                        "exclude_domains": [],
+                                        "include_answer": false,
+                                        "include_domains": [],
+                                        "include_image_descriptions": false,
+                                        "include_images": false,
+                                        "include_raw_content": true,
+                                        "max_results": 5,
+                                        "outputs": {
+                                            "formalized_content": {
+                                                "type": "string",
+                                                "value": ""
+                                            },
+                                            "json": {
+                                                "type": "Array<Object>",
+                                                "value": []
+                                            }
+                                        },
+                                        "query": "sys.query",
+                                        "search_depth": "basic",
+                                        "topic": "general"
+                                    }
+                                }
+                            ],
+                            "topPEnabled": false,
+                            "top_p": 0.85,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        }
+                    },
+                    "upstream": [
+                        "Agent:ClearRabbitsScream"
+                    ]
+                },
+                "Agent:ClearRabbitsScream": {
+                    "downstream": [
+                        "Agent:BetterSitesSend"
+                    ],
+                    "obj": {
+                        "component_name": "Agent",
+                        "params": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_comment": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": null,
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.5,
+                            "llm_id": "deepseek-chat@DeepSeek",
+                            "maxTokensEnabled": false,
+                            "max_retries": 3,
+                            "max_rounds": 1,
+                            "max_tokens": 4096,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "parameter": "Precise",
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.5,
+                            "prompts": [
+                                {
+                                    "content": "The user query is {sys.query}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "# Role\n\nYou are the **Parse_And_Keyword_Agent**, responsible for interpreting a user's blog writing request and generating a structured writing intent summary and keyword strategy for SEO-optimized content generation.\n\n# Goals\n\n1. Extract and infer the user's true writing intent, even if the input is informal or vague.\n\n2. Identify the writing type, target audience, and implied goal.\n\n3. Suggest 3\u20135 long-tail keywords based on the input and context.\n\n4. Output all data in a Markdown format for downstream agents.\n\n# Operating Guidelines\n\n\n- If the user's input lacks clarity, make reasonable and **conservative** assumptions based on SEO best practices.\n\n- Always choose one clear \"Writing Type\" from the list below.\n\n- Your job is not to write the blog \u2014 only to structure the brief.\n\n# Output Format\n\n```markdown\n## Writing Type\n\n[Choose one: Tutorial / Informative Guide / Marketing Content / Case Study / Opinion Piece / How-to / Comparison Article]\n\n## Target Audience\n\n[Try to be specific based on clues in the input: e.g., marketing managers, junior developers, SEO beginners]\n\n## User Intent Summary\n\n[A 1\u20132 sentence summary of what the user wants to achieve with the blog post]\n\n## Suggested Long-tail Keywords\n\n- keyword 1\n\n- keyword 2\n\n- keyword 3\n\n- keyword 4 (optional)\n\n- keyword 5 (optional)\n\n\n\n\n## Input Examples (and how to handle them)\n\nInput: \"I want to write about RAGFlow.\"\n\u2192 Output: Informative Guide, Audience: AI developers, Intent: explain what RAGFlow is and its use cases\n\nInput: \"Need a blog to promote our prompt design tool.\"\n\u2192 Output: Marketing Content, Audience: product managers or tool adopters, Intent: raise awareness and interest in the product\n\n\n\nInput: \"How to get more Google traffic using AI\"\n\u2192 Output: How-to, Audience: SEO marketers, Intent: guide readers on applying AI for SEO growth",
+                            "temperature": 0.2,
+                            "temperatureEnabled": true,
+                            "tools": [],
+                            "topPEnabled": false,
+                            "top_p": 0.75,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        }
+                    },
+                    "upstream": [
+                        "begin"
+                    ]
+                },
+                "Agent:EagerNailsRemain": {
+                    "downstream": [
+                        "Agent:LovelyHeadsOwn"
+                    ],
+                    "obj": {
+                        "component_name": "Agent",
+                        "params": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_comment": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": null,
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.5,
+                            "llm_id": "deepseek-chat@DeepSeek",
+                            "maxTokensEnabled": false,
+                            "max_retries": 3,
+                            "max_rounds": 5,
+                            "max_tokens": 4096,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "parameter": "Precise",
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.5,
+                            "prompts": [
+                                {
+                                    "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}\n\n\n\nThe Outline agent output is {Agent:BetterSitesSend@content}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "# Role\n\nYou are the **Body_Agent**, responsible for generating the full content of each section of an SEO-optimized blog based on the provided outline and keyword strategy.\n\n# Tool Access:\n\nYou can use the `Tavily Search` tool to retrieve relevant content, statistics, or examples to support each section you're writing.\n\nUse it **only** when the provided outline lacks enough information, or if the section requires factual grounding.\n\nAlways cite the original link or indicate source where possible.\n\n\n# Goals\n\n1. Write each section (based on H2/H3 structure) as a complete and natural blog paragraph.\n\n2. Integrate the suggested long-tail keywords naturally into each section.\n\n3. When appropriate, use the `Tavily Search` tool to enrich your writing with relevant facts, examples, or quotes.\n\n4. Ensure each section is clear, engaging, and informative, suitable for both human readers and search engines.\n\n\n# Style Guidelines\n\n- Write in a tone appropriate to the audience. Be explanatory, not promotional, unless it's a marketing blog.\n\n- Avoid generic filler content. Prioritize clarity, structure, and value.\n\n- Ensure SEO keywords are embedded seamlessly, not forcefully.\n\n\n\n- Maintain writing rhythm. Vary sentence lengths. Use transitions between ideas.\n\n\n# Input\n\n\nYou will receive:\n\n- Blog title\n\n- Structured outline (including section titles, keywords, and descriptions)\n\n- Target audience\n\n- Blog type and user intent\n\nYou must **follow the outline strictly**. Write content **section-by-section**, based on the structure.\n\n\n# Output Format\n\n```markdown\n\n## H2: [Section Title]\n\n[Your generated content for this section \u2014 500-600 words, using keywords naturally.]\n\n",
+                            "temperature": 0.2,
+                            "temperatureEnabled": true,
+                            "tools": [
+                                {
+                                    "component_name": "TavilySearch",
+                                    "name": "TavilySearch",
+                                    "params": {
+                                        "api_key": "",
+                                        "days": 7,
+                                        "exclude_domains": [],
+                                        "include_answer": false,
+                                        "include_domains": [],
+                                        "include_image_descriptions": false,
+                                        "include_images": false,
+                                        "include_raw_content": true,
+                                        "max_results": 5,
+                                        "outputs": {
+                                            "formalized_content": {
+                                                "type": "string",
+                                                "value": ""
+                                            },
+                                            "json": {
+                                                "type": "Array<Object>",
+                                                "value": []
+                                            }
+                                        },
+                                        "query": "sys.query",
+                                        "search_depth": "basic",
+                                        "topic": "general"
+                                    }
+                                }
+                            ],
+                            "topPEnabled": false,
+                            "top_p": 0.75,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        }
+                    },
+                    "upstream": [
+                        "Agent:BetterSitesSend"
+                    ]
+                },
+                "Agent:LovelyHeadsOwn": {
+                    "downstream": [
+                        "Message:LegalBeansBet"
+                    ],
+                    "obj": {
+                        "component_name": "Agent",
+                        "params": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_comment": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": null,
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.5,
+                            "llm_id": "deepseek-chat@DeepSeek",
+                            "maxTokensEnabled": false,
+                            "max_retries": 3,
+                            "max_rounds": 5,
+                            "max_tokens": 4096,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "parameter": "Precise",
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.5,
+                            "prompts": [
+                                {
+                                    "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}\n\nThe Outline agent output is {Agent:BetterSitesSend@content}\n\nThe Body agent output is {Agent:EagerNailsRemain@content}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "# Role\n\nYou are the **Editor_Agent**, responsible for finalizing the blog post for both human readability and SEO effectiveness.\n\n# Goals\n\n1. Polish the entire blog content for clarity, coherence, and style.\n\n2. Improve transitions between sections, ensure logical flow.\n\n3. Verify that keywords are used appropriately and effectively.\n\n4. Conduct a lightweight SEO audit \u2014 checking keyword density, structure (H1/H2/H3), and overall searchability.\n\n\n\n# Style Guidelines\n\n- Be precise. Avoid bloated or vague language.\n\n- Maintain an informative and engaging tone, suitable to the target audience.\n\n- Do not remove keywords unless absolutely necessary for clarity.\n\n- Ensure paragraph flow and section continuity.\n\n\n# Input\n\nYou will receive:\n\n- Full blog content, written section-by-section\n\n- Original outline with suggested keywords\n\n- Target audience and writing type\n\n# Output Format\n\n```markdown\n\n[The revised, fully polished blog post content goes here.]\n\n",
+                            "temperature": 0.2,
+                            "temperatureEnabled": true,
+                            "tools": [],
+                            "topPEnabled": false,
+                            "top_p": 0.75,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        }
+                    },
+                    "upstream": [
+                        "Agent:EagerNailsRemain"
+                    ]
+                },
+                "Message:LegalBeansBet": {
+                    "downstream": [],
+                    "obj": {
+                        "component_name": "Message",
+                        "params": {
+                            "content": [
+                                "{Agent:LovelyHeadsOwn@content}"
+                            ]
+                        }
+                    },
+                    "upstream": [
+                        "Agent:LovelyHeadsOwn"
+                    ]
+                },
+                "begin": {
+                    "downstream": [
+                        "Agent:ClearRabbitsScream"
+                    ],
+                    "obj": {
+                        "component_name": "Begin",
+                        "params": {
+                            "enablePrologue": true,
+                            "inputs": {},
+                            "mode": "conversational",
+                            "prologue": "Hi! I'm your SEO blog assistant.\n\nTo get started, please tell me:\n1. What topic you want the blog to cover\n2. Who is the target audience\n3. What you hope to achieve with this blog (e.g., SEO traffic, teaching beginners, promoting a product)\n"
+                        }
+                    },
+                    "upstream": []
+                }
+            },
+            "globals": {
+                "sys.conversation_turns": 0,
+                "sys.files": [],
+                "sys.query": "",
+                "sys.user_id": ""
+            },
+            "graph": {
+                "edges": [
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__beginstart-Agent:ClearRabbitsScreamend",
+                        "source": "begin",
+                        "sourceHandle": "start",
+                        "target": "Agent:ClearRabbitsScream",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:ClearRabbitsScreamstart-Agent:BetterSitesSendend",
+                        "source": "Agent:ClearRabbitsScream",
+                        "sourceHandle": "start",
+                        "target": "Agent:BetterSitesSend",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:BetterSitesSendtool-Tool:SharpPensBurnend",
+                        "source": "Agent:BetterSitesSend",
+                        "sourceHandle": "tool",
+                        "target": "Tool:SharpPensBurn",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:BetterSitesSendstart-Agent:EagerNailsRemainend",
+                        "source": "Agent:BetterSitesSend",
+                        "sourceHandle": "start",
+                        "target": "Agent:EagerNailsRemain",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "id": "xy-edge__Agent:EagerNailsRemaintool-Tool:WickedDeerHealend",
+                        "source": "Agent:EagerNailsRemain",
+                        "sourceHandle": "tool",
+                        "target": "Tool:WickedDeerHeal",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:EagerNailsRemainstart-Agent:LovelyHeadsOwnend",
+                        "source": "Agent:EagerNailsRemain",
+                        "sourceHandle": "start",
+                        "target": "Agent:LovelyHeadsOwn",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:LovelyHeadsOwnstart-Message:LegalBeansBetend",
+                        "source": "Agent:LovelyHeadsOwn",
+                        "sourceHandle": "start",
+                        "target": "Message:LegalBeansBet",
+                        "targetHandle": "end"
+                    }
+                ],
+                "nodes": [
+                    {
+                        "data": {
+                            "form": {
+                                "enablePrologue": true,
+                                "inputs": {},
+                                "mode": "conversational",
+                                "prologue": "Hi! I'm your SEO blog assistant.\n\nTo get started, please tell me:\n1. What topic you want the blog to cover\n2. Who is the target audience\n3. What you hope to achieve with this blog (e.g., SEO traffic, teaching beginners, promoting a product)\n"
+                            },
+                            "label": "Begin",
+                            "name": "begin"
+                        },
+                        "id": "begin",
+                        "measured": {
+                            "height": 48,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 50,
+                            "y": 200
+                        },
+                        "selected": false,
+                        "sourcePosition": "left",
+                        "targetPosition": "right",
+                        "type": "beginNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.5,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 1,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Precise",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.5,
+                                "prompts": [
+                                    {
+                                        "content": "The user query is {sys.query}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Parse_And_Keyword_Agent**, responsible for interpreting a user's blog writing request and generating a structured writing intent summary and keyword strategy for SEO-optimized content generation.\n\n# Goals\n\n1. Extract and infer the user's true writing intent, even if the input is informal or vague.\n\n2. Identify the writing type, target audience, and implied goal.\n\n3. Suggest 3\u20135 long-tail keywords based on the input and context.\n\n4. Output all data in a Markdown format for downstream agents.\n\n# Operating Guidelines\n\n\n- If the user's input lacks clarity, make reasonable and **conservative** assumptions based on SEO best practices.\n\n- Always choose one clear \"Writing Type\" from the list below.\n\n- Your job is not to write the blog \u2014 only to structure the brief.\n\n# Output Format\n\n```markdown\n## Writing Type\n\n[Choose one: Tutorial / Informative Guide / Marketing Content / Case Study / Opinion Piece / How-to / Comparison Article]\n\n## Target Audience\n\n[Try to be specific based on clues in the input: e.g., marketing managers, junior developers, SEO beginners]\n\n## User Intent Summary\n\n[A 1\u20132 sentence summary of what the user wants to achieve with the blog post]\n\n## Suggested Long-tail Keywords\n\n- keyword 1\n\n- keyword 2\n\n- keyword 3\n\n- keyword 4 (optional)\n\n- keyword 5 (optional)\n\n\n\n\n## Input Examples (and how to handle them)\n\nInput: \"I want to write about RAGFlow.\"\n\u2192 Output: Informative Guide, Audience: AI developers, Intent: explain what RAGFlow is and its use cases\n\nInput: \"Need a blog to promote our prompt design tool.\"\n\u2192 Output: Marketing Content, Audience: product managers or tool adopters, Intent: raise awareness and interest in the product\n\n\n\nInput: \"How to get more Google traffic using AI\"\n\u2192 Output: How-to, Audience: SEO marketers, Intent: guide readers on applying AI for SEO growth",
+                                "temperature": 0.2,
+                                "temperatureEnabled": true,
+                                "tools": [],
+                                "topPEnabled": false,
+                                "top_p": 0.75,
+                                "user_prompt": "",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Parse And Keyword Agent"
+                        },
+                        "dragging": false,
+                        "id": "Agent:ClearRabbitsScream",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 344.7766966202233,
+                            "y": 234.82202253184496
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.3,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 3,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Balance",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.2,
+                                "prompts": [
+                                    {
+                                        "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Outline_Agent**, responsible for generating a clear and SEO-optimized blog outline based on the user's parsed writing intent and keyword strategy.\n\n# Tool Access:\n\n- You have access to a search tool called `Tavily Search`.\n\n- If you are unsure how to structure a section, you may call this tool to search for related blog outlines or content from Google.\n\n- Do not overuse it. Your job is to extract **structure**, not to write paragraphs.\n\n\n# Goals\n\n1. Create a well-structured outline with appropriate H2 and H3 headings.\n\n2. Ensure logical flow from introduction to conclusion.\n\n3. Assign 1\u20132 suggested long-tail keywords to each major section for SEO alignment.\n\n4. Make the structure suitable for downstream paragraph writing.\n\n\n\n\n#Note\n\n- Use concise, scannable section titles.\n\n- Do not write full paragraphs.\n\n- Prioritize clarity, logical progression, and SEO alignment.\n\n\n\n- If the blog type is \u201cTutorial\u201d or \u201cHow-to\u201d, include step-based sections.\n\n\n# Input\n\nYou will receive:\n\n- Writing Type (e.g., Tutorial, Informative Guide)\n\n- Target Audience\n\n- User Intent Summary\n\n- 3\u20135 long-tail keywords\n\n\nUse this information to design a structure that both informs readers and maximizes search engine visibility.\n\n# Output Format\n\n```markdown\n\n## Blog Title (suggested)\n\n[Give a short, SEO-friendly title suggestion]\n\n## Outline\n\n### Introduction\n\n- Purpose of the article\n\n- Brief context\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 1]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 2]\n\n- [Short description of what this section will cover]\n\n- **Suggested keywords**: [keyword1, keyword2]\n\n### H2: [Section Title 3]\n\n- [Optional H3 Subsection Title A]\n\n  - [Explanation of sub-point]\n\n- [Optional H3 Subsection Title B]\n\n  - [Explanation of sub-point]\n\n- **Suggested keywords**: [keyword1]\n\n### Conclusion\n\n- Recap key takeaways\n\n- Optional CTA (Call to Action)\n\n- **Suggested keywords**: [keyword3]\n\n",
+                                "temperature": 0.5,
+                                "temperatureEnabled": true,
+                                "tools": [
+                                    {
+                                        "component_name": "TavilySearch",
+                                        "name": "TavilySearch",
+                                        "params": {
+                                            "api_key": "",
+                                            "days": 7,
+                                            "exclude_domains": [],
+                                            "include_answer": false,
+                                            "include_domains": [],
+                                            "include_image_descriptions": false,
+                                            "include_images": false,
+                                            "include_raw_content": true,
+                                            "max_results": 5,
+                                            "outputs": {
+                                                "formalized_content": {
+                                                    "type": "string",
+                                                    "value": ""
+                                                },
+                                                "json": {
+                                                    "type": "Array<Object>",
+                                                    "value": []
+                                                }
+                                            },
+                                            "query": "sys.query",
+                                            "search_depth": "basic",
+                                            "topic": "general"
+                                        }
+                                    }
+                                ],
+                                "topPEnabled": false,
+                                "top_p": 0.85,
+                                "user_prompt": "",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Outline Agent"
+                        },
+                        "dragging": false,
+                        "id": "Agent:BetterSitesSend",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 613.4368763415628,
+                            "y": 164.3074269048589
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "description": "This is an agent for a specific task.",
+                                "user_prompt": "This is the order you need to send to the agent."
+                            },
+                            "label": "Tool",
+                            "name": "flow.tool_0"
+                        },
+                        "dragging": false,
+                        "id": "Tool:SharpPensBurn",
+                        "measured": {
+                            "height": 44,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 580.1877078861457,
+                            "y": 287.7669662022325
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "toolNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.5,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 5,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Precise",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.5,
+                                "prompts": [
+                                    {
+                                        "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}\n\n\n\nThe Outline agent output is {Agent:BetterSitesSend@content}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Body_Agent**, responsible for generating the full content of each section of an SEO-optimized blog based on the provided outline and keyword strategy.\n\n# Tool Access:\n\nYou can use the `Tavily Search` tool to retrieve relevant content, statistics, or examples to support each section you're writing.\n\nUse it **only** when the provided outline lacks enough information, or if the section requires factual grounding.\n\nAlways cite the original link or indicate source where possible.\n\n\n# Goals\n\n1. Write each section (based on H2/H3 structure) as a complete and natural blog paragraph.\n\n2. Integrate the suggested long-tail keywords naturally into each section.\n\n3. When appropriate, use the `Tavily Search` tool to enrich your writing with relevant facts, examples, or quotes.\n\n4. Ensure each section is clear, engaging, and informative, suitable for both human readers and search engines.\n\n\n# Style Guidelines\n\n- Write in a tone appropriate to the audience. Be explanatory, not promotional, unless it's a marketing blog.\n\n- Avoid generic filler content. Prioritize clarity, structure, and value.\n\n- Ensure SEO keywords are embedded seamlessly, not forcefully.\n\n\n\n- Maintain writing rhythm. Vary sentence lengths. Use transitions between ideas.\n\n\n# Input\n\n\nYou will receive:\n\n- Blog title\n\n- Structured outline (including section titles, keywords, and descriptions)\n\n- Target audience\n\n- Blog type and user intent\n\nYou must **follow the outline strictly**. Write content **section-by-section**, based on the structure.\n\n\n# Output Format\n\n```markdown\n\n## H2: [Section Title]\n\n[Your generated content for this section \u2014 500-600 words, using keywords naturally.]\n\n",
+                                "temperature": 0.2,
+                                "temperatureEnabled": true,
+                                "tools": [
+                                    {
+                                        "component_name": "TavilySearch",
+                                        "name": "TavilySearch",
+                                        "params": {
+                                            "api_key": "",
+                                            "days": 7,
+                                            "exclude_domains": [],
+                                            "include_answer": false,
+                                            "include_domains": [],
+                                            "include_image_descriptions": false,
+                                            "include_images": false,
+                                            "include_raw_content": true,
+                                            "max_results": 5,
+                                            "outputs": {
+                                                "formalized_content": {
+                                                    "type": "string",
+                                                    "value": ""
+                                                },
+                                                "json": {
+                                                    "type": "Array<Object>",
+                                                    "value": []
+                                                }
+                                            },
+                                            "query": "sys.query",
+                                            "search_depth": "basic",
+                                            "topic": "general"
+                                        }
+                                    }
+                                ],
+                                "topPEnabled": false,
+                                "top_p": 0.75,
+                                "user_prompt": "",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Body Agent"
+                        },
+                        "dragging": false,
+                        "id": "Agent:EagerNailsRemain",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 889.0614605692713,
+                            "y": 247.00973041799065
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "description": "This is an agent for a specific task.",
+                                "user_prompt": "This is the order you need to send to the agent."
+                            },
+                            "label": "Tool",
+                            "name": "flow.tool_1"
+                        },
+                        "dragging": false,
+                        "id": "Tool:WickedDeerHeal",
+                        "measured": {
+                            "height": 44,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 853.2006404239659,
+                            "y": 364.37541577229143
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "toolNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "",
+                                "exception_comment": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": null,
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.5,
+                                "llm_id": "deepseek-chat@DeepSeek",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 5,
+                                "max_tokens": 4096,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "parameter": "Precise",
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.5,
+                                "prompts": [
+                                    {
+                                        "content": "The parse and keyword agent output is {Agent:ClearRabbitsScream@content}\n\nThe Outline agent output is {Agent:BetterSitesSend@content}\n\nThe Body agent output is {Agent:EagerNailsRemain@content}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "# Role\n\nYou are the **Editor_Agent**, responsible for finalizing the blog post for both human readability and SEO effectiveness.\n\n# Goals\n\n1. Polish the entire blog content for clarity, coherence, and style.\n\n2. Improve transitions between sections, ensure logical flow.\n\n3. Verify that keywords are used appropriately and effectively.\n\n4. Conduct a lightweight SEO audit \u2014 checking keyword density, structure (H1/H2/H3), and overall searchability.\n\n\n\n# Style Guidelines\n\n- Be precise. Avoid bloated or vague language.\n\n- Maintain an informative and engaging tone, suitable to the target audience.\n\n- Do not remove keywords unless absolutely necessary for clarity.\n\n- Ensure paragraph flow and section continuity.\n\n\n# Input\n\nYou will receive:\n\n- Full blog content, written section-by-section\n\n- Original outline with suggested keywords\n\n- Target audience and writing type\n\n# Output Format\n\n```markdown\n\n[The revised, fully polished blog post content goes here.]\n\n",
+                                "temperature": 0.2,
+                                "temperatureEnabled": true,
+                                "tools": [],
+                                "topPEnabled": false,
+                                "top_p": 0.75,
+                                "user_prompt": "",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "Editor Agent"
+                        },
+                        "dragging": false,
+                        "id": "Agent:LovelyHeadsOwn",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 1160.3332919804993,
+                            "y": 149.50806732882472
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "content": [
+                                    "{Agent:LovelyHeadsOwn@content}"
+                                ]
+                            },
+                            "label": "Message",
+                            "name": "Response"
+                        },
+                        "dragging": false,
+                        "id": "Message:LegalBeansBet",
+                        "measured": {
+                            "height": 56,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 1370.6665839609984,
+                            "y": 267.0323933738015
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "messageNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "This workflow automatically generates a complete SEO-optimized blog article based on a simple user input. You don\u2019t need any writing experience. Just provide a topic or short request \u2014 the system will handle the rest.\n\nThe process includes the following key stages:\n\n1. **Understanding your topic and goals**\n2. **Designing the blog structure**\n3. **Writing high-quality content**\n\n\n"
+                            },
+                            "label": "Note",
+                            "name": "Workflow Overall Description"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 205,
+                        "id": "Note:SlimyGhostsWear",
+                        "measured": {
+                            "height": 205,
+                            "width": 415
+                        },
+                        "position": {
+                            "x": -284.3143151688742,
+                            "y": 150.47632147913419
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 415
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis agent reads the user\u2019s input and figures out what kind of blog needs to be written.\n\n**What it does**:\n- Understands the main topic you want to write about  \n- Identifies who the blog is for (e.g., beginners, marketers, developers)  \n- Determines the writing purpose (e.g., SEO traffic, product promotion, education)  \n- Suggests 3\u20135 long-tail SEO keywords related to the topic"
+                            },
+                            "label": "Note",
+                            "name": "Parse And Keyword Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 152,
+                        "id": "Note:EmptyChairsShake",
+                        "measured": {
+                            "height": 152,
+                            "width": 340
+                        },
+                        "position": {
+                            "x": 295.04147626768133,
+                            "y": 372.2755718118446
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 340
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis agent builds the blog structure \u2014 just like writing a table of contents before you start writing the full article.\n\n**What it does**:\n- Suggests a clear blog title that includes important keywords  \n- Breaks the article into sections using H2 and H3 headings (like a professional blog layout)  \n- Assigns 1\u20132 recommended keywords to each section to help with SEO  \n- Follows the writing goal and target audience set in the previous step"
+                            },
+                            "label": "Note",
+                            "name": "Outline Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 146,
+                        "id": "Note:TallMelonsNotice",
+                        "measured": {
+                            "height": 146,
+                            "width": 343
+                        },
+                        "position": {
+                            "x": 598.5644991893463,
+                            "y": 5.801054564756448
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 343
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis agent is responsible for writing the actual content of the blog \u2014 paragraph by paragraph \u2014 based on the outline created earlier.\n\n**What it does**:\n- Looks at each H2/H3 section in the outline  \n- Writes 150\u2013220 words of clear, helpful, and well-structured content per section  \n- Includes the suggested SEO keywords naturally (not keyword stuffing)  \n- Uses real examples or facts if needed (by calling a web search tool like Tavily)"
+                            },
+                            "label": "Note",
+                            "name": "Body Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 137,
+                        "id": "Note:RipeCougarsBuild",
+                        "measured": {
+                            "height": 137,
+                            "width": 319
+                        },
+                        "position": {
+                            "x": 860.4854129814981,
+                            "y": 427.2196835690842
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 319
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "**Purpose**:  \nThis agent reviews the entire blog draft to make sure it is smooth, professional, and SEO-friendly. It acts like a human editor before publishing.\n\n**What it does**:\n- Polishes the writing: improves sentence clarity, fixes awkward phrasing  \n- Makes sure the content flows well from one section to the next  \n- Double-checks keyword usage: are they present, natural, and not overused?  \n- Verifies the blog structure (H1, H2, H3 headings) is correct  \n- Adds two key SEO elements:\n  - **Meta Title** (shows up in search results)\n  - **Meta Description** (summary for Google and social sharing)"
+                            },
+                            "label": "Note",
+                            "name": "Editor Agent"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "height": 146,
+                        "id": "Note:OpenTurkeysSell",
+                        "measured": {
+                            "height": 146,
+                            "width": 320
+                        },
+                        "position": {
+                            "x": 1129,
+                            "y": -30
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 320
+                    }
+                ]
+            },
+            "history": [],
+            "messages": [],
+            "path": [],
+            "retrieval": []
+        },
+    "avatar": "data:image/jpeg;base64,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"
+}

agent/templates/sql_assistant.json

@@ -0,0 +1,716 @@
+{
+    "id": 17,
+    "title": {
+        "en": "SQL Assistant",
+        "zh": "SQL助理"},
+    "description": {
+        "en": "SQL Assistant is an AI-powered tool that lets business users turn plain-English questions into fully formed SQL queries. Simply type your question (e.g., “Show me last quarter’s top 10 products by revenue”) and SQL Assistant generates the exact SQL, runs it against your database, and returns the results in seconds. ",
+        "zh": "用户能够将简单文本问题转化为完整的SQL查询并输出结果。只需输入您的问题（例如，“展示上个季度前十名按收入排序的产品”），SQL助理就会生成精确的SQL语句，对其运行您的数据库，并几秒钟内返回结果。"},
+    "canvas_type": "Marketing",
+    "dsl": {
+            "components": {
+                "Agent:WickedGoatsDivide": {
+                    "downstream": [
+                        "ExeSQL:TiredShirtsPull"
+                    ],
+                    "obj": {
+                        "component_name": "Agent",
+                        "params": {
+                            "delay_after_error": 1,
+                            "description": "",
+                            "exception_default_value": "",
+                            "exception_goto": [],
+                            "exception_method": "",
+                            "frequencyPenaltyEnabled": false,
+                            "frequency_penalty": 0.7,
+                            "llm_id": "qwen-max@Tongyi-Qianwen",
+                            "maxTokensEnabled": false,
+                            "max_retries": 3,
+                            "max_rounds": 5,
+                            "max_tokens": 256,
+                            "mcp": [],
+                            "message_history_window_size": 12,
+                            "outputs": {
+                                "content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "presencePenaltyEnabled": false,
+                            "presence_penalty": 0.4,
+                            "prompts": [
+                                {
+                                    "content": "User's query: {sys.query}\n\nSchema: {Retrieval:HappyTiesFilm@formalized_content}\n\nSamples about question to SQL: {Retrieval:SmartNewsHammer@formalized_content}\n\nDescription about meanings of tables and files: {Retrieval:SweetDancersAppear@formalized_content}",
+                                    "role": "user"
+                                }
+                            ],
+                            "sys_prompt": "### ROLE\nYou are a Text-to-SQL assistant.  \nGiven a relational database schema and a natural-language request, you must produce a **single, syntactically-correct MySQL query** that answers the request.  \nReturn **nothing except the SQL statement itself**\u2014no code fences, no commentary, no explanations, no comments, no trailing semicolon if not required.\n\n\n###  EXAMPLES  \n-- Example 1  \nUser: List every product name and its unit price.  \nSQL:\nSELECT name, unit_price FROM Products;\n\n-- Example 2  \nUser: Show the names and emails of customers who placed orders in January 2025.  \nSQL:\nSELECT DISTINCT c.name, c.email\nFROM Customers c\nJOIN Orders o ON o.customer_id = c.id\nWHERE o.order_date BETWEEN '2025-01-01' AND '2025-01-31';\n\n-- Example 3  \nUser: How many orders have a status of \"Completed\" for each month in 2024?  \nSQL:\nSELECT DATE_FORMAT(order_date, '%Y-%m') AS month,\n       COUNT(*) AS completed_orders\nFROM Orders\nWHERE status = 'Completed'\n  AND YEAR(order_date) = 2024\nGROUP BY month\nORDER BY month;\n\n-- Example 4  \nUser: Which products generated at least \\$10 000 in total revenue?  \nSQL:\nSELECT p.id, p.name, SUM(oi.quantity * oi.unit_price) AS revenue\nFROM Products p\nJOIN OrderItems oi ON oi.product_id = p.id\nGROUP BY p.id, p.name\nHAVING revenue >= 10000\nORDER BY revenue DESC;\n\n\n### OUTPUT GUIDELINES\n1. Think through the schema and the request.  \n2. Write **only** the final MySQL query.  \n3. Do **not** wrap the query in back-ticks or markdown fences.  \n4. Do **not** add explanations, comments, or additional text\u2014just the SQL.",
+                            "temperature": 0.1,
+                            "temperatureEnabled": false,
+                            "tools": [],
+                            "topPEnabled": false,
+                            "top_p": 0.3,
+                            "user_prompt": "",
+                            "visual_files_var": ""
+                        }
+                    },
+                    "upstream": [
+                        "Retrieval:HappyTiesFilm",
+                        "Retrieval:SmartNewsHammer",
+                        "Retrieval:SweetDancersAppear"
+                    ]
+                },
+                "ExeSQL:TiredShirtsPull": {
+                    "downstream": [
+                        "Message:ShaggyMasksAttend"
+                    ],
+                    "obj": {
+                        "component_name": "ExeSQL",
+                        "params": {
+                            "database": "",
+                            "db_type": "mysql",
+                            "host": "",
+                            "max_records": 1024,
+                            "outputs": {
+                                "formalized_content": {
+                                    "type": "string",
+                                    "value": ""
+                                },
+                                "json": {
+                                    "type": "Array<Object>",
+                                    "value": []
+                                }
+                            },
+                            "password": "20010812Yy!",
+                            "port": 3306,
+                            "sql": "{Agent:WickedGoatsDivide@content}",
+                            "username": "13637682833@163.com"
+                        }
+                    },
+                    "upstream": [
+                        "Agent:WickedGoatsDivide"
+                    ]
+                },
+                "Message:ShaggyMasksAttend": {
+                    "downstream": [],
+                    "obj": {
+                        "component_name": "Message",
+                        "params": {
+                            "content": [
+                                "{ExeSQL:TiredShirtsPull@formalized_content}"
+                            ]
+                        }
+                    },
+                    "upstream": [
+                        "ExeSQL:TiredShirtsPull"
+                    ]
+                },
+                "Retrieval:HappyTiesFilm": {
+                    "downstream": [
+                        "Agent:WickedGoatsDivide"
+                    ],
+                    "obj": {
+                        "component_name": "Retrieval",
+                        "params": {
+                            "cross_languages": [],
+                            "empty_response": "",
+                            "kb_ids": [],
+                            "keywords_similarity_weight": 0.7,
+                            "outputs": {
+                                "formalized_content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "query": "{sys.query}",
+                            "rerank_id": "",
+                            "similarity_threshold": 0.2,
+                            "top_k": 1024,
+                            "top_n": 8,
+                            "use_kg": false
+                        }
+                    },
+                    "upstream": [
+                        "begin"
+                    ]
+                },
+                "Retrieval:SmartNewsHammer": {
+                    "downstream": [
+                        "Agent:WickedGoatsDivide"
+                    ],
+                    "obj": {
+                        "component_name": "Retrieval",
+                        "params": {
+                            "cross_languages": [],
+                            "empty_response": "",
+                            "kb_ids": [],
+                            "keywords_similarity_weight": 0.7,
+                            "outputs": {
+                                "formalized_content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "query": "{sys.query}",
+                            "rerank_id": "",
+                            "similarity_threshold": 0.2,
+                            "top_k": 1024,
+                            "top_n": 8,
+                            "use_kg": false
+                        }
+                    },
+                    "upstream": [
+                        "begin"
+                    ]
+                },
+                "Retrieval:SweetDancersAppear": {
+                    "downstream": [
+                        "Agent:WickedGoatsDivide"
+                    ],
+                    "obj": {
+                        "component_name": "Retrieval",
+                        "params": {
+                            "cross_languages": [],
+                            "empty_response": "",
+                            "kb_ids": [],
+                            "keywords_similarity_weight": 0.7,
+                            "outputs": {
+                                "formalized_content": {
+                                    "type": "string",
+                                    "value": ""
+                                }
+                            },
+                            "query": "{sys.query}",
+                            "rerank_id": "",
+                            "similarity_threshold": 0.2,
+                            "top_k": 1024,
+                            "top_n": 8,
+                            "use_kg": false
+                        }
+                    },
+                    "upstream": [
+                        "begin"
+                    ]
+                },
+                "begin": {
+                    "downstream": [
+                        "Retrieval:HappyTiesFilm",
+                        "Retrieval:SmartNewsHammer",
+                        "Retrieval:SweetDancersAppear"
+                    ],
+                    "obj": {
+                        "component_name": "Begin",
+                        "params": {
+                            "enablePrologue": true,
+                            "inputs": {},
+                            "mode": "conversational",
+                            "prologue": "Hi! I'm your SQL assistant. What can I do for you?"
+                        }
+                    },
+                    "upstream": []
+                }
+            },
+            "globals": {
+                "sys.conversation_turns": 0,
+                "sys.files": [],
+                "sys.query": "",
+                "sys.user_id": ""
+            },
+            "graph": {
+                "edges": [
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__beginstart-Retrieval:HappyTiesFilmend",
+                        "source": "begin",
+                        "sourceHandle": "start",
+                        "target": "Retrieval:HappyTiesFilm",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "id": "xy-edge__beginstart-Retrieval:SmartNewsHammerend",
+                        "source": "begin",
+                        "sourceHandle": "start",
+                        "target": "Retrieval:SmartNewsHammer",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__beginstart-Retrieval:SweetDancersAppearend",
+                        "source": "begin",
+                        "sourceHandle": "start",
+                        "target": "Retrieval:SweetDancersAppear",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Retrieval:HappyTiesFilmstart-Agent:WickedGoatsDivideend",
+                        "source": "Retrieval:HappyTiesFilm",
+                        "sourceHandle": "start",
+                        "target": "Agent:WickedGoatsDivide",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Retrieval:SmartNewsHammerstart-Agent:WickedGoatsDivideend",
+                        "markerEnd": "logo",
+                        "source": "Retrieval:SmartNewsHammer",
+                        "sourceHandle": "start",
+                        "style": {
+                            "stroke": "rgba(91, 93, 106, 1)",
+                            "strokeWidth": 1
+                        },
+                        "target": "Agent:WickedGoatsDivide",
+                        "targetHandle": "end",
+                        "type": "buttonEdge",
+                        "zIndex": 1001
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Retrieval:SweetDancersAppearstart-Agent:WickedGoatsDivideend",
+                        "markerEnd": "logo",
+                        "source": "Retrieval:SweetDancersAppear",
+                        "sourceHandle": "start",
+                        "style": {
+                            "stroke": "rgba(91, 93, 106, 1)",
+                            "strokeWidth": 1
+                        },
+                        "target": "Agent:WickedGoatsDivide",
+                        "targetHandle": "end",
+                        "type": "buttonEdge",
+                        "zIndex": 1001
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__Agent:WickedGoatsDividestart-ExeSQL:TiredShirtsPullend",
+                        "source": "Agent:WickedGoatsDivide",
+                        "sourceHandle": "start",
+                        "target": "ExeSQL:TiredShirtsPull",
+                        "targetHandle": "end"
+                    },
+                    {
+                        "data": {
+                            "isHovered": false
+                        },
+                        "id": "xy-edge__ExeSQL:TiredShirtsPullstart-Message:ShaggyMasksAttendend",
+                        "source": "ExeSQL:TiredShirtsPull",
+                        "sourceHandle": "start",
+                        "target": "Message:ShaggyMasksAttend",
+                        "targetHandle": "end"
+                    }
+                ],
+                "nodes": [
+                    {
+                        "data": {
+                            "form": {
+                                "enablePrologue": true,
+                                "inputs": {},
+                                "mode": "conversational",
+                                "prologue": "Hi! I'm your SQL assistant. What can I do for you?"
+                            },
+                            "label": "Begin",
+                            "name": "begin"
+                        },
+                        "id": "begin",
+                        "measured": {
+                            "height": 48,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 50,
+                            "y": 200
+                        },
+                        "selected": false,
+                        "sourcePosition": "left",
+                        "targetPosition": "right",
+                        "type": "beginNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "cross_languages": [],
+                                "empty_response": "",
+                                "kb_ids": [],
+                                "keywords_similarity_weight": 0.7,
+                                "outputs": {
+                                    "formalized_content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "query": "{sys.query}",
+                                "rerank_id": "",
+                                "similarity_threshold": 0.2,
+                                "top_k": 1024,
+                                "top_n": 8,
+                                "use_kg": false
+                            },
+                            "label": "Retrieval",
+                            "name": "Schema"
+                        },
+                        "dragging": false,
+                        "id": "Retrieval:HappyTiesFilm",
+                        "measured": {
+                            "height": 96,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 414,
+                            "y": 20.5
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "retrievalNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "cross_languages": [],
+                                "empty_response": "",
+                                "kb_ids": [],
+                                "keywords_similarity_weight": 0.7,
+                                "outputs": {
+                                    "formalized_content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "query": "{sys.query}",
+                                "rerank_id": "",
+                                "similarity_threshold": 0.2,
+                                "top_k": 1024,
+                                "top_n": 8,
+                                "use_kg": false
+                            },
+                            "label": "Retrieval",
+                            "name": "Question to SQL"
+                        },
+                        "dragging": false,
+                        "id": "Retrieval:SmartNewsHammer",
+                        "measured": {
+                            "height": 96,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 406.5,
+                            "y": 175.5
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "retrievalNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "cross_languages": [],
+                                "empty_response": "",
+                                "kb_ids": [],
+                                "keywords_similarity_weight": 0.7,
+                                "outputs": {
+                                    "formalized_content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "query": "{sys.query}",
+                                "rerank_id": "",
+                                "similarity_threshold": 0.2,
+                                "top_k": 1024,
+                                "top_n": 8,
+                                "use_kg": false
+                            },
+                            "label": "Retrieval",
+                            "name": "Database Description"
+                        },
+                        "dragging": false,
+                        "id": "Retrieval:SweetDancersAppear",
+                        "measured": {
+                            "height": 96,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 403.5,
+                            "y": 328
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "retrievalNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "delay_after_error": 1,
+                                "description": "",
+                                "exception_default_value": "",
+                                "exception_goto": [],
+                                "exception_method": "",
+                                "frequencyPenaltyEnabled": false,
+                                "frequency_penalty": 0.7,
+                                "llm_id": "qwen-max@Tongyi-Qianwen",
+                                "maxTokensEnabled": false,
+                                "max_retries": 3,
+                                "max_rounds": 5,
+                                "max_tokens": 256,
+                                "mcp": [],
+                                "message_history_window_size": 12,
+                                "outputs": {
+                                    "content": {
+                                        "type": "string",
+                                        "value": ""
+                                    }
+                                },
+                                "presencePenaltyEnabled": false,
+                                "presence_penalty": 0.4,
+                                "prompts": [
+                                    {
+                                        "content": "User's query: {sys.query}\n\nSchema: {Retrieval:HappyTiesFilm@formalized_content}\n\nSamples about question to SQL: {Retrieval:SmartNewsHammer@formalized_content}\n\nDescription about meanings of tables and files: {Retrieval:SweetDancersAppear@formalized_content}",
+                                        "role": "user"
+                                    }
+                                ],
+                                "sys_prompt": "### ROLE\nYou are a Text-to-SQL assistant.  \nGiven a relational database schema and a natural-language request, you must produce a **single, syntactically-correct MySQL query** that answers the request.  \nReturn **nothing except the SQL statement itself**\u2014no code fences, no commentary, no explanations, no comments, no trailing semicolon if not required.\n\n\n###  EXAMPLES  \n-- Example 1  \nUser: List every product name and its unit price.  \nSQL:\nSELECT name, unit_price FROM Products;\n\n-- Example 2  \nUser: Show the names and emails of customers who placed orders in January 2025.  \nSQL:\nSELECT DISTINCT c.name, c.email\nFROM Customers c\nJOIN Orders o ON o.customer_id = c.id\nWHERE o.order_date BETWEEN '2025-01-01' AND '2025-01-31';\n\n-- Example 3  \nUser: How many orders have a status of \"Completed\" for each month in 2024?  \nSQL:\nSELECT DATE_FORMAT(order_date, '%Y-%m') AS month,\n       COUNT(*) AS completed_orders\nFROM Orders\nWHERE status = 'Completed'\n  AND YEAR(order_date) = 2024\nGROUP BY month\nORDER BY month;\n\n-- Example 4  \nUser: Which products generated at least \\$10 000 in total revenue?  \nSQL:\nSELECT p.id, p.name, SUM(oi.quantity * oi.unit_price) AS revenue\nFROM Products p\nJOIN OrderItems oi ON oi.product_id = p.id\nGROUP BY p.id, p.name\nHAVING revenue >= 10000\nORDER BY revenue DESC;\n\n\n### OUTPUT GUIDELINES\n1. Think through the schema and the request.  \n2. Write **only** the final MySQL query.  \n3. Do **not** wrap the query in back-ticks or markdown fences.  \n4. Do **not** add explanations, comments, or additional text\u2014just the SQL.",
+                                "temperature": 0.1,
+                                "temperatureEnabled": false,
+                                "tools": [],
+                                "topPEnabled": false,
+                                "top_p": 0.3,
+                                "user_prompt": "",
+                                "visual_files_var": ""
+                            },
+                            "label": "Agent",
+                            "name": "SQL Generator "
+                        },
+                        "dragging": false,
+                        "id": "Agent:WickedGoatsDivide",
+                        "measured": {
+                            "height": 84,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 981,
+                            "y": 174
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "agentNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "database": "",
+                                "db_type": "mysql",
+                                "host": "",
+                                "max_records": 1024,
+                                "outputs": {
+                                    "formalized_content": {
+                                        "type": "string",
+                                        "value": ""
+                                    },
+                                    "json": {
+                                        "type": "Array<Object>",
+                                        "value": []
+                                    }
+                                },
+                                "password": "20010812Yy!",
+                                "port": 3306,
+                                "sql": "{Agent:WickedGoatsDivide@content}",
+                                "username": "13637682833@163.com"
+                            },
+                            "label": "ExeSQL",
+                            "name": "ExeSQL"
+                        },
+                        "dragging": false,
+                        "id": "ExeSQL:TiredShirtsPull",
+                        "measured": {
+                            "height": 56,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 1211.5,
+                            "y": 212.5
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "ragNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "content": [
+                                    "{ExeSQL:TiredShirtsPull@formalized_content}"
+                                ]
+                            },
+                            "label": "Message",
+                            "name": "Message"
+                        },
+                        "dragging": false,
+                        "id": "Message:ShaggyMasksAttend",
+                        "measured": {
+                            "height": 56,
+                            "width": 200
+                        },
+                        "position": {
+                            "x": 1447.3125,
+                            "y": 181.5
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "messageNode"
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "Searches for relevant database creation statements.\n\nIt should label with a knowledgebase to which the schema is dumped in. You could use \" General \" as parsing method, \" 2 \" as chunk size and \" ; \"  as delimiter."
+                            },
+                            "label": "Note",
+                            "name": "Note Schema"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 188,
+                        "id": "Note:ThickClubsFloat",
+                        "measured": {
+                            "height": 188,
+                            "width": 392
+                        },
+                        "position": {
+                            "x": 689,
+                            "y": -180.31251144409183
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 392
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "Searches for samples about question to SQL. \n\nYou could use \" Q&A \" as parsing method.\n\nPlease check this dataset:\nhttps://huggingface.co/datasets/InfiniFlow/text2sql"
+                            },
+                            "label": "Note",
+                            "name": "Note: Question to SQL"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 154,
+                        "id": "Note:ElevenLionsJoke",
+                        "measured": {
+                            "height": 154,
+                            "width": 345
+                        },
+                        "position": {
+                            "x": 693.5,
+                            "y": 138
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 345
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "Searches for description about meanings of tables and fields.\n\nYou could use \" General \" as parsing method, \" 2 \" as chunk size and \" ### \"  as delimiter."
+                            },
+                            "label": "Note",
+                            "name": "Note: Database Description"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 158,
+                        "id": "Note:ManyRosesTrade",
+                        "measured": {
+                            "height": 158,
+                            "width": 408
+                        },
+                        "position": {
+                            "x": 691.5,
+                            "y": 435.69736389555317
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 408
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "The Agent learns which tables may be available based on the responses from three knowledge bases and converts the user's input into SQL statements."
+                            },
+                            "label": "Note",
+                            "name": "Note: SQL Generator"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "height": 132,
+                        "id": "Note:RudeHousesInvite",
+                        "measured": {
+                            "height": 132,
+                            "width": 383
+                        },
+                        "position": {
+                            "x": 1106.9254833678003,
+                            "y": 290.5891036507015
+                        },
+                        "resizing": false,
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode",
+                        "width": 383
+                    },
+                    {
+                        "data": {
+                            "form": {
+                                "text": "Connect to your database to execute SQL statements."
+                            },
+                            "label": "Note",
+                            "name": "Note: SQL Executor"
+                        },
+                        "dragHandle": ".note-drag-handle",
+                        "dragging": false,
+                        "id": "Note:HungryBatsLay",
+                        "measured": {
+                            "height": 136,
+                            "width": 255
+                        },
+                        "position": {
+                            "x": 1185,
+                            "y": -30
+                        },
+                        "selected": false,
+                        "sourcePosition": "right",
+                        "targetPosition": "left",
+                        "type": "noteNode"
+                    }
+                ]
+            },
+            "history": [],
+            "messages": [],
+            "path": [],
+            "retrieval": []
+        },
+    "avatar": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAcFBQYFBAcGBQYIBwcIChELCgkJChUPEAwRGBUaGRgVGBcbHichGx0lHRcYIi4iJSgpKywrGiAvMy8qMicqKyr/2wBDAQcICAoJChQLCxQqHBgcKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKir/wAARCAAwADADAREAAhEBAxEB/8QAGgAAAwEBAQEAAAAAAAAAAAAABQYHBAMAAf/EADIQAAEDAwMCBAMHBQAAAAAAAAECAwQFESEABjESEyJBUYEUYXEHFSNSkaGxMjNictH/xAAZAQADAQEBAAAAAAAAAAAAAAACAwQBAAX/xAAlEQACAgICAgEEAwAAAAAAAAABAgARAyESMQRBEyIycYFCkbH/2gAMAwEAAhEDEQA/AKHt2DGpNHXDLrZdWtSrIub39tZ5GbGwPA+pmDFkX7x7idvra85xqQaFNkxUTVIVJQzf8QpBFjbgEenNs681MnA9WJ6fEOKJoxVpSpFLTCo6KEZlTlLcQBIJS20hAv1D1ve+qPk52b0IsYuIGtyt7ZkVVNP+H3A5GdlN2u7GQUBSfmkk8cXH10tmLD6Yl0CG5qmTXBMZiQEMuvupUoKdc6UeEi4FsqOeBxrsKnv1AY+hJ2l5yfu6qQ6/UZtPDRHZ+Eldpsqz1hSrXJGLXwRxqxUQizFs7galPYUFDKT+h15oMuImspQpFiL+2i1A3A1bgxmixUgwlT8ZfgJ/y8P8HXdRuPZoxaqtfkQKbKqF03jtEoDeFKV1lNgfK4H764XfccVUgipvdiwKpFaXMLklFg4juuqV0m3Izg/MaEZCDYMScYqiJOd6xmqfUVfBJcWwtHV1Elfi87k51ViyhrsxL4ivQj1KrFZjTGjTJ8aShdyph5SUqFhwPzX9jpC0dXUqZK3ViHNq7oNaVJjz2Vw5LCrdKknpULZyfMf801MfI1e5NmpAGHUL12EZNFWWlhXSUuWHKgk3xomwEDuDhzLysySU9EndEVyIz3GmxJR+KpBIdCLlRHn/AFEjjIF9AMJlZ8gLZ/qUiJSg1Tu0HO4plFj4FC1h9NYfHIU7kwzgnqCJlKLiCO2s6hKytWiPJoFdfnLW7HS0or6bqXbjg2AI99XjAa3NPlL6jFTduOR5sd1+oyfjQMONqI7QOMA4V7/pqjHjC9SLNn56I1HiqrqTUKM0hbq2lpst5CQSST54xjSPJbICOHUhawISiRQ02T2Uq6AAkqFj/GquJQks1iEr/INLU82bploKSFXusG9xfjHofXQuQUNRoQqQT0ZwVEST5687iZWGgpDsebNbaTDfKVL/ALnbQU/UkKNhjXpFt0BJBVXe/wAGGG6YMlvvNkjlBGmKeJimHIVc0TY89akCKspT28C5BKgDyR7fvrCFI+q/1DQsvVfudYcVyKw49KU6tZyQbmwHFhrOKr9s0uz0CAIpbr3RKo1Rbh02C4HJISp2ZIz0pJ8IQk5Nr/QXznSX6NSnGAwHI/gD/TM+3vtAj1arJpcpgtPdPSH0kFt5wDxAWOOLgamIAFwijCfD927N2tGXuNxlK2W0occUhJWpR+QzzrPjc+pvyqT3Ftf2zbObf7YYecb6CrrDAGfy20wYMkA5Vjbtev7b3nEcXRela27d1ogoWi/rnQsjrqZzHdwzKoKUsqWz3mOnJUlZJt8uokD621w+RdzgynUkUpoUafPZXMnSHlrKluyX1Eug8XF7GwxbgWxrubMO5WmNRsCKtLfcY3rAU0nIltkBP+w0X8Jjdz//2Q=="
+}

agent/test/client.py

@@ -0,0 +1,46 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import argparse
+import os
+from agent.canvas import Canvas
+from api import settings
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    dsl_default_path = os.path.join(
+        os.path.dirname(os.path.realpath(__file__)),
+        "dsl_examples",
+        "retrieval_and_generate.json",
+    )
+    parser.add_argument('-s', '--dsl', default=dsl_default_path, help="input dsl", action='store', required=True)
+    parser.add_argument('-t', '--tenant_id', default=False, help="Tenant ID", action='store', required=True)
+    parser.add_argument('-m', '--stream', default=False, help="Stream output", action='store_true', required=False)
+    args = parser.parse_args()
+
+    settings.init_settings()
+    canvas = Canvas(open(args.dsl, "r").read(), args.tenant_id)
+    if canvas.get_prologue():
+        print(f"==================== Bot =====================\n>    {canvas.get_prologue()}", end='')
+    query = ""
+    while True:
+        canvas.reset(True)
+        query = input("\n==================== User =====================\n> ")
+        ans = canvas.run(query=query)
+        print("==================== Bot =====================\n>    ", end='')
+        for ans in canvas.run(query=query):
+            print(ans, end='\n', flush=True)
+
+        print(canvas.path)

agent/test/dsl_examples/categorize_and_agent_with_tavily.json

@@ -0,0 +1,85 @@
+{
+  "components": {
+            "begin": {
+                "obj":{
+                    "component_name": "Begin",
+                    "params": {
+                      "prologue": "Hi there!"
+                    }
+                },
+                "downstream": ["categorize:0"],
+                "upstream": []
+            },
+            "categorize:0": {
+                "obj": {
+                    "component_name": "Categorize",
+                    "params": {
+                      "llm_id": "deepseek-chat",
+                      "category_description": {
+                        "product_related": {
+                          "description": "The question is about the product usage, appearance and how it works.",
+                          "to": ["agent:0"]
+                        },
+                        "others": {
+                          "description": "The question is not about the product usage, appearance and how it works.",
+                          "to": ["message:0"]
+                        }
+                      }
+                    }
+                },
+                "downstream": [],
+                "upstream": ["begin"]
+            },
+            "message:0": {
+                "obj":{
+                    "component_name": "Message",
+                    "params": {
+                      "content": [
+                        "Sorry, I don't know. I'm an AI bot."
+                      ]
+                    }
+                },
+                "downstream": [],
+                "upstream": ["categorize:0"]
+            },
+            "agent:0": {
+                "obj": {
+                    "component_name": "Agent",
+                    "params": {
+                      "llm_id": "deepseek-chat",
+                      "sys_prompt": "You are a smart researcher. You could generate proper queries to search. According to the search results, you could deside next query if the result is not enough.",
+                      "temperature": 0.2,
+                      "llm_enabled_tools": [
+                        {
+                            "component_name": "TavilySearch",
+                            "params": {
+                              "api_key": "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"
+                            }
+                        }
+                      ]
+                    }
+                },
+                "downstream": ["message:1"],
+                "upstream": ["categorize:0"]
+            },
+            "message:1": {
+                "obj": {
+                    "component_name": "Message",
+                    "params": {
+                      "content": ["{agent:0@content}"]
+                    }
+                },
+                "downstream": [],
+                "upstream": ["agent:0"]
+            }
+  },
+  "history": [],
+  "path": [],
+  "retrival": {"chunks": [], "doc_aggs": []},
+  "globals": {
+    "sys.query": "",
+    "sys.user_id": "",
+    "sys.conversation_turns": 0,
+    "sys.files": []
+  }
+}

agent/test/dsl_examples/exesql.json

@@ -0,0 +1,43 @@
+{
+  "components": {
+            "begin": {
+                "obj":{
+                    "component_name": "Begin",
+                    "params": {
+                      "prologue": "Hi there!"
+                    }
+                },
+                "downstream": ["answer:0"],
+                "upstream": []
+            },
+            "answer:0": {
+                "obj": {
+                    "component_name": "Answer",
+                    "params": {}
+                },
+                "downstream": ["exesql:0"],
+                "upstream": ["begin", "exesql:0"]
+            },
+            "exesql:0": {
+                "obj": {
+                    "component_name": "ExeSQL",
+                    "params": {
+                                    "database": "rag_flow",
+                                    "username": "root",
+                                    "host": "mysql",
+                                    "port": 3306,
+                                    "password": "infini_rag_flow",
+				    "top_n": 3
+                    }
+                },
+                "downstream": ["answer:0"],
+                "upstream": ["answer:0"]
+            }
+  },
+  "history": [],
+  "messages": [],
+  "reference": {},
+  "path": [],
+  "answer": []
+}
+

agent/test/dsl_examples/headhunter_zh.json

@@ -0,0 +1,210 @@
+{
+  "components": {
+    "begin": {
+      "obj": {
+        "component_name": "Begin",
+        "params": {
+          "prologue": "您好！我是AGI方向的猎头，了解到您是这方面的大佬，然后冒昧的就联系到您。这边有个机会想和您分享，RAGFlow正在招聘您这个岗位的资深的工程师不知道您那边是不是感兴趣？"
+        }
+      },
+      "downstream": ["answer:0"],
+      "upstream": []
+    },
+    "answer:0": {
+      "obj": {
+        "component_name": "Answer",
+        "params": {}
+      },
+      "downstream": ["categorize:0"],
+      "upstream": ["begin", "message:reject"]
+    },
+    "categorize:0": {
+      "obj": {
+        "component_name": "Categorize",
+        "params": {
+          "llm_id": "deepseek-chat",
+          "category_description": {
+            "about_job": {
+              "description": "该问题关于职位本身或公司的信息。",
+              "examples": "什么岗位？\n汇报对象是谁?\n公司多少人？\n公司有啥产品？\n具体工作内容是啥？\n地点哪里？\n双休吗？",
+              "to": "retrieval:0"
+            },
+            "casual": {
+              "description": "该问题不关于职位本身或公司的信息，属于闲聊。",
+              "examples": "你好\n好久不见\n你男的女的？\n你是猴子派来的救兵吗？\n上午开会了?\n你叫啥？\n最近市场如何?生意好做吗？",
+              "to": "generate:casual"
+            },
+            "interested": {
+              "description": "该回答表示他对于该职位感兴趣。",
+              "examples": "嗯\n说吧\n说说看\n还好吧\n是的\n哦\nyes\n具体说说",
+              "to": "message:introduction"
+            },
+            "answer": {
+              "description": "该回答表示他对于该职位不感兴趣，或感觉受到骚扰。",
+              "examples": "不需要\n不感兴趣\n暂时不看\n不要\nno\n我已经不干这个了\n我不是这个方向的",
+              "to": "message:reject"
+            }
+          }
+        }
+      },
+      "downstream": [
+        "message:introduction",
+        "generate:casual",
+        "message:reject",
+        "retrieval:0"
+      ],
+      "upstream": ["answer:0"]
+    },
+    "message:introduction": {
+      "obj": {
+        "component_name": "Message",
+        "params": {
+          "messages": [
+            "我简单介绍以下：\nRAGFlow 是一款基于深度文档理解构建的开源 RAG（Retrieval-Augmented Generation）引擎。RAGFlow 可以为各种规模的企业及个人提供一套精简的 RAG 工作流程，结合大语言模型（LLM）针对用户各类不同的复杂格式数据提供可靠的问答以及有理有据的引用。https://github.com/infiniflow/ragflow\n您那边还有什么要了解的？"
+          ]
+        }
+      },
+      "downstream": ["answer:1"],
+      "upstream": ["categorize:0"]
+    },
+    "answer:1": {
+      "obj": {
+        "component_name": "Answer",
+        "params": {}
+      },
+      "downstream": ["categorize:1"],
+      "upstream": [
+        "message:introduction",
+        "generate:aboutJob",
+        "generate:casual",
+        "generate:get_wechat",
+        "generate:nowechat"
+      ]
+    },
+    "categorize:1": {
+      "obj": {
+        "component_name": "Categorize",
+        "params": {
+          "llm_id": "deepseek-chat",
+          "category_description": {
+            "about_job": {
+              "description": "该问题关于职位本身或公司的信息。",
+              "examples": "什么岗位？\n汇报对象是谁?\n公司多少人？\n公司有啥产品？\n具体工作内容是啥？\n地点哪里？\n双休吗？",
+              "to": "retrieval:0"
+            },
+            "casual": {
+              "description": "该问题不关于职位本身或公司的信息，属于闲聊。",
+              "examples": "你好\n好久不见\n你男的女的？\n你是猴子派来的救兵吗？\n上午开会了?\n你叫啥？\n最近市场如何?生意好做吗？",
+              "to": "generate:casual"
+            },
+            "wechat": {
+              "description": "该回答表示他愿意加微信,或者已经报了微信号。",
+              "examples": "嗯\n可以\n是的\n哦\nyes\n15002333453\nwindblow_2231",
+              "to": "generate:get_wechat"
+            },
+            "giveup": {
+              "description": "该回答表示他不愿意加微信。",
+              "examples": "不需要\n不感兴趣\n暂时不看\n不要\nno\n不方便\n不知道还要加我微信",
+              "to": "generate:nowechat"
+            }
+          },
+          "message_history_window_size": 8
+        }
+      },
+      "downstream": [
+        "retrieval:0",
+        "generate:casual",
+        "generate:get_wechat",
+        "generate:nowechat"
+      ],
+      "upstream": ["answer:1"]
+    },
+    "generate:casual": {
+      "obj": {
+        "component_name": "Generate",
+        "params": {
+          "llm_id": "deepseek-chat",
+          "prompt": "你是AGI方向的猎头，现在候选人的聊了和职位无关的话题，请耐心的回应候选人，并将话题往该AGI的职位上带，最好能要到候选人微信号以便后面保持联系。",
+          "temperature": 0.9,
+          "message_history_window_size": 12,
+          "cite": false
+        }
+      },
+      "downstream": ["answer:1"],
+      "upstream": ["categorize:0", "categorize:1"]
+    },
+    "retrieval:0": {
+      "obj": {
+        "component_name": "Retrieval",
+        "params": {
+          "similarity_threshold": 0.2,
+          "keywords_similarity_weight": 0.3,
+          "top_n": 6,
+          "top_k": 1024,
+          "rerank_id": "BAAI/bge-reranker-v2-m3",
+          "kb_ids": ["869a236818b811ef91dffa163e197198"]
+        }
+      },
+      "downstream": ["generate:aboutJob"],
+      "upstream": ["categorize:0", "categorize:1"]
+    },
+    "generate:aboutJob": {
+      "obj": {
+        "component_name": "Generate",
+        "params": {
+          "llm_id": "deepseek-chat",
+          "prompt": "你是AGI方向的猎头，候选人问了有关职位或公司的问题，你根据以下职位信息回答。如果职位信息中不包含候选人的问题就回答不清楚、不知道、有待确认等。回答完后引导候选人加微信号，如：\n - 方便加一下微信吗，我把JD发您看看？\n  - 微信号多少，我把详细职位JD发您？\n      职位信息如下:\n      {input}\n      职位信息如上。",
+          "temperature": 0.02
+        }
+      },
+      "downstream": ["answer:1"],
+      "upstream": ["retrieval:0"]
+    },
+    "generate:get_wechat": {
+      "obj": {
+        "component_name": "Generate",
+        "params": {
+          "llm_id": "deepseek-chat",
+          "prompt": "你是AGI方向的猎头，候选人表示不反感加微信，如果对方已经报了微信号，表示感谢和信任并表示马上会加上；如果没有，则问对方微信号多少。你的微信号是weixin_kevin，E-mail是kkk@ragflow.com。说话不要重复。不要总是您好。",
+          "temperature": 0.1,
+          "message_history_window_size": 12,
+          "cite": false
+        }
+      },
+      "downstream": ["answer:1"],
+      "upstream": ["categorize:1"]
+    },
+    "generate:nowechat": {
+      "obj": {
+        "component_name": "Generate",
+        "params": {
+          "llm_id": "deepseek-chat",
+          "prompt": "你是AGI方向的猎头，当你提出加微信时对方表示拒绝。你需要耐心礼貌的回应候选人，表示对于保护隐私信息给予理解，也可以询问他对该职位的看法和顾虑。并在恰当的时机再次询问微信联系方式。也可以鼓励候选人主动与你取得联系。你的微信号是weixin_kevin，E-mail是kkk@ragflow.com。说话不要重复。不要总是您好。",
+          "temperature": 0.1,
+          "message_history_window_size": 12,
+          "cite": false
+        }
+      },
+      "downstream": ["answer:1"],
+      "upstream": ["categorize:1"]
+    },
+    "message:reject": {
+      "obj": {
+        "component_name": "Message",
+        "params": {
+          "messages": [
+            "好的，祝您生活愉快，工作顺利。",
+            "哦，好的，感谢您宝贵的时间！"
+          ]
+        }
+      },
+      "downstream": ["answer:0"],
+      "upstream": ["categorize:0"]
+    }
+  },
+  "history": [],
+  "messages": [],
+  "path": [],
+  "reference": [],
+  "answer": []
+}

agent/test/dsl_examples/iteration.json

@@ -0,0 +1,92 @@
+{
+  "components": {
+            "begin": {
+                "obj":{
+                    "component_name": "Begin",
+                    "params": {
+                      "prologue": "Hi there!"
+                    }
+                },
+                "downstream": ["generate:0"],
+                "upstream": []
+            },
+            "generate:0": {
+                "obj": {
+                    "component_name": "Agent",
+                    "params": {
+                      "llm_id": "deepseek-chat",
+                      "sys_prompt": "You are an helpful research assistant. \nPlease decompose user's topic: '{sys.query}' into several meaningful sub-topics. \nThe output format MUST be an string array like: [\"sub-topic1\", \"sub-topic2\", ...]. Redundant information is forbidden.",
+                      "temperature": 0.2,
+                      "cite":false,
+                      "output_structure": ["sub-topic1", "sub-topic2", "sub-topic3"]
+                    }
+                },
+                "downstream": ["iteration:0"],
+                "upstream": ["begin"]
+            },
+            "iteration:0": {
+                "obj": {
+                    "component_name": "Iteration",
+                    "params": {
+                      "items_ref": "generate:0@structured_content"
+                    }
+                },
+                "downstream": ["message:0"],
+                "upstream": ["generate:0"]
+            },
+            "iterationitem:0": {
+                "obj": {
+                    "component_name": "IterationItem",
+                    "params": {}
+                },
+                "parent_id": "iteration:0",
+                "downstream": ["tavily:0"],
+                "upstream": []
+            },
+            "tavily:0": {
+                "obj": {
+                    "component_name": "TavilySearch",
+                    "params": {
+                      "api_key": "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",
+                      "query": "iterationitem:0@result"
+                    }
+                },
+                "parent_id": "iteration:0",
+                "downstream": ["generate:1"],
+                "upstream": ["iterationitem:0"]
+            },
+            "generate:1": {
+                "obj": {
+                    "component_name": "Agent",
+                    "params": {
+                      "llm_id": "deepseek-chat",
+                      "sys_prompt": "Your goal is to provide answers based on information from the internet. \nYou must use the provided search results to find relevant online information. \nYou should never use your own knowledge to answer questions.\nPlease include relevant url sources in the end of your answers.\n\n \"{tavily:0@formalized_content}\" \nUsing the above information, answer the following question or topic: \"{iterationitem:0@result} \"\nin a detailed report — The report should focus on the answer to the question, should be well structured, informative, in depth, with facts and numbers if available, a minimum of 200 words and with markdown syntax and apa format. Write all source urls at the end of the report in apa format. You should write your report only based on the given information and nothing else.",
+                      "temperature": 0.9,
+                      "cite":false
+                    }
+                },
+                "parent_id": "iteration:0",
+                "downstream": ["iterationitem:0"],
+                "upstream": ["tavily:0"]
+            },
+            "message:0": {
+                "obj": {
+                    "component_name": "Message",
+                    "params": {
+                      "content": ["{iteration:0@generate:1}"]
+                    }
+                },
+                "downstream": [],
+                "upstream": ["iteration:0"]
+            }
+  },
+  "history": [],
+  "path": [],
+  "retrival": {"chunks": [], "doc_aggs": []},
+  "globals": {
+    "sys.query": "",
+    "sys.user_id": "",
+    "sys.conversation_turns": 0,
+    "sys.files": []
+  }
+}

agent/test/dsl_examples/retrieval_and_generate.json

@@ -0,0 +1,61 @@
+{
+  "components": {
+            "begin": {
+                "obj":{
+                    "component_name": "Begin",
+                    "params": {
+                      "prologue": "Hi there!"
+                    }
+                },
+                "downstream": ["retrieval:0"],
+                "upstream": []
+            },
+            "retrieval:0": {
+                "obj": {
+                    "component_name": "Retrieval",
+                    "params": {
+                      "similarity_threshold": 0.2,
+                      "keywords_similarity_weight": 0.3,
+                      "top_n": 6,
+                      "top_k": 1024,
+                      "rerank_id": "",
+                      "empty_response": "Nothing found in dataset",
+                      "kb_ids": ["1a3d1d7afb0611ef9866047c16ec874f"]
+                    }
+                },
+                "downstream": ["generate:0"],
+                "upstream": ["begin"]
+            },
+            "generate:0": {
+                "obj": {
+                    "component_name": "LLM",
+                    "params": {
+                      "llm_id": "deepseek-chat",
+                      "sys_prompt": "You are an intelligent assistant. Please summarize the content of the knowledge base to answer the question. Please list the data in the knowledge base and answer in detail. When all knowledge base content is irrelevant to the question, your answer must include the sentence \"The answer you are looking for is not found in the knowledge base!\" Answers need to consider chat history.\n      Here is the knowledge base:\n      {retrieval:0@formalized_content}\n      The above is the knowledge base.",
+                      "temperature": 0.2
+                    }
+                },
+                "downstream": ["message:0"],
+                "upstream": ["retrieval:0"]
+            },
+            "message:0": {
+                "obj": {
+                    "component_name": "Message",
+                    "params": {
+                      "content": ["{generate:0@content}"]
+                    }
+                },
+                "downstream": [],
+                "upstream": ["generate:0"]
+            }
+  },
+  "history": [],
+  "path": [],
+  "retrival": {"chunks": [], "doc_aggs": []},
+  "globals": {
+    "sys.query": "",
+    "sys.user_id": "",
+    "sys.conversation_turns": 0,
+    "sys.files": []
+  }
+}

agent/test/dsl_examples/retrieval_categorize_and_generate.json

@@ -0,0 +1,95 @@
+{
+  "components": {
+            "begin": {
+                "obj":{
+                    "component_name": "Begin",
+                    "params": {
+                      "prologue": "Hi there!"
+                    }
+                },
+                "downstream": ["categorize:0"],
+                "upstream": []
+            },
+            "categorize:0": {
+                "obj": {
+                    "component_name": "Categorize",
+                    "params": {
+                      "llm_id": "deepseek-chat",
+                      "category_description": {
+                        "product_related": {
+                          "description": "The question is about the product usage, appearance and how it works.",
+                          "examples": [],
+                          "to": ["retrieval:0"]
+                        },
+                        "others": {
+                          "description": "The question is not about the product usage, appearance and how it works.",
+                          "examples": [],
+                          "to": ["message:0"]
+                        }
+                      }
+                    }
+                },
+                "downstream": [],
+                "upstream": ["begin"]
+            },
+            "message:0": {
+                "obj":{
+                    "component_name": "Message",
+                    "params": {
+                      "content": [
+                        "Sorry, I don't know. I'm an AI bot."
+                      ]
+                    }
+                },
+                "downstream": [],
+                "upstream": ["categorize:0"]
+            },
+            "retrieval:0": {
+                "obj": {
+                    "component_name": "Retrieval",
+                    "params": {
+                      "similarity_threshold": 0.2,
+                      "keywords_similarity_weight": 0.3,
+                      "top_n": 6,
+                      "top_k": 1024,
+                      "rerank_id": "",
+                      "empty_response": "Nothing found in dataset",
+                      "kb_ids": ["1a3d1d7afb0611ef9866047c16ec874f"]
+                    }
+                },
+                "downstream": ["generate:0"],
+                "upstream": ["categorize:0"]
+            },
+            "generate:0": {
+                "obj": {
+                    "component_name": "Agent",
+                    "params": {
+                      "llm_id": "deepseek-chat",
+                      "sys_prompt": "You are an intelligent assistant. Please summarize the content of the knowledge base to answer the question. Please list the data in the knowledge base and answer in detail. When all knowledge base content is irrelevant to the question, your answer must include the sentence \"The answer you are looking for is not found in the knowledge base!\" Answers need to consider chat history.\n      Here is the knowledge base:\n      {retrieval:0@formalized_content}\n      The above is the knowledge base.",
+                      "temperature": 0.2
+                    }
+                },
+                "downstream": ["message:1"],
+                "upstream": ["retrieval:0"]
+            },
+            "message:1": {
+                "obj": {
+                    "component_name": "Message",
+                    "params": {
+                      "content": ["{generate:0@content}"]
+                    }
+                },
+                "downstream": [],
+                "upstream": ["generate:0"]
+            }
+  },
+  "history": [],
+  "path": [],
+  "retrival": {"chunks": [], "doc_aggs": []},
+  "globals": {
+    "sys.query": "",
+    "sys.user_id": "",
+    "sys.conversation_turns": 0,
+    "sys.files": []
+  }
+}

agent/test/dsl_examples/tavily_and_generate.json

@@ -0,0 +1,55 @@
+{
+  "components": {
+            "begin": {
+                "obj":{
+                    "component_name": "Begin",
+                    "params": {
+                      "prologue": "Hi there!"
+                    }
+                },
+                "downstream": ["tavily:0"],
+                "upstream": []
+            },
+            "tavily:0": {
+                "obj": {
+                    "component_name": "TavilySearch",
+                    "params": {
+                      "api_key": "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"
+                    }
+                },
+                "downstream": ["generate:0"],
+                "upstream": ["begin"]
+            },
+            "generate:0": {
+                "obj": {
+                    "component_name": "LLM",
+                    "params": {
+                      "llm_id": "deepseek-chat",
+                      "sys_prompt": "You are an intelligent assistant. Please summarize the content of the knowledge base to answer the question. Please list the data in the knowledge base and answer in detail. When all knowledge base content is irrelevant to the question, your answer must include the sentence \"The answer you are looking for is not found in the knowledge base!\" Answers need to consider chat history.\n      Here is the knowledge base:\n      {tavily:0@formalized_content}\n      The above is the knowledge base.",
+                      "temperature": 0.2
+                    }
+                },
+                "downstream": ["message:0"],
+                "upstream": ["tavily:0"]
+            },
+            "message:0": {
+                "obj": {
+                    "component_name": "Message",
+                    "params": {
+                      "content": ["{generate:0@content}"]
+                    }
+                },
+                "downstream": [],
+                "upstream": ["generate:0"]
+            }
+  },
+  "history": [],
+  "path": [],
+  "retrival": {"chunks": [], "doc_aggs": []},
+  "globals": {
+    "sys.query": "",
+    "sys.user_id": "",
+    "sys.conversation_turns": 0,
+    "sys.files": []
+  }
+}

agent/tools/__init__.py

@@ -0,0 +1,48 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import os
+import importlib
+import inspect
+from types import ModuleType
+from typing import Dict, Type
+
+_package_path = os.path.dirname(__file__)
+__all_classes: Dict[str, Type] = {}
+
+def _import_submodules() -> None:
+    for filename in os.listdir(_package_path): # noqa: F821
+        if filename.startswith("__") or not filename.endswith(".py") or filename.startswith("base"):
+            continue
+        module_name = filename[:-3]
+
+        try:
+            module = importlib.import_module(f".{module_name}", package=__name__)
+            _extract_classes_from_module(module)  # noqa: F821
+        except ImportError as e:
+            print(f"Warning: Failed to import module {module_name}: {str(e)}")
+
+def _extract_classes_from_module(module: ModuleType) -> None:
+    for name, obj in inspect.getmembers(module):
+        if (inspect.isclass(obj) and
+                obj.__module__ == module.__name__ and not name.startswith("_")):
+            __all_classes[name] = obj
+            globals()[name] = obj
+
+_import_submodules()
+
+__all__ = list(__all_classes.keys()) + ["__all_classes"]
+
+del _package_path, _import_submodules, _extract_classes_from_module

agent/tools/akshare.py

@@ -0,0 +1,56 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from abc import ABC
+import pandas as pd
+from agent.component.base import ComponentBase, ComponentParamBase
+
+
+class AkShareParam(ComponentParamBase):
+    """
+    Define the AkShare component parameters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.top_n = 10
+
+    def check(self):
+        self.check_positive_integer(self.top_n, "Top N")
+
+
+class AkShare(ComponentBase, ABC):
+    component_name = "AkShare"
+
+    def _run(self, history, **kwargs):
+        import akshare as ak
+        ans = self.get_input()
+        ans = ",".join(ans["content"]) if "content" in ans else ""
+        if not ans:
+            return AkShare.be_output("")
+
+        try:
+            ak_res = []
+            stock_news_em_df = ak.stock_news_em(symbol=ans)
+            stock_news_em_df = stock_news_em_df.head(self._param.top_n)
+            ak_res = [{"content": '<a href="' + i["新闻链接"] + '">' + i["新闻标题"] + '</a>\n 新闻内容: ' + i[
+                "新闻内容"] + " \n发布时间:" + i["发布时间"] + " \n文章来源: " + i["文章来源"]} for index, i in stock_news_em_df.iterrows()]
+        except Exception as e:
+            return AkShare.be_output("**ERROR**: " + str(e))
+
+        if not ak_res:
+            return AkShare.be_output("")
+
+        return pd.DataFrame(ak_res)

agent/tools/arxiv.py

@@ -0,0 +1,102 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import time
+from abc import ABC
+import arxiv
+from agent.tools.base import ToolParamBase, ToolMeta, ToolBase
+from api.utils.api_utils import timeout
+
+
+class ArXivParam(ToolParamBase):
+    """
+    Define the ArXiv component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "arxiv_search",
+            "description": """arXiv is a free distribution service and an open-access archive for nearly 2.4 million scholarly articles in the fields of physics, mathematics, computer science, quantitative biology, quantitative finance, statistics, electrical engineering and systems science, and economics. Materials on this site are not peer-reviewed by arXiv.""",
+            "parameters": {
+                "query": {
+                    "type": "string",
+                    "description": "The search keywords to execute with arXiv. The keywords should be the most important words/terms(includes synonyms) from the original request.",
+                    "default": "{sys.query}",
+                    "required": True
+                }
+            }
+        }
+        super().__init__()
+        self.top_n = 12
+        self.sort_by = 'submittedDate'
+
+    def check(self):
+        self.check_positive_integer(self.top_n, "Top N")
+        self.check_valid_value(self.sort_by, "ArXiv Search Sort_by",
+                               ['submittedDate', 'lastUpdatedDate', 'relevance'])
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "query": {
+                "name": "Query",
+                "type": "line"
+            }
+        }
+
+
+class ArXiv(ToolBase, ABC):
+    component_name = "ArXiv"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 12)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("query"):
+            self.set_output("formalized_content", "")
+            return ""
+
+        last_e = ""
+        for _ in range(self._param.max_retries+1):
+            try:
+                sort_choices = {"relevance": arxiv.SortCriterion.Relevance,
+                                "lastUpdatedDate": arxiv.SortCriterion.LastUpdatedDate,
+                                'submittedDate': arxiv.SortCriterion.SubmittedDate}
+                arxiv_client = arxiv.Client()
+                search = arxiv.Search(
+                    query=kwargs["query"],
+                    max_results=self._param.top_n,
+                    sort_by=sort_choices[self._param.sort_by]
+                )
+                self._retrieve_chunks(list(arxiv_client.results(search)),
+                                      get_title=lambda r: r.title,
+                                      get_url=lambda r: r.pdf_url,
+                                      get_content=lambda r: r.summary)
+                return self.output("formalized_content")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"ArXiv error: {e}")
+                time.sleep(self._param.delay_after_error)
+
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"ArXiv error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return """
+Keywords: {}
+Looking for the most relevant articles.
+                """.format(self.get_input().get("query", "-_-!"))

agent/tools/base.py

@@ -0,0 +1,173 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import re
+import time
+from copy import deepcopy
+from functools import partial
+from typing import TypedDict, List, Any
+from agent.component.base import ComponentParamBase, ComponentBase
+from api.utils import hash_str2int
+from rag.llm.chat_model import ToolCallSession
+from rag.prompts.generator import kb_prompt
+from rag.utils.mcp_tool_call_conn import MCPToolCallSession
+from timeit import default_timer as timer
+
+
+class ToolParameter(TypedDict):
+    type: str
+    description: str
+    displayDescription: str
+    enum: List[str]
+    required: bool
+
+
+class ToolMeta(TypedDict):
+    name: str
+    displayName: str
+    description: str
+    displayDescription: str
+    parameters: dict[str, ToolParameter]
+
+
+class LLMToolPluginCallSession(ToolCallSession):
+    def __init__(self, tools_map: dict[str, object], callback: partial):
+        self.tools_map = tools_map
+        self.callback = callback
+
+    def tool_call(self, name: str, arguments: dict[str, Any]) -> Any:
+        assert name in self.tools_map, f"LLM tool {name} does not exist"
+        st = timer()
+        if isinstance(self.tools_map[name], MCPToolCallSession):
+            resp = self.tools_map[name].tool_call(name, arguments, 60)
+        else:
+            resp = self.tools_map[name].invoke(**arguments)
+
+        self.callback(name, arguments, resp, elapsed_time=timer()-st)
+        return resp
+
+    def get_tool_obj(self, name):
+        return self.tools_map[name]
+
+
+class ToolParamBase(ComponentParamBase):
+    def __init__(self):
+        #self.meta:ToolMeta = None
+        super().__init__()
+        self._init_inputs()
+        self._init_attr_by_meta()
+
+    def _init_inputs(self):
+        self.inputs = {}
+        for k,p in self.meta["parameters"].items():
+            self.inputs[k] = deepcopy(p)
+
+    def _init_attr_by_meta(self):
+        for k,p in self.meta["parameters"].items():
+            if not hasattr(self, k):
+                setattr(self, k, p.get("default"))
+
+    def get_meta(self):
+        params = {}
+        for k, p in self.meta["parameters"].items():
+            params[k] = {
+                "type": p["type"],
+                "description": p["description"]
+            }
+            if "enum" in p:
+                params[k]["enum"] = p["enum"]
+
+        desc = self.meta["description"]
+        if hasattr(self, "description"):
+            desc = self.description
+
+        function_name = self.meta["name"]
+        if hasattr(self, "function_name"):
+            function_name = self.function_name
+
+        return {
+            "type": "function",
+            "function": {
+                "name": function_name,
+                "description": desc,
+                "parameters": {
+                    "type": "object",
+                    "properties": params,
+                    "required": [k for k, p in self.meta["parameters"].items() if p["required"]]
+                }
+            }
+        }
+
+
+class ToolBase(ComponentBase):
+    def __init__(self, canvas, id, param: ComponentParamBase):
+        from agent.canvas import Canvas  # Local import to avoid cyclic dependency
+        assert isinstance(canvas, Canvas), "canvas must be an instance of Canvas"
+        self._canvas = canvas
+        self._id = id
+        self._param = param
+        self._param.check()
+
+    def get_meta(self) -> dict[str, Any]:
+        return self._param.get_meta()
+
+    def invoke(self, **kwargs):
+        self.set_output("_created_time", time.perf_counter())
+        try:
+            res = self._invoke(**kwargs)
+        except Exception as e:
+            self._param.outputs["_ERROR"] = {"value": str(e)}
+            logging.exception(e)
+            res = str(e)
+        self._param.debug_inputs = []
+
+        self.set_output("_elapsed_time", time.perf_counter() - self.output("_created_time"))
+        return res
+
+    def _retrieve_chunks(self, res_list: list, get_title, get_url, get_content, get_score=None):
+        chunks = []
+        aggs = []
+        for r in res_list:
+            content = get_content(r)
+            if not content:
+                continue
+            content = re.sub(r"!?\[[a-z]+\]\(data:image/png;base64,[ 0-9A-Za-z/_=+-]+\)", "", content)
+            content = content[:10000]
+            if not content:
+                continue
+            id = str(hash_str2int(content))
+            title = get_title(r)
+            url = get_url(r)
+            score = get_score(r) if get_score else 1
+            chunks.append({
+                "chunk_id": id,
+                "content": content,
+                "doc_id": id,
+                "docnm_kwd": title,
+                "similarity": score,
+                "url": url
+            })
+            aggs.append({
+                "doc_name": title,
+                "doc_id": id,
+                "count": 1,
+                "url": url
+            })
+        self._canvas.add_reference(chunks, aggs)
+        self.set_output("formalized_content", "\n".join(kb_prompt({"chunks": chunks, "doc_aggs": aggs}, 200000, True)))
+
+    def thoughts(self) -> str:
+        return self._canvas.get_component_name(self._id) + " is running..."

agent/tools/code_exec.py

@@ -0,0 +1,201 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import base64
+import logging
+import os
+from abc import ABC
+from strenum import StrEnum
+from typing import Optional
+from pydantic import BaseModel, Field, field_validator
+from agent.tools.base import ToolParamBase, ToolBase, ToolMeta
+from api import settings
+from api.utils.api_utils import timeout
+
+
+class Language(StrEnum):
+    PYTHON = "python"
+    NODEJS = "nodejs"
+
+
+class CodeExecutionRequest(BaseModel):
+    code_b64: str = Field(..., description="Base64 encoded code string")
+    language: str = Field(default=Language.PYTHON.value, description="Programming language")
+    arguments: Optional[dict] = Field(default={}, description="Arguments")
+
+    @field_validator("code_b64")
+    @classmethod
+    def validate_base64(cls, v: str) -> str:
+        try:
+            base64.b64decode(v, validate=True)
+            return v
+        except Exception as e:
+            raise ValueError(f"Invalid base64 encoding: {str(e)}")
+
+    @field_validator("language", mode="before")
+    @classmethod
+    def normalize_language(cls, v) -> str:
+        if isinstance(v, str):
+            low = v.lower()
+            if low in ("python", "python3"):
+                return "python"
+            elif low in ("javascript", "nodejs"):
+                return "nodejs"
+        raise ValueError(f"Unsupported language: {v}")
+
+
+class CodeExecParam(ToolParamBase):
+    """
+    Define the code sandbox component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "execute_code",
+            "description": """
+This tool has a sandbox that can execute code written in 'Python'/'Javascript'. It recieves a piece of code and return a Json string.
+Here's a code example for Python(`main` function MUST be included):
+def main() -> dict:
+    \"\"\"
+    Generate Fibonacci numbers within 100.
+    \"\"\"
+    def fibonacci_recursive(n):
+        if n <= 1:
+            return n
+        else:
+            return fibonacci_recursive(n-1) + fibonacci_recursive(n-2)
+    return {
+        "result": fibonacci_recursive(100),
+    }
+
+Here's a code example for Javascript(`main` function MUST be included and exported):
+const axios = require('axios');
+async function main(args) {
+  try {
+    const response = await axios.get('https://github.com/infiniflow/ragflow');
+    console.log('Body:', response.data);
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+module.exports = { main };
+            """,
+            "parameters": {
+                "lang": {
+                    "type": "string",
+                    "description": "The programming language of this piece of code.",
+                    "enum": ["python", "javascript"],
+                    "required": True,
+                },
+                "script": {
+                    "type": "string",
+                    "description": "A piece of code in right format. There MUST be main function.",
+                    "required": True
+                }
+            }
+        }
+        super().__init__()
+        self.lang = Language.PYTHON.value
+        self.script = "def main(arg1: str, arg2: str) -> dict: return {\"result\": arg1 + arg2}"
+        self.arguments = {}
+        self.outputs = {"result": {"value": "", "type": "string"}}
+
+    def check(self):
+        self.check_valid_value(self.lang, "Support languages", ["python", "python3", "nodejs", "javascript"])
+        self.check_empty(self.script, "Script")
+
+    def get_input_form(self) -> dict[str, dict]:
+        res = {}
+        for k, v in self.arguments.items():
+            res[k] = {
+                "type": "line",
+                "name": k
+            }
+        return res
+
+
+class CodeExec(ToolBase, ABC):
+    component_name = "CodeExec"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 10*60)))
+    def _invoke(self, **kwargs):
+        lang = kwargs.get("lang", self._param.lang)
+        script = kwargs.get("script", self._param.script)
+        arguments = {}
+        for k, v in self._param.arguments.items():
+            if kwargs.get(k):
+                arguments[k] = kwargs[k]
+                continue
+            arguments[k] = self._canvas.get_variable_value(v) if v else None
+
+        self._execute_code(
+            language=lang,
+            code=script,
+            arguments=arguments
+        )
+
+    def _execute_code(self, language: str, code: str, arguments: dict):
+        import requests
+
+        try:
+            code_b64 = self._encode_code(code)
+            code_req = CodeExecutionRequest(code_b64=code_b64, language=language, arguments=arguments).model_dump()
+        except Exception as e:
+            self.set_output("_ERROR", "construct code request error: " + str(e))
+
+        try:
+            resp = requests.post(url=f"http://{settings.SANDBOX_HOST}:9385/run", json=code_req, timeout=int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 10*60)))
+            logging.info(f"http://{settings.SANDBOX_HOST}:9385/run,  code_req: {code_req}, resp.status_code {resp.status_code}:")
+            if resp.status_code != 200:
+                resp.raise_for_status()
+            body = resp.json()
+            if body:
+                stderr = body.get("stderr")
+                if stderr:
+                    self.set_output("_ERROR", stderr)
+                    return
+                try:
+                    rt = eval(body.get("stdout", ""))
+                except Exception:
+                    rt = body.get("stdout", "")
+                logging.info(f"http://{settings.SANDBOX_HOST}:9385/run -> {rt}")
+                if isinstance(rt, tuple):
+                    for i, (k, o) in enumerate(self._param.outputs.items()):
+                        if k.find("_") == 0:
+                            continue
+                        o["value"] = rt[i]
+                elif isinstance(rt, dict):
+                    for i, (k, o) in enumerate(self._param.outputs.items()):
+                        if k not in rt or k.find("_") == 0:
+                            continue
+                        o["value"] = rt[k]
+                else:
+                    for i, (k, o) in enumerate(self._param.outputs.items()):
+                        if k.find("_") == 0:
+                            continue
+                        o["value"] = rt
+            else:
+                self.set_output("_ERROR", "There is no response from sandbox")
+
+        except Exception as e:
+            self.set_output("_ERROR", "Exception executing code: " + str(e))
+
+        return self.output()
+
+    def _encode_code(self, code: str) -> str:
+        return base64.b64encode(code.encode("utf-8")).decode("utf-8")
+
+    def thoughts(self) -> str:
+        return "Running a short script to process data."

agent/tools/crawler.py

@@ -0,0 +1,68 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from abc import ABC
+import asyncio
+from crawl4ai import AsyncWebCrawler
+from agent.tools.base import ToolParamBase, ToolBase
+
+
+
+class CrawlerParam(ToolParamBase):
+    """
+    Define the Crawler component parameters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.proxy = None
+        self.extract_type = "markdown"
+    
+    def check(self):
+        self.check_valid_value(self.extract_type, "Type of content from the crawler", ['html', 'markdown', 'content'])
+
+
+class Crawler(ToolBase, ABC):
+    component_name = "Crawler"
+
+    def _run(self, history, **kwargs):
+        from api.utils.web_utils import is_valid_url
+        ans = self.get_input()
+        ans = " - ".join(ans["content"]) if "content" in ans else ""
+        if not is_valid_url(ans):
+            return Crawler.be_output("URL not valid")
+        try:
+            result = asyncio.run(self.get_web(ans))
+
+            return Crawler.be_output(result)
+            
+        except Exception as e:
+            return Crawler.be_output(f"An unexpected error occurred: {str(e)}")
+
+    async def get_web(self, url):
+        proxy = self._param.proxy if self._param.proxy else None
+        async with AsyncWebCrawler(verbose=True, proxy=proxy) as crawler:
+            result = await crawler.arun(
+                url=url,
+                bypass_cache=True
+            )
+            
+            if self._param.extract_type == 'html':
+                return result.cleaned_html
+            elif self._param.extract_type == 'markdown':
+                return result.markdown
+            elif self._param.extract_type == 'content':
+                return result.extracted_content
+            return result.markdown

agent/tools/deepl.py

@@ -0,0 +1,61 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from abc import ABC
+from agent.component.base import ComponentBase, ComponentParamBase
+import deepl
+
+
+class DeepLParam(ComponentParamBase):
+    """
+    Define the DeepL component parameters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.auth_key = "xxx"
+        self.parameters = []
+        self.source_lang = 'ZH'
+        self.target_lang = 'EN-GB'
+
+    def check(self):
+        self.check_positive_integer(self.top_n, "Top N")
+        self.check_valid_value(self.source_lang, "Source language",
+                               ['AR', 'BG', 'CS', 'DA', 'DE', 'EL', 'EN', 'ES', 'ET', 'FI', 'FR', 'HU', 'ID', 'IT',
+                                'JA', 'KO', 'LT', 'LV', 'NB', 'NL', 'PL', 'PT', 'RO', 'RU', 'SK', 'SL', 'SV', 'TR',
+                                'UK', 'ZH'])
+        self.check_valid_value(self.target_lang, "Target language",
+                               ['AR', 'BG', 'CS', 'DA', 'DE', 'EL', 'EN-GB', 'EN-US', 'ES', 'ET', 'FI', 'FR', 'HU',
+                                'ID', 'IT', 'JA', 'KO', 'LT', 'LV', 'NB', 'NL', 'PL', 'PT-BR', 'PT-PT', 'RO', 'RU',
+                                'SK', 'SL', 'SV', 'TR', 'UK', 'ZH'])
+
+
+class DeepL(ComponentBase, ABC):
+    component_name = "DeepL"
+
+    def _run(self, history, **kwargs):
+        ans = self.get_input()
+        ans = " - ".join(ans["content"]) if "content" in ans else ""
+        if not ans:
+            return DeepL.be_output("")
+
+        try:
+            translator = deepl.Translator(self._param.auth_key)
+            result = translator.translate_text(ans, source_lang=self._param.source_lang,
+                                               target_lang=self._param.target_lang)
+
+            return DeepL.be_output(result.text)
+        except Exception as e:
+            DeepL.be_output("**Error**:" + str(e))

agent/tools/duckduckgo.py

@@ -0,0 +1,120 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import time
+from abc import ABC
+from duckduckgo_search import DDGS
+from agent.tools.base import ToolMeta, ToolParamBase, ToolBase
+from api.utils.api_utils import timeout
+
+
+class DuckDuckGoParam(ToolParamBase):
+    """
+    Define the DuckDuckGo component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "duckduckgo_search",
+            "description": "DuckDuckGo is a search engine focused on privacy. It offers search capabilities for web pages, images, and provides translation services. DuckDuckGo also features a private AI chat interface, providing users with an AI assistant that prioritizes data protection.",
+            "parameters": {
+                "query": {
+                    "type": "string",
+                    "description": "The search keywords to execute with DuckDuckGo. The keywords should be the most important words/terms(includes synonyms) from the original request.",
+                    "default": "{sys.query}",
+                    "required": True
+                },
+                "channel": {
+                    "type": "string",
+                    "description": "default:general. The category of the search. `news` is useful for retrieving real-time updates, particularly about politics, sports, and major current events covered by mainstream media sources. `general` is for broader, more general-purpose searches that may include a wide range of sources.",
+                    "enum": ["general", "news"],
+                    "default": "general",
+                    "required": False,
+                },
+            }
+        }
+        super().__init__()
+        self.top_n = 10
+        self.channel = "text"
+
+    def check(self):
+        self.check_positive_integer(self.top_n, "Top N")
+        self.check_valid_value(self.channel, "Web Search or News", ["text", "news"])
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "query": {
+                "name": "Query",
+                "type": "line"
+            },
+            "channel": {
+                "name": "Channel",
+                "type": "options",
+                "value": "general",
+                "options": ["general", "news"]
+            }
+        }
+
+
+class DuckDuckGo(ToolBase, ABC):
+    component_name = "DuckDuckGo"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 12)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("query"):
+            self.set_output("formalized_content", "")
+            return ""
+
+        last_e = ""
+        for _ in range(self._param.max_retries+1):
+            try:
+                if kwargs.get("topic", "general") == "general":
+                    with DDGS() as ddgs:
+                        # {'title': '', 'href': '', 'body': ''}
+                        duck_res = ddgs.text(kwargs["query"], max_results=self._param.top_n)
+                        self._retrieve_chunks(duck_res,
+                                              get_title=lambda r: r["title"],
+                                              get_url=lambda r: r.get("href", r.get("url")),
+                                              get_content=lambda r: r["body"])
+                        self.set_output("json", duck_res)
+                        return self.output("formalized_content")
+                else:
+                    with DDGS() as ddgs:
+                        # {'date': '', 'title': '', 'body': '', 'url': '', 'image': '', 'source': ''}
+                        duck_res = ddgs.news(kwargs["query"], max_results=self._param.top_n)
+                        self._retrieve_chunks(duck_res,
+                                              get_title=lambda r: r["title"],
+                                              get_url=lambda r: r.get("href", r.get("url")),
+                                              get_content=lambda r: r["body"])
+                        self.set_output("json", duck_res)
+                        return self.output("formalized_content")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"DuckDuckGo error: {e}")
+                time.sleep(self._param.delay_after_error)
+
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"DuckDuckGo error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return """
+Keywords: {}
+Looking for the most relevant articles.
+                """.format(self.get_input().get("query", "-_-!"))

agent/tools/email.py

@@ -0,0 +1,215 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import os
+import time
+from abc import ABC
+import json
+import smtplib
+import logging
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.header import Header
+from email.utils import formataddr
+
+from agent.tools.base import ToolParamBase, ToolBase, ToolMeta
+from api.utils.api_utils import timeout
+
+
+class EmailParam(ToolParamBase):
+    """
+    Define the Email component parameters.
+    """
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "email",
+            "description": "The email is a method of electronic communication for sending and receiving information through the Internet. This tool helps users to send emails to one person or to multiple recipients with support for CC, BCC, file attachments, and markdown-to-HTML conversion.",
+            "parameters": {
+                "to_email": {
+                    "type": "string",
+                    "description": "The target email address.",
+                    "default": "{sys.query}",
+                    "required": True
+                },
+                "cc_email": {
+                    "type": "string",
+                    "description": "The other email addresses needs to be send to. Comma splited.",
+                    "default": "",
+                    "required": False
+                },
+                "content": {
+                    "type": "string",
+                    "description": "The content of the email.",
+                    "default": "",
+                    "required": False
+                },
+                "subject": {
+                    "type": "string",
+                    "description": "The subject/title of the email.",
+                    "default": "",
+                    "required": False
+                }
+            }
+        }
+        super().__init__()
+        # Fixed configuration parameters
+        self.smtp_server = ""  # SMTP server address
+        self.smtp_port = 465  # SMTP port
+        self.email = ""  # Sender email
+        self.password = ""  # Email authorization code
+        self.sender_name = ""  # Sender name
+
+    def check(self):
+        # Check required parameters
+        self.check_empty(self.smtp_server, "SMTP Server")
+        self.check_empty(self.email, "Email")
+        self.check_empty(self.password, "Password")
+        self.check_empty(self.sender_name, "Sender Name")
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "to_email": {
+                "name": "To ",
+                "type": "line"
+            },
+            "subject": {
+                "name": "Subject",
+                "type": "line",
+                "optional": True
+            },
+            "cc_email": {
+                "name": "CC To",
+                "type": "line",
+                "optional": True
+            },
+        }
+
+class Email(ToolBase, ABC):
+    component_name = "Email"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 60)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("to_email"):
+            self.set_output("success", False)
+            return ""
+
+        last_e = ""
+        for _ in range(self._param.max_retries+1):
+            try:
+                # Parse JSON string passed from upstream
+                email_data = kwargs
+
+                # Validate required fields
+                if "to_email" not in email_data:
+                    return Email.be_output("Missing required field: to_email")
+
+                # Create email object
+                msg = MIMEMultipart('alternative')
+
+                # Properly handle sender name encoding
+                msg['From'] = formataddr((str(Header(self._param.sender_name,'utf-8')), self._param.email))
+                msg['To'] = email_data["to_email"]
+                if email_data.get("cc_email"):
+                    msg['Cc'] = email_data["cc_email"]
+                msg['Subject'] = Header(email_data.get("subject", "No Subject"), 'utf-8').encode()
+
+                # Use content from email_data or default content
+                email_content = email_data.get("content", "No content provided")
+                # msg.attach(MIMEText(email_content, 'plain', 'utf-8'))
+                msg.attach(MIMEText(email_content, 'html', 'utf-8'))
+
+                # Connect to SMTP server and send
+                logging.info(f"Connecting to SMTP server {self._param.smtp_server}:{self._param.smtp_port}")
+
+                context = smtplib.ssl.create_default_context()
+                with smtplib.SMTP(self._param.smtp_server, self._param.smtp_port) as server:
+                    server.ehlo()
+                    server.starttls(context=context)
+                    server.ehlo()
+                    # Login
+                    logging.info(f"Attempting to login with email: {self._param.email}")
+                    server.login(self._param.email, self._param.password)
+
+                    # Get all recipient list
+                    recipients = [email_data["to_email"]]
+                    if email_data.get("cc_email"):
+                        recipients.extend(email_data["cc_email"].split(','))
+
+                    # Send email
+                    logging.info(f"Sending email to recipients: {recipients}")
+                    try:
+                        server.send_message(msg, self._param.email, recipients)
+                        success = True
+                    except Exception as e:
+                        logging.error(f"Error during send_message: {str(e)}")
+                        # Try alternative method
+                        server.sendmail(self._param.email, recipients, msg.as_string())
+                        success = True
+
+                    try:
+                        server.quit()
+                    except Exception as e:
+                        # Ignore errors when closing connection
+                        logging.warning(f"Non-fatal error during connection close: {str(e)}")
+
+                self.set_output("success", success)
+                return success
+
+            except json.JSONDecodeError:
+                error_msg = "Invalid JSON format in input"
+                logging.error(error_msg)
+                self.set_output("_ERROR", error_msg)
+                self.set_output("success", False)
+                return False
+
+            except smtplib.SMTPAuthenticationError:
+                error_msg = "SMTP Authentication failed. Please check your email and authorization code."
+                logging.error(error_msg)
+                self.set_output("_ERROR", error_msg)
+                self.set_output("success", False)
+                return False
+
+            except smtplib.SMTPConnectError:
+                error_msg = f"Failed to connect to SMTP server {self._param.smtp_server}:{self._param.smtp_port}"
+                logging.error(error_msg)
+                last_e = error_msg
+                time.sleep(self._param.delay_after_error)
+
+            except smtplib.SMTPException as e:
+                error_msg = f"SMTP error occurred: {str(e)}"
+                logging.error(error_msg)
+                last_e = error_msg
+                time.sleep(self._param.delay_after_error)
+
+            except Exception as e:
+                error_msg = f"Unexpected error: {str(e)}"
+                logging.error(error_msg)
+                self.set_output("_ERROR", error_msg)
+                self.set_output("success", False)
+                return False
+
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return False
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        inputs = self.get_input()
+        return """
+To: {}
+Subject: {}
+Your email is on its way—sit tight!
+""".format(inputs.get("to_email", "-_-!"), inputs.get("subject", "-_-!"))

agent/tools/exesql.py

@@ -0,0 +1,212 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import json
+import os
+import re
+from abc import ABC
+import pandas as pd
+import pymysql
+import psycopg2
+import pyodbc
+from agent.tools.base import ToolParamBase, ToolBase, ToolMeta
+from api.utils.api_utils import timeout
+
+
+class ExeSQLParam(ToolParamBase):
+    """
+    Define the ExeSQL component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "execute_sql",
+            "description": "This is a tool that can execute SQL.",
+            "parameters": {
+                "sql": {
+                    "type": "string",
+                    "description": "The SQL needs to be executed.",
+                    "default": "{sys.query}",
+                    "required": True
+                }
+            }
+        }
+        super().__init__()
+        self.db_type = "mysql"
+        self.database = ""
+        self.username = ""
+        self.host = ""
+        self.port = 3306
+        self.password = ""
+        self.max_records = 1024
+
+    def check(self):
+        self.check_valid_value(self.db_type, "Choose DB type", ['mysql', 'postgres', 'mariadb', 'mssql', 'IBM DB2'])
+        self.check_empty(self.database, "Database name")
+        self.check_empty(self.username, "database username")
+        self.check_empty(self.host, "IP Address")
+        self.check_positive_integer(self.port, "IP Port")
+        self.check_empty(self.password, "Database password")
+        self.check_positive_integer(self.max_records, "Maximum number of records")
+        if self.database == "rag_flow":
+            if self.host == "ragflow-mysql":
+                raise ValueError("For the security reason, it dose not support database named rag_flow.")
+            if self.password == "infini_rag_flow":
+                raise ValueError("For the security reason, it dose not support database named rag_flow.")
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "sql": {
+                "name": "SQL",
+                "type": "line"
+            }
+        }
+
+
+class ExeSQL(ToolBase, ABC):
+    component_name = "ExeSQL"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 60)))
+    def _invoke(self, **kwargs):
+
+        def convert_decimals(obj):
+            from decimal import Decimal
+            if isinstance(obj, Decimal):
+                return float(obj)  # 或 str(obj)
+            elif isinstance(obj, dict):
+                return {k: convert_decimals(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [convert_decimals(item) for item in obj]
+            return obj
+
+        sql = kwargs.get("sql")
+        if not sql:
+            raise Exception("SQL for `ExeSQL` MUST not be empty.")
+
+        vars = self.get_input_elements_from_text(sql)
+        args = {}
+        for k, o in vars.items():
+            args[k] = o["value"]
+            if not isinstance(args[k], str):
+                try:
+                    args[k] = json.dumps(args[k], ensure_ascii=False)
+                except Exception:
+                    args[k] = str(args[k])
+            self.set_input_value(k, args[k])
+        sql = self.string_format(sql, args)
+
+        sqls = sql.split(";")
+        if self._param.db_type in ["mysql", "mariadb"]:
+            db = pymysql.connect(db=self._param.database, user=self._param.username, host=self._param.host,
+                                 port=self._param.port, password=self._param.password)
+        elif self._param.db_type == 'postgres':
+            db = psycopg2.connect(dbname=self._param.database, user=self._param.username, host=self._param.host,
+                                  port=self._param.port, password=self._param.password)
+        elif self._param.db_type == 'mssql':
+            conn_str = (
+                    r'DRIVER={ODBC Driver 17 for SQL Server};'
+                    r'SERVER=' + self._param.host + ',' + str(self._param.port) + ';'
+                    r'DATABASE=' + self._param.database + ';'
+                    r'UID=' + self._param.username + ';'
+                    r'PWD=' + self._param.password
+            )
+            db = pyodbc.connect(conn_str)
+        elif self._param.db_type == 'IBM DB2':
+            import ibm_db
+            conn_str = (
+                f"DATABASE={self._param.database};"
+                f"HOSTNAME={self._param.host};"
+                f"PORT={self._param.port};"
+                f"PROTOCOL=TCPIP;"
+                f"UID={self._param.username};"
+                f"PWD={self._param.password};"
+            )
+            try:
+                conn = ibm_db.connect(conn_str, "", "")
+            except Exception as e:
+                raise Exception("Database Connection Failed! \n" + str(e))
+
+            sql_res = []
+            formalized_content = []
+            for single_sql in sqls:
+                single_sql = single_sql.replace("```", "").strip()
+                if not single_sql:
+                    continue
+                single_sql = re.sub(r"\[ID:[0-9]+\]", "", single_sql)
+
+                stmt = ibm_db.exec_immediate(conn, single_sql)
+                rows = []
+                row = ibm_db.fetch_assoc(stmt)
+                while row and len(rows) < self._param.max_records:
+                    rows.append(row)
+                    row = ibm_db.fetch_assoc(stmt)
+
+                if not rows:
+                    sql_res.append({"content": "No record in the database!"})
+                    continue
+
+                df = pd.DataFrame(rows)
+                for col in df.columns:
+                    if pd.api.types.is_datetime64_any_dtype(df[col]):
+                        df[col] = df[col].dt.strftime("%Y-%m-%d")
+
+                df = df.where(pd.notnull(df), None)
+
+                sql_res.append(convert_decimals(df.to_dict(orient="records")))
+                formalized_content.append(df.to_markdown(index=False, floatfmt=".6f"))
+
+            ibm_db.close(conn)
+
+            self.set_output("json", sql_res)
+            self.set_output("formalized_content", "\n\n".join(formalized_content))
+            return self.output("formalized_content")
+        try:
+            cursor = db.cursor()
+        except Exception as e:
+            raise Exception("Database Connection Failed! \n" + str(e))
+
+        sql_res = []
+        formalized_content = []
+        for single_sql in sqls:
+            single_sql = single_sql.replace('```','')
+            if not single_sql:
+                continue
+            single_sql = re.sub(r"\[ID:[0-9]+\]", "", single_sql)
+            cursor.execute(single_sql)
+            if cursor.rowcount == 0:
+                sql_res.append({"content": "No record in the database!"})
+                break
+            if self._param.db_type == 'mssql':
+                single_res = pd.DataFrame.from_records(cursor.fetchmany(self._param.max_records),
+                                                       columns=[desc[0] for desc in cursor.description])
+            else:
+                single_res = pd.DataFrame([i for i in cursor.fetchmany(self._param.max_records)])
+                single_res.columns = [i[0] for i in cursor.description]
+
+            for col in single_res.columns:
+                if pd.api.types.is_datetime64_any_dtype(single_res[col]):
+                    single_res[col] = single_res[col].dt.strftime('%Y-%m-%d')
+
+            single_res = single_res.where(pd.notnull(single_res), None)
+
+            sql_res.append(convert_decimals(single_res.to_dict(orient='records')))
+            formalized_content.append(single_res.to_markdown(index=False, floatfmt=".6f"))
+
+        self.set_output("json", sql_res)
+        self.set_output("formalized_content", "\n\n".join(formalized_content))
+        return self.output("formalized_content")
+
+    def thoughts(self) -> str:
+        return "Query sent—waiting for the data."

agent/tools/github.py

@@ -0,0 +1,91 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import time
+from abc import ABC
+import requests
+from agent.tools.base import ToolParamBase, ToolMeta, ToolBase
+from api.utils.api_utils import timeout
+
+
+class GitHubParam(ToolParamBase):
+    """
+    Define the GitHub component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "github_search",
+            "description": """GitHub repository search is a feature that enables users to find specific repositories on the GitHub platform. This search functionality allows users to locate projects, codebases, and other content hosted on GitHub based on various criteria.""",
+            "parameters": {
+                "query": {
+                    "type": "string",
+                    "description": "The search keywords to execute with GitHub. The keywords should be the most important words/terms(includes synonyms) from the original request.",
+                    "default": "{sys.query}",
+                    "required": True
+                }
+            }
+        }
+        super().__init__()
+        self.top_n = 10
+
+    def check(self):
+        self.check_positive_integer(self.top_n, "Top N")
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "query": {
+                "name": "Query",
+                "type": "line"
+            }
+        }
+
+class GitHub(ToolBase, ABC):
+    component_name = "GitHub"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 12)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("query"):
+            self.set_output("formalized_content", "")
+            return ""
+
+        last_e = ""
+        for _ in range(self._param.max_retries+1):
+            try:
+                url = 'https://api.github.com/search/repositories?q=' + kwargs["query"] + '&sort=stars&order=desc&per_page=' + str(
+                    self._param.top_n)
+                headers = {"Content-Type": "application/vnd.github+json", "X-GitHub-Api-Version": '2022-11-28'}
+                response = requests.get(url=url, headers=headers).json()
+                self._retrieve_chunks(response['items'],
+                                      get_title=lambda r: r["name"],
+                                      get_url=lambda r: r["html_url"],
+                                      get_content=lambda r: str(r["description"]) + '\n stars:' + str(r['watchers']))
+                self.set_output("json", response['items'])
+                return self.output("formalized_content")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"GitHub error: {e}")
+                time.sleep(self._param.delay_after_error)
+
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"GitHub error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return "Scanning GitHub repos related to `{}`.".format(self.get_input().get("query", "-_-!"))

agent/tools/google.py

@@ -0,0 +1,159 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import time
+from abc import ABC
+from serpapi import GoogleSearch
+from agent.tools.base import ToolParamBase, ToolMeta, ToolBase
+from api.utils.api_utils import timeout
+
+
+class GoogleParam(ToolParamBase):
+    """
+    Define the Google component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "google_search",
+            "description": """Search the world's information, including webpages, images, videos and more. Google has many special features to help you find exactly what you're looking ...""",
+            "parameters": {
+                "q": {
+                    "type": "string",
+                    "description": "The search keywords to execute with Google. The keywords should be the most important words/terms(includes synonyms) from the original request.",
+                    "default": "{sys.query}",
+                    "required": True
+                },
+                "start": {
+                    "type": "integer",
+                    "description": "Parameter defines the result offset. It skips the given number of results. It's used for pagination. (e.g., 0 (default) is the first page of results, 10 is the 2nd page of results, 20 is the 3rd page of results, etc.). Google Local Results only accepts multiples of 20(e.g. 20 for the second page results, 40 for the third page results, etc.) as the `start` value.",
+                    "default": "0",
+                    "required": False,
+                },
+                "num": {
+                    "type": "integer",
+                    "description": "Parameter defines the maximum number of results to return. (e.g., 10 (default) returns 10 results, 40 returns 40 results, and 100 returns 100 results). The use of num may introduce latency, and/or prevent the inclusion of specialized result types. It is better to omit this parameter unless it is strictly necessary to increase the number of results per page. Results are not guaranteed to have the number of results specified in num.",
+                    "default": "6",
+                    "required": False,
+                }
+            }
+        }
+        super().__init__()
+        self.start = 0
+        self.num = 6
+        self.api_key = ""
+        self.country = "cn"
+        self.language = "en"
+
+    def check(self):
+        self.check_empty(self.api_key, "SerpApi API key")
+        self.check_valid_value(self.country, "Google Country",
+                               ['af', 'al', 'dz', 'as', 'ad', 'ao', 'ai', 'aq', 'ag', 'ar', 'am', 'aw', 'au', 'at',
+                                'az', 'bs', 'bh', 'bd', 'bb', 'by', 'be', 'bz', 'bj', 'bm', 'bt', 'bo', 'ba', 'bw',
+                                'bv', 'br', 'io', 'bn', 'bg', 'bf', 'bi', 'kh', 'cm', 'ca', 'cv', 'ky', 'cf', 'td',
+                                'cl', 'cn', 'cx', 'cc', 'co', 'km', 'cg', 'cd', 'ck', 'cr', 'ci', 'hr', 'cu', 'cy',
+                                'cz', 'dk', 'dj', 'dm', 'do', 'ec', 'eg', 'sv', 'gq', 'er', 'ee', 'et', 'fk', 'fo',
+                                'fj', 'fi', 'fr', 'gf', 'pf', 'tf', 'ga', 'gm', 'ge', 'de', 'gh', 'gi', 'gr', 'gl',
+                                'gd', 'gp', 'gu', 'gt', 'gn', 'gw', 'gy', 'ht', 'hm', 'va', 'hn', 'hk', 'hu', 'is',
+                                'in', 'id', 'ir', 'iq', 'ie', 'il', 'it', 'jm', 'jp', 'jo', 'kz', 'ke', 'ki', 'kp',
+                                'kr', 'kw', 'kg', 'la', 'lv', 'lb', 'ls', 'lr', 'ly', 'li', 'lt', 'lu', 'mo', 'mk',
+                                'mg', 'mw', 'my', 'mv', 'ml', 'mt', 'mh', 'mq', 'mr', 'mu', 'yt', 'mx', 'fm', 'md',
+                                'mc', 'mn', 'ms', 'ma', 'mz', 'mm', 'na', 'nr', 'np', 'nl', 'an', 'nc', 'nz', 'ni',
+                                'ne', 'ng', 'nu', 'nf', 'mp', 'no', 'om', 'pk', 'pw', 'ps', 'pa', 'pg', 'py', 'pe',
+                                'ph', 'pn', 'pl', 'pt', 'pr', 'qa', 're', 'ro', 'ru', 'rw', 'sh', 'kn', 'lc', 'pm',
+                                'vc', 'ws', 'sm', 'st', 'sa', 'sn', 'rs', 'sc', 'sl', 'sg', 'sk', 'si', 'sb', 'so',
+                                'za', 'gs', 'es', 'lk', 'sd', 'sr', 'sj', 'sz', 'se', 'ch', 'sy', 'tw', 'tj', 'tz',
+                                'th', 'tl', 'tg', 'tk', 'to', 'tt', 'tn', 'tr', 'tm', 'tc', 'tv', 'ug', 'ua', 'ae',
+                                'uk', 'gb', 'us', 'um', 'uy', 'uz', 'vu', 've', 'vn', 'vg', 'vi', 'wf', 'eh', 'ye',
+                                'zm', 'zw'])
+        self.check_valid_value(self.language, "Google languages",
+                               ['af', 'ak', 'sq', 'ws', 'am', 'ar', 'hy', 'az', 'eu', 'be', 'bem', 'bn', 'bh',
+                                'xx-bork', 'bs', 'br', 'bg', 'bt', 'km', 'ca', 'chr', 'ny', 'zh-cn', 'zh-tw', 'co',
+                                'hr', 'cs', 'da', 'nl', 'xx-elmer', 'en', 'eo', 'et', 'ee', 'fo', 'tl', 'fi', 'fr',
+                                'fy', 'gaa', 'gl', 'ka', 'de', 'el', 'kl', 'gn', 'gu', 'xx-hacker', 'ht', 'ha', 'haw',
+                                'iw', 'hi', 'hu', 'is', 'ig', 'id', 'ia', 'ga', 'it', 'ja', 'jw', 'kn', 'kk', 'rw',
+                                'rn', 'xx-klingon', 'kg', 'ko', 'kri', 'ku', 'ckb', 'ky', 'lo', 'la', 'lv', 'ln', 'lt',
+                                'loz', 'lg', 'ach', 'mk', 'mg', 'ms', 'ml', 'mt', 'mv', 'mi', 'mr', 'mfe', 'mo', 'mn',
+                                'sr-me', 'my', 'ne', 'pcm', 'nso', 'no', 'nn', 'oc', 'or', 'om', 'ps', 'fa',
+                                'xx-pirate', 'pl', 'pt', 'pt-br', 'pt-pt', 'pa', 'qu', 'ro', 'rm', 'nyn', 'ru', 'gd',
+                                'sr', 'sh', 'st', 'tn', 'crs', 'sn', 'sd', 'si', 'sk', 'sl', 'so', 'es', 'es-419', 'su',
+                                'sw', 'sv', 'tg', 'ta', 'tt', 'te', 'th', 'ti', 'to', 'lua', 'tum', 'tr', 'tk', 'tw',
+                                'ug', 'uk', 'ur', 'uz', 'vu', 'vi', 'cy', 'wo', 'xh', 'yi', 'yo', 'zu']
+                               )
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "q": {
+                "name": "Query",
+                "type": "line"
+            },
+            "start": {
+                "name": "From",
+                "type": "integer",
+                "value": 0
+            },
+            "num": {
+                "name": "Limit",
+                "type": "integer",
+                "value": 12
+            }
+        }
+
+class Google(ToolBase, ABC):
+    component_name = "Google"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 12)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("q"):
+            self.set_output("formalized_content", "")
+            return ""
+
+        params = {
+            "api_key": self._param.api_key,
+            "engine": "google",
+            "q": kwargs["q"],
+            "google_domain": "google.com",
+            "gl": self._param.country,
+            "hl": self._param.language
+        }
+        last_e = ""
+        for _ in range(self._param.max_retries+1):
+            try:
+                search = GoogleSearch(params).get_dict()
+                self._retrieve_chunks(search["organic_results"],
+                                      get_title=lambda r: r["title"],
+                                      get_url=lambda r: r["link"],
+                                      get_content=lambda r: r.get("about_this_result", {}).get("source", {}).get("description", r["snippet"])
+                                      )
+                self.set_output("json", search["organic_results"])
+                return self.output("formalized_content")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"Google error: {e}")
+                time.sleep(self._param.delay_after_error)
+
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"Google error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return """
+Keywords: {}
+Looking for the most relevant articles.
+        """.format(self.get_input().get("query", "-_-!"))

agent/tools/googlescholar.py

@@ -0,0 +1,96 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import time
+from abc import ABC
+from scholarly import scholarly
+from agent.tools.base import ToolMeta, ToolParamBase, ToolBase
+from api.utils.api_utils import timeout
+
+
+class GoogleScholarParam(ToolParamBase):
+    """
+    Define the GoogleScholar component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "google_scholar_search",
+            "description": """Google Scholar provides a simple way to broadly search for scholarly literature. From one place, you can search across many disciplines and sources: articles, theses, books, abstracts and court opinions, from academic publishers, professional societies, online repositories, universities and other web sites. Google Scholar helps you find relevant work across the world of scholarly research.""",
+            "parameters": {
+                "query": {
+                    "type": "string",
+                    "description": "The search keyword to execute with Google Scholar. The keywords should be the most important words/terms(includes synonyms) from the original request.",
+                    "default": "{sys.query}",
+                    "required": True
+                }
+            }
+        }
+        super().__init__()
+        self.top_n = 12
+        self.sort_by = 'relevance'
+        self.year_low = None
+        self.year_high = None
+        self.patents = True
+
+    def check(self):
+        self.check_positive_integer(self.top_n, "Top N")
+        self.check_valid_value(self.sort_by, "GoogleScholar Sort_by", ['date', 'relevance'])
+        self.check_boolean(self.patents, "Whether or not to include patents, defaults to True")
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "query": {
+                "name": "Query",
+                "type": "line"
+            }
+        }
+
+class GoogleScholar(ToolBase, ABC):
+    component_name = "GoogleScholar"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 12)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("query"):
+            self.set_output("formalized_content", "")
+            return ""
+
+        last_e = ""
+        for _ in range(self._param.max_retries+1):
+            try:
+                scholar_client = scholarly.search_pubs(kwargs["query"], patents=self._param.patents, year_low=self._param.year_low,
+                                                       year_high=self._param.year_high, sort_by=self._param.sort_by)
+                self._retrieve_chunks(scholar_client,
+                                      get_title=lambda r: r['bib']['title'],
+                                      get_url=lambda r: r["pub_url"],
+                                      get_content=lambda r: "\n author: " + ",".join(r['bib']['author']) + '\n Abstract: ' + r['bib'].get('abstract', 'no abstract')
+                                      )
+                self.set_output("json", list(scholar_client))
+                return self.output("formalized_content")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"GoogleScholar error: {e}")
+                time.sleep(self._param.delay_after_error)
+
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"GoogleScholar error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return "Looking for scholarly papers on `{}`,” prioritising reputable sources.".format(self.get_input().get("query", "-_-!"))

agent/tools/jin10.py

@@ -0,0 +1,130 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import json
+from abc import ABC
+import pandas as pd
+import requests
+from agent.component.base import ComponentBase, ComponentParamBase
+
+
+class Jin10Param(ComponentParamBase):
+    """
+    Define the Jin10 component parameters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.type = "flash"
+        self.secret_key = "xxx"
+        self.flash_type = '1'
+        self.calendar_type = 'cj'
+        self.calendar_datatype = 'data'
+        self.symbols_type = 'GOODS'
+        self.symbols_datatype = 'symbols'
+        self.contain = ""
+        self.filter = ""
+
+    def check(self):
+        self.check_valid_value(self.type, "Type", ['flash', 'calendar', 'symbols', 'news'])
+        self.check_valid_value(self.flash_type, "Flash Type", ['1', '2', '3', '4', '5'])
+        self.check_valid_value(self.calendar_type, "Calendar Type", ['cj', 'qh', 'hk', 'us'])
+        self.check_valid_value(self.calendar_datatype, "Calendar DataType", ['data', 'event', 'holiday'])
+        self.check_valid_value(self.symbols_type, "Symbols Type", ['GOODS', 'FOREX', 'FUTURE', 'CRYPTO'])
+        self.check_valid_value(self.symbols_datatype, 'Symbols DataType', ['symbols', 'quotes'])
+
+
+class Jin10(ComponentBase, ABC):
+    component_name = "Jin10"
+
+    def _run(self, history, **kwargs):
+        ans = self.get_input()
+        ans = " - ".join(ans["content"]) if "content" in ans else ""
+        if not ans:
+            return Jin10.be_output("")
+
+        jin10_res = []
+        headers = {'secret-key': self._param.secret_key}
+        try:
+            if self._param.type == "flash":
+                params = {
+                    'category': self._param.flash_type,
+                    'contain': self._param.contain,
+                    'filter': self._param.filter
+                }
+                response = requests.get(
+                    url='https://open-data-api.jin10.com/data-api/flash?category=' + self._param.flash_type,
+                    headers=headers, data=json.dumps(params))
+                response = response.json()
+                for i in response['data']:
+                    jin10_res.append({"content": i['data']['content']})
+            if self._param.type == "calendar":
+                params = {
+                    'category': self._param.calendar_type
+                }
+                response = requests.get(
+                    url='https://open-data-api.jin10.com/data-api/calendar/' + self._param.calendar_datatype + '?category=' + self._param.calendar_type,
+                    headers=headers, data=json.dumps(params))
+
+                response = response.json()
+                jin10_res.append({"content": pd.DataFrame(response['data']).to_markdown()})
+            if self._param.type == "symbols":
+                params = {
+                    'type': self._param.symbols_type
+                }
+                if self._param.symbols_datatype == "quotes":
+                    params['codes'] = 'BTCUSD'
+                response = requests.get(
+                    url='https://open-data-api.jin10.com/data-api/' + self._param.symbols_datatype + '?type=' + self._param.symbols_type,
+                    headers=headers, data=json.dumps(params))
+                response = response.json()
+                if self._param.symbols_datatype == "symbols":
+                    for i in response['data']:
+                        i['Commodity Code'] = i['c']
+                        i['Stock Exchange'] = i['e']
+                        i['Commodity Name'] = i['n']
+                        i['Commodity Type'] = i['t']
+                        del i['c'], i['e'], i['n'], i['t']
+                if self._param.symbols_datatype == "quotes":
+                    for i in response['data']:
+                        i['Selling Price'] = i['a']
+                        i['Buying Price'] = i['b']
+                        i['Commodity Code'] = i['c']
+                        i['Stock Exchange'] = i['e']
+                        i['Highest Price'] = i['h']
+                        i['Yesterday’s Closing Price'] = i['hc']
+                        i['Lowest Price'] = i['l']
+                        i['Opening Price'] = i['o']
+                        i['Latest Price'] = i['p']
+                        i['Market Quote Time'] = i['t']
+                        del i['a'], i['b'], i['c'], i['e'], i['h'], i['hc'], i['l'], i['o'], i['p'], i['t']
+                jin10_res.append({"content": pd.DataFrame(response['data']).to_markdown()})
+            if self._param.type == "news":
+                params = {
+                    'contain': self._param.contain,
+                    'filter': self._param.filter
+                }
+                response = requests.get(
+                    url='https://open-data-api.jin10.com/data-api/news',
+                    headers=headers, data=json.dumps(params))
+                response = response.json()
+                jin10_res.append({"content": pd.DataFrame(response['data']).to_markdown()})
+        except Exception as e:
+            return Jin10.be_output("**ERROR**: " + str(e))
+
+        if not jin10_res:
+            return Jin10.be_output("")
+
+        return pd.DataFrame(jin10_res)

agent/tools/pubmed.py

@@ -0,0 +1,108 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import time
+from abc import ABC
+from Bio import Entrez
+import re
+import xml.etree.ElementTree as ET
+from agent.tools.base import ToolParamBase, ToolMeta, ToolBase
+from api.utils.api_utils import timeout
+
+
+class PubMedParam(ToolParamBase):
+    """
+    Define the PubMed component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "pubmed_search",
+            "description": """
+PubMed is an openly accessible, free database which includes primarily the MEDLINE database of references and abstracts on life sciences and biomedical topics.
+In addition to MEDLINE, PubMed provides access to:
+ - older references from the print version of Index Medicus, back to 1951 and earlier
+ - references to some journals before they were indexed in Index Medicus and MEDLINE, for instance Science, BMJ, and Annals of Surgery
+ - very recent entries to records for an article before it is indexed with Medical Subject Headings (MeSH) and added to MEDLINE
+ - a collection of books available full-text and other subsets of NLM records[4]
+ - PMC citations
+ - NCBI Bookshelf
+            """,
+            "parameters": {
+                "query": {
+                    "type": "string",
+                    "description": "The search keywords to execute with PubMed. The keywords should be the most important words/terms(includes synonyms) from the original request.",
+                    "default": "{sys.query}",
+                    "required": True
+                }
+            }
+        }
+        super().__init__()
+        self.top_n = 12
+        self.email = "A.N.Other@example.com"
+
+    def check(self):
+        self.check_positive_integer(self.top_n, "Top N")
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "query": {
+                "name": "Query",
+                "type": "line"
+            }
+        }
+
+class PubMed(ToolBase, ABC):
+    component_name = "PubMed"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 12)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("query"):
+            self.set_output("formalized_content", "")
+            return ""
+
+        last_e = ""
+        for _ in range(self._param.max_retries+1):
+            try:
+                Entrez.email = self._param.email
+                pubmedids = Entrez.read(Entrez.esearch(db='pubmed', retmax=self._param.top_n, term=kwargs["query"]))['IdList']
+                pubmedcnt = ET.fromstring(re.sub(r'<(/?)b>|<(/?)i>', '', Entrez.efetch(db='pubmed', id=",".join(pubmedids),
+                                                                                       retmode="xml").read().decode("utf-8")))
+                self._retrieve_chunks(pubmedcnt.findall("PubmedArticle"),
+                                      get_title=lambda child: child.find("MedlineCitation").find("Article").find("ArticleTitle").text,
+                                      get_url=lambda child: "https://pubmed.ncbi.nlm.nih.gov/" + child.find("MedlineCitation").find("PMID").text,
+                                      get_content=lambda child: child.find("MedlineCitation") \
+                                                                    .find("Article") \
+                                                                    .find("Abstract") \
+                                                                    .find("AbstractText").text \
+                                                                    if child.find("MedlineCitation")\
+                                                                            .find("Article").find("Abstract")  \
+                                                                    else "No abstract available")
+                return self.output("formalized_content")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"PubMed error: {e}")
+                time.sleep(self._param.delay_after_error)
+
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"PubMed error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return "Looking for scholarly papers on `{}`,” prioritising reputable sources.".format(self.get_input().get("query", "-_-!"))

agent/tools/qweather.py

@@ -0,0 +1,111 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+from abc import ABC
+import pandas as pd
+import requests
+from agent.component.base import ComponentBase, ComponentParamBase
+
+
+class QWeatherParam(ComponentParamBase):
+    """
+    Define the QWeather component parameters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.web_apikey = "xxx"
+        self.lang = "zh"
+        self.type = "weather"
+        self.user_type = 'free'
+        self.error_code = {
+            "204": "The request was successful, but the region you are querying does not have the data you need at this time.",
+            "400": "Request error, may contain incorrect request parameters or missing mandatory request parameters.",
+            "401": "Authentication fails, possibly using the wrong KEY, wrong digital signature, wrong type of KEY (e.g. using the SDK's KEY to access the Web API).",
+            "402": "Exceeded the number of accesses or the balance is not enough to support continued access to the service, you can recharge, upgrade the accesses or wait for the accesses to be reset.",
+            "403": "No access, may be the binding PackageName, BundleID, domain IP address is inconsistent, or the data that requires additional payment.",
+            "404": "The queried data or region does not exist.",
+            "429": "Exceeded the limited QPM (number of accesses per minute), please refer to the QPM description",
+            "500": "No response or timeout, interface service abnormality please contact us"
+            }
+        # Weather
+        self.time_period = 'now'
+
+    def check(self):
+        self.check_empty(self.web_apikey, "BaiduFanyi APPID")
+        self.check_valid_value(self.type, "Type", ["weather", "indices", "airquality"])
+        self.check_valid_value(self.user_type, "Free subscription or paid subscription", ["free", "paid"])
+        self.check_valid_value(self.lang, "Use language",
+                               ['zh', 'zh-hant', 'en', 'de', 'es', 'fr', 'it', 'ja', 'ko', 'ru', 'hi', 'th', 'ar', 'pt',
+                                'bn', 'ms', 'nl', 'el', 'la', 'sv', 'id', 'pl', 'tr', 'cs', 'et', 'vi', 'fil', 'fi',
+                                'he', 'is', 'nb'])
+        self.check_valid_value(self.time_period, "Time period", ['now', '3d', '7d', '10d', '15d', '30d'])
+
+
+class QWeather(ComponentBase, ABC):
+    component_name = "QWeather"
+
+    def _run(self, history, **kwargs):
+        ans = self.get_input()
+        ans = "".join(ans["content"]) if "content" in ans else ""
+        if not ans:
+            return QWeather.be_output("")
+
+        try:
+            response = requests.get(
+                url="https://geoapi.qweather.com/v2/city/lookup?location=" + ans + "&key=" + self._param.web_apikey).json()
+            if response["code"] == "200":
+                location_id = response["location"][0]["id"]
+            else:
+                return QWeather.be_output("**Error**" + self._param.error_code[response["code"]])
+
+            base_url = "https://api.qweather.com/v7/" if self._param.user_type == 'paid' else "https://devapi.qweather.com/v7/"
+
+            if self._param.type == "weather":
+                url = base_url + "weather/" + self._param.time_period + "?location=" + location_id + "&key=" + self._param.web_apikey + "&lang=" + self._param.lang
+                response = requests.get(url=url).json()
+                if response["code"] == "200":
+                    if self._param.time_period == "now":
+                        return QWeather.be_output(str(response["now"]))
+                    else:
+                        qweather_res = [{"content": str(i) + "\n"} for i in response["daily"]]
+                        if not qweather_res:
+                            return QWeather.be_output("")
+
+                        df = pd.DataFrame(qweather_res)
+                        return df
+                else:
+                    return QWeather.be_output("**Error**" + self._param.error_code[response["code"]])
+
+            elif self._param.type == "indices":
+                url = base_url + "indices/1d?type=0&location=" + location_id + "&key=" + self._param.web_apikey + "&lang=" + self._param.lang
+                response = requests.get(url=url).json()
+                if response["code"] == "200":
+                    indices_res = response["daily"][0]["date"] + "\n" + "\n".join(
+                        [i["name"] + ": " + i["category"] + ", " + i["text"] for i in response["daily"]])
+                    return QWeather.be_output(indices_res)
+
+                else:
+                    return QWeather.be_output("**Error**" + self._param.error_code[response["code"]])
+
+            elif self._param.type == "airquality":
+                url = base_url + "air/now?location=" + location_id + "&key=" + self._param.web_apikey + "&lang=" + self._param.lang
+                response = requests.get(url=url).json()
+                if response["code"] == "200":
+                    return QWeather.be_output(str(response["now"]))
+                else:
+                    return QWeather.be_output("**Error**" + self._param.error_code[response["code"]])
+        except Exception as e:
+            return QWeather.be_output("**Error**" + str(e))

agent/tools/retrieval.py

@@ -0,0 +1,181 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import os
+import re
+from abc import ABC
+from agent.tools.base import ToolParamBase, ToolBase, ToolMeta
+from api.db import LLMType
+from api.db.services.knowledgebase_service import KnowledgebaseService
+from api.db.services.llm_service import LLMBundle
+from api import settings
+from api.utils.api_utils import timeout
+from rag.app.tag import label_question
+from rag.prompts.generator import cross_languages, kb_prompt
+
+
+class RetrievalParam(ToolParamBase):
+    """
+    Define the Retrieval component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "search_my_dateset",
+            "description": "This tool can be utilized for relevant content searching in the datasets.",
+            "parameters": {
+                "query": {
+                    "type": "string",
+                    "description": "The keywords to search the dataset. The keywords should be the most important words/terms(includes synonyms) from the original request.",
+                    "default": "",
+                    "required": True
+                }
+            }
+        }
+        super().__init__()
+        self.function_name = "search_my_dateset"
+        self.description = "This tool can be utilized for relevant content searching in the datasets."
+        self.similarity_threshold = 0.2
+        self.keywords_similarity_weight = 0.5
+        self.top_n = 8
+        self.top_k = 1024
+        self.kb_ids = []
+        self.kb_vars = []
+        self.rerank_id = ""
+        self.empty_response = ""
+        self.use_kg = False
+        self.cross_languages = []
+
+    def check(self):
+        self.check_decimal_float(self.similarity_threshold, "[Retrieval] Similarity threshold")
+        self.check_decimal_float(self.keywords_similarity_weight, "[Retrieval] Keyword similarity weight")
+        self.check_positive_number(self.top_n, "[Retrieval] Top N")
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "query": {
+                "name": "Query",
+                "type": "line"
+            }
+        }
+
+class Retrieval(ToolBase, ABC):
+    component_name = "Retrieval"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 12)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("query"):
+            self.set_output("formalized_content", self._param.empty_response)
+
+        kb_ids: list[str] = []
+        for id in self._param.kb_ids:
+            if id.find("@") < 0:
+                kb_ids.append(id)
+                continue
+            kb_nm = self._canvas.get_variable_value(id)
+            # if kb_nm is a list
+            kb_nm_list = kb_nm if isinstance(kb_nm, list) else [kb_nm]
+            for nm_or_id in kb_nm_list:
+                e, kb = KnowledgebaseService.get_by_name(nm_or_id,
+                                                         self._canvas._tenant_id)
+                if not e:
+                    e, kb = KnowledgebaseService.get_by_id(nm_or_id)
+                    if not e:
+                        raise Exception(f"Dataset({nm_or_id}) does not exist.")
+                kb_ids.append(kb.id)
+
+        filtered_kb_ids: list[str] = list(set([kb_id for kb_id in kb_ids if kb_id]))
+
+        kbs = KnowledgebaseService.get_by_ids(filtered_kb_ids)
+        if not kbs:
+            raise Exception("No dataset is selected.")
+
+        embd_nms = list(set([kb.embd_id for kb in kbs]))
+        assert len(embd_nms) == 1, "Knowledge bases use different embedding models."
+
+        embd_mdl = None
+        if embd_nms:
+            embd_mdl = LLMBundle(self._canvas.get_tenant_id(), LLMType.EMBEDDING, embd_nms[0])
+
+        rerank_mdl = None
+        if self._param.rerank_id:
+            rerank_mdl = LLMBundle(kbs[0].tenant_id, LLMType.RERANK, self._param.rerank_id)
+
+        vars = self.get_input_elements_from_text(kwargs["query"])
+        vars = {k:o["value"] for k,o in vars.items()}
+        query = self.string_format(kwargs["query"], vars)
+        if self._param.cross_languages:
+            query = cross_languages(kbs[0].tenant_id, None, query, self._param.cross_languages)
+
+        if kbs:
+            query = re.sub(r"^user[:：\s]*", "", query, flags=re.IGNORECASE)
+            kbinfos = settings.retrievaler.retrieval(
+                query,
+                embd_mdl,
+                [kb.tenant_id for kb in kbs],
+                filtered_kb_ids,
+                1,
+                self._param.top_n,
+                self._param.similarity_threshold,
+                1 - self._param.keywords_similarity_weight,
+                aggs=False,
+                rerank_mdl=rerank_mdl,
+                rank_feature=label_question(query, kbs),
+            )
+            if self._param.use_kg:
+                ck = settings.kg_retrievaler.retrieval(query,
+                                                       [kb.tenant_id for kb in kbs],
+                                                       kb_ids,
+                                                       embd_mdl,
+                                                       LLMBundle(self._canvas.get_tenant_id(), LLMType.CHAT))
+                if ck["content_with_weight"]:
+                    kbinfos["chunks"].insert(0, ck)
+        else:
+            kbinfos = {"chunks": [], "doc_aggs": []}
+
+        if self._param.use_kg and kbs:
+            ck = settings.kg_retrievaler.retrieval(query, [kb.tenant_id for kb in kbs], filtered_kb_ids, embd_mdl, LLMBundle(kbs[0].tenant_id, LLMType.CHAT))
+            if ck["content_with_weight"]:
+                ck["content"] = ck["content_with_weight"]
+                del ck["content_with_weight"]
+                kbinfos["chunks"].insert(0, ck)
+
+        for ck in kbinfos["chunks"]:
+            if "vector" in ck:
+                del ck["vector"]
+            if "content_ltks" in ck:
+                del ck["content_ltks"]
+
+        if not kbinfos["chunks"]:
+            self.set_output("formalized_content", self._param.empty_response)
+            return
+
+        # Format the chunks for JSON output (similar to how other tools do it)
+        json_output = kbinfos["chunks"].copy()
+
+        self._canvas.add_reference(kbinfos["chunks"], kbinfos["doc_aggs"])
+        form_cnt = "\n".join(kb_prompt(kbinfos, 200000, True))
+
+        # Set both formalized content and JSON output
+        self.set_output("formalized_content", form_cnt)
+        self.set_output("json", json_output)
+
+        return form_cnt
+
+    def thoughts(self) -> str:
+        return """
+Keywords: {}
+Looking for the most relevant articles.
+        """.format(self.get_input().get("query", "-_-!"))

agent/tools/searxng.py

@@ -0,0 +1,151 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import time
+from abc import ABC
+import requests
+from agent.tools.base import ToolMeta, ToolParamBase, ToolBase
+from api.utils.api_utils import timeout
+
+
+class SearXNGParam(ToolParamBase):
+    """
+    Define the SearXNG component parameters.
+    """
+
+    def __init__(self):
+        self.meta: ToolMeta = {
+            "name": "searxng_search",
+            "description": "SearXNG is a privacy-focused metasearch engine that aggregates results from multiple search engines without tracking users. It provides comprehensive web search capabilities.",
+            "parameters": {
+                "query": {
+                    "type": "string",
+                    "description": "The search keywords to execute with SearXNG. The keywords should be the most important words/terms(includes synonyms) from the original request.",
+                    "default": "{sys.query}",
+                    "required": True
+                },
+                "searxng_url": {
+                    "type": "string",
+                    "description": "The base URL of your SearXNG instance (e.g., http://localhost:4000). This is required to connect to your SearXNG server.",
+                    "required": False,
+                    "default": ""
+                }
+            }
+        }
+        super().__init__()
+        self.top_n = 10
+        self.searxng_url = ""
+
+    def check(self):
+        # Keep validation lenient so opening try-run panel won't fail without URL.
+        # Coerce top_n to int if it comes as string from UI.
+        try:
+            if isinstance(self.top_n, str):
+                self.top_n = int(self.top_n.strip())
+        except Exception:
+            pass
+        self.check_positive_integer(self.top_n, "Top N")
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "query": {
+                "name": "Query",
+                "type": "line"
+            },
+            "searxng_url": {
+                "name": "SearXNG URL",
+                "type": "line",
+                "placeholder": "http://localhost:4000"
+            }
+        }
+
+
+class SearXNG(ToolBase, ABC):
+    component_name = "SearXNG"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 12)))
+    def _invoke(self, **kwargs):
+        # Gracefully handle try-run without inputs
+        query = kwargs.get("query")
+        if not query or not isinstance(query, str) or not query.strip():
+            self.set_output("formalized_content", "")
+            return ""
+
+        searxng_url = (getattr(self._param, "searxng_url", "") or kwargs.get("searxng_url") or "").strip()
+        # In try-run, if no URL configured, just return empty instead of raising
+        if not searxng_url:
+            self.set_output("formalized_content", "")
+            return ""
+
+        last_e = ""
+        for _ in range(self._param.max_retries+1):
+            try:
+                search_params = {
+                    'q': query,
+                    'format': 'json',
+                    'categories': 'general',
+                    'language': 'auto',
+                    'safesearch': 1,
+                    'pageno': 1
+                }
+
+                response = requests.get(
+                    f"{searxng_url}/search",
+                    params=search_params,
+                    timeout=10
+                )
+                response.raise_for_status()
+
+                data = response.json()
+
+                if not data or not isinstance(data, dict):
+                    raise ValueError("Invalid response from SearXNG")
+
+                results = data.get("results", [])
+                if not isinstance(results, list):
+                    raise ValueError("Invalid results format from SearXNG")
+
+                results = results[:self._param.top_n]
+
+                self._retrieve_chunks(results,
+                                      get_title=lambda r: r.get("title", ""),
+                                      get_url=lambda r: r.get("url", ""),
+                                      get_content=lambda r: r.get("content", ""))
+
+                self.set_output("json", results)
+                return self.output("formalized_content")
+
+            except requests.RequestException as e:
+                last_e = f"Network error: {e}"
+                logging.exception(f"SearXNG network error: {e}")
+                time.sleep(self._param.delay_after_error)
+            except Exception as e:
+                last_e = str(e)
+                logging.exception(f"SearXNG error: {e}")
+                time.sleep(self._param.delay_after_error)
+
+        if last_e:
+            self.set_output("_ERROR", last_e)
+            return f"SearXNG error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return """
+Keywords: {}
+Searching with SearXNG for relevant results...
+                """.format(self.get_input().get("query", "-_-!"))

agent/tools/tavily.py

@@ -0,0 +1,227 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import time
+from abc import ABC
+from tavily import TavilyClient
+from agent.tools.base import ToolParamBase, ToolBase, ToolMeta
+from api.utils.api_utils import timeout
+
+
+class TavilySearchParam(ToolParamBase):
+    """
+    Define the Retrieval component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "tavily_search",
+            "description": """
+Tavily is a search engine optimized for LLMs, aimed at efficient, quick and persistent search results.
+When searching:
+   - Start with specific query which should focus on just a single aspect.
+   - Number of keywords in query should be less than 5.
+   - Broaden search terms if needed
+   - Cross-reference information from multiple sources
+             """,
+            "parameters": {
+                "query": {
+                    "type": "string",
+                    "description": "The search keywords to execute with Tavily. The keywords should be the most important words/terms(includes synonyms) from the original request.",
+                    "default": "{sys.query}",
+                    "required": True
+                },
+                "topic": {
+                    "type": "string",
+                    "description": "default:general. The category of the search.news is useful for retrieving real-time updates, particularly about politics, sports, and major current events covered by mainstream media sources. general is for broader, more general-purpose searches that may include a wide range of sources.",
+                    "enum": ["general", "news"],
+                    "default": "general",
+                    "required": False,
+                },
+                "include_domains": {
+                    "type": "array",
+                    "description": "default:[]. A list of domains only from which the search results can be included.",
+                    "default": [],
+                    "items": {
+                        "type": "string",
+                        "description": "Domain name that must be included, e.g. www.yahoo.com"
+                    },
+                    "required": False
+                },
+                "exclude_domains": {
+                    "type": "array",
+                    "description": "default:[]. A list of domains from which the search results can not be included",
+                    "default": [],
+                    "items": {
+                        "type": "string",
+                        "description": "Domain name that must be excluded, e.g. www.yahoo.com"
+                    },
+                    "required": False
+                },
+            }
+        }
+        super().__init__()
+        self.api_key = ""
+        self.search_depth = "basic" # basic/advanced
+        self.max_results = 6
+        self.days = 14
+        self.include_answer = False
+        self.include_raw_content = False
+        self.include_images = False
+        self.include_image_descriptions = False
+
+    def check(self):
+        self.check_valid_value(self.topic, "Tavily topic: should be in 'general/news'", ["general", "news"])
+        self.check_valid_value(self.search_depth, "Tavily search depth should be in 'basic/advanced'", ["basic", "advanced"])
+        self.check_positive_integer(self.max_results, "Tavily max result number should be within [1， 20]")
+        self.check_positive_integer(self.days, "Tavily days should be greater than 1")
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "query": {
+                "name": "Query",
+                "type": "line"
+            }
+        }
+
+class TavilySearch(ToolBase, ABC):
+    component_name = "TavilySearch"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 12)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("query"):
+            self.set_output("formalized_content", "")
+            return ""
+
+        self.tavily_client = TavilyClient(api_key=self._param.api_key)
+        last_e = None
+        for fld in ["search_depth", "topic", "max_results", "days", "include_answer", "include_raw_content", "include_images", "include_image_descriptions", "include_domains", "exclude_domains"]:
+            if fld not in kwargs:
+                kwargs[fld] = getattr(self._param, fld)
+        for _ in range(self._param.max_retries+1):
+            try:
+                kwargs["include_images"] = False
+                kwargs["include_raw_content"] = False
+                res = self.tavily_client.search(**kwargs)
+                self._retrieve_chunks(res["results"],
+                                      get_title=lambda r: r["title"],
+                                      get_url=lambda r: r["url"],
+                                      get_content=lambda r: r["raw_content"] if r["raw_content"] else r["content"],
+                                      get_score=lambda r: r["score"])
+                self.set_output("json", res["results"])
+                return self.output("formalized_content")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"Tavily error: {e}")
+                time.sleep(self._param.delay_after_error)
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"Tavily error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return """
+Keywords: {}
+Looking for the most relevant articles.
+                """.format(self.get_input().get("query", "-_-!"))
+
+
+class TavilyExtractParam(ToolParamBase):
+    """
+    Define the Retrieval component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "tavily_extract",
+            "description": "Extract web page content from one or more specified URLs using Tavily Extract.",
+            "parameters": {
+                "urls": {
+                    "type": "array",
+                    "description": "The URLs to extract content from.",
+                    "default": "",
+                    "items": {
+                        "type": "string",
+                        "description": "The URL to extract content from, e.g. www.yahoo.com"
+                    },
+                    "required": True
+                },
+                "extract_depth": {
+                    "type": "string",
+                    "description": "The depth of the extraction process. advanced extraction retrieves more data, including tables and embedded content, with higher success but may increase latency.basic extraction costs 1 credit per 5 successful URL extractions, while advanced extraction costs 2 credits per 5 successful URL extractions.",
+                    "enum": ["basic", "advanced"],
+                    "default": "basic",
+                    "required": False,
+                },
+                "format": {
+                    "type": "string",
+                    "description": "The format of the extracted web page content. markdown returns content in markdown format. text returns plain text and may increase latency.",
+                    "enum": ["markdown", "text"],
+                    "default": "markdown",
+                    "required": False,
+                }
+            }
+        }
+        super().__init__()
+        self.api_key = ""
+        self.extract_depth = "basic" # basic/advanced
+        self.urls = []
+        self.format = "markdown"
+        self.include_images = False
+
+    def check(self):
+        self.check_valid_value(self.extract_depth, "Tavily extract depth should be in 'basic/advanced'", ["basic", "advanced"])
+        self.check_valid_value(self.format, "Tavily extract format should be in 'markdown/text'", ["markdown", "text"])
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "urls": {
+                "name": "URLs",
+                "type": "line"
+            }
+        }
+
+class TavilyExtract(ToolBase, ABC):
+    component_name = "TavilyExtract"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 10*60)))
+    def _invoke(self, **kwargs):
+        self.tavily_client = TavilyClient(api_key=self._param.api_key)
+        last_e = None
+        for fld in ["urls", "extract_depth", "format"]:
+            if fld not in kwargs:
+                kwargs[fld] = getattr(self._param, fld)
+        if kwargs.get("urls") and isinstance(kwargs["urls"], str):
+            kwargs["urls"] = kwargs["urls"].split(",")
+        for _ in range(self._param.max_retries+1):
+            try:
+                kwargs["include_images"] = False
+                res = self.tavily_client.extract(**kwargs)
+                self.set_output("json", res["results"])
+                return self.output("json")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"Tavily error: {e}")
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"Tavily error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return "Opened {}—pulling out the main text…".format(self.get_input().get("urls", "-_-!"))

agent/tools/tushare.py

@@ -0,0 +1,72 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import json
+from abc import ABC
+import pandas as pd
+import time
+import requests
+from agent.component.base import ComponentBase, ComponentParamBase
+
+
+class TuShareParam(ComponentParamBase):
+    """
+    Define the TuShare component parameters.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.token = "xxx"
+        self.src = "eastmoney"
+        self.start_date = "2024-01-01 09:00:00"
+        self.end_date = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+        self.keyword = ""
+
+    def check(self):
+        self.check_valid_value(self.src, "Quick News Source",
+                               ["sina", "wallstreetcn", "10jqka", "eastmoney", "yuncaijing", "fenghuang", "jinrongjie"])
+
+
+class TuShare(ComponentBase, ABC):
+    component_name = "TuShare"
+
+    def _run(self, history, **kwargs):
+        ans = self.get_input()
+        ans = ",".join(ans["content"]) if "content" in ans else ""
+        if not ans:
+            return TuShare.be_output("")
+
+        try:
+            tus_res = []
+            params = {
+                "api_name": "news",
+                "token": self._param.token,
+                "params": {"src": self._param.src, "start_date": self._param.start_date,
+                           "end_date": self._param.end_date}
+            }
+            response = requests.post(url="http://api.tushare.pro", data=json.dumps(params).encode('utf-8'))
+            response = response.json()
+            if response['code'] != 0:
+                return TuShare.be_output(response['msg'])
+            df = pd.DataFrame(response['data']['items'])
+            df.columns = response['data']['fields']
+            tus_res.append({"content": (df[df['content'].str.contains(self._param.keyword, case=False)]).to_markdown()})
+        except Exception as e:
+            return TuShare.be_output("**ERROR**: " + str(e))
+
+        if not tus_res:
+            return TuShare.be_output("")
+
+        return pd.DataFrame(tus_res)

agent/tools/wencai.py

@@ -0,0 +1,114 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import time
+from abc import ABC
+import pandas as pd
+import pywencai
+
+from agent.tools.base import ToolParamBase, ToolMeta, ToolBase
+from api.utils.api_utils import timeout
+
+
+class WenCaiParam(ToolParamBase):
+    """
+    Define the WenCai component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "iwencai",
+            "description": """
+iwencai search: search platform is committed to providing hundreds of millions of investors with the most timely, accurate and comprehensive information, covering news, announcements, research reports, blogs, forums, Weibo, characters, etc.
+robo-advisor intelligent stock selection platform: through AI technology, is committed to providing investors with intelligent stock selection, quantitative investment, main force tracking, value investment, technical analysis and other types of stock selection technologies.
+fund selection platform: through AI technology, is committed to providing excellent fund, value investment, quantitative analysis and other fund selection technologies for foundation citizens.
+""",
+            "parameters": {
+                "query": {
+                    "type": "string",
+                    "description": "The question/conditions to select stocks.",
+                    "default": "{sys.query}",
+                    "required": True
+                }
+            }
+        }
+        super().__init__()
+        self.top_n = 10
+        self.query_type = "stock"
+
+    def check(self):
+        self.check_positive_integer(self.top_n, "Top N")
+        self.check_valid_value(self.query_type, "Query type",
+                               ['stock', 'zhishu', 'fund', 'hkstock', 'usstock', 'threeboard', 'conbond', 'insurance',
+                                'futures', 'lccp',
+                                'foreign_exchange'])
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "query": {
+                "name": "Query",
+                "type": "line"
+            }
+        }
+
+class WenCai(ToolBase, ABC):
+    component_name = "WenCai"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 12)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("query"):
+            self.set_output("report", "")
+            return ""
+
+        last_e = ""
+        for _ in range(self._param.max_retries+1):
+            try:
+                wencai_res = []
+                res = pywencai.get(query=kwargs["query"], query_type=self._param.query_type, perpage=self._param.top_n)
+                if isinstance(res, pd.DataFrame):
+                    wencai_res.append(res.to_markdown())
+                elif isinstance(res, dict):
+                    for item in res.items():
+                        if isinstance(item[1], list):
+                            wencai_res.append(item[0] + "\n" + pd.DataFrame(item[1]).to_markdown())
+                        elif isinstance(item[1], str):
+                            wencai_res.append(item[0] + "\n" + item[1])
+                        elif isinstance(item[1], dict):
+                            if "meta" in item[1].keys():
+                                continue
+                            wencai_res.append(pd.DataFrame.from_dict(item[1], orient='index').to_markdown())
+                        elif isinstance(item[1], pd.DataFrame):
+                            if "image_url" in item[1].columns:
+                                continue
+                            wencai_res.append(item[1].to_markdown())
+                        else:
+                            wencai_res.append(item[0] + "\n" + str(item[1]))
+                self.set_output("report", "\n\n".join(wencai_res))
+                return self.output("report")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"WenCai error: {e}")
+                time.sleep(self._param.delay_after_error)
+
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"WenCai error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return "Pulling live financial data for `{}`.".format(self.get_input().get("query", "-_-!"))

agent/tools/wikipedia.py

@@ -0,0 +1,104 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import time
+from abc import ABC
+import wikipedia
+from agent.tools.base import ToolMeta, ToolParamBase, ToolBase
+from api.utils.api_utils import timeout
+
+
+class WikipediaParam(ToolParamBase):
+    """
+    Define the Wikipedia component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "wikipedia_search",
+            "description": """A wide range of how-to and information pages are made available in wikipedia. Since 2001, it has grown rapidly to become the world's largest reference website. From Wikipedia, the free encyclopedia.""",
+            "parameters": {
+                "query": {
+                    "type": "string",
+                    "description": "The search keyword to execute with wikipedia. The keyword MUST be a specific subject that can match the title.",
+                    "default": "{sys.query}",
+                    "required": True
+                }
+            }
+        }
+        super().__init__()
+        self.top_n = 10
+        self.language = "en"
+
+    def check(self):
+        self.check_positive_integer(self.top_n, "Top N")
+        self.check_valid_value(self.language, "Wikipedia languages",
+                               ['af', 'pl', 'ar', 'ast', 'az', 'bg', 'nan', 'bn', 'be', 'ca', 'cs', 'cy', 'da', 'de',
+                                'et', 'el', 'en', 'es', 'eo', 'eu', 'fa', 'fr', 'gl', 'ko', 'hy', 'hi', 'hr', 'id',
+                                'it', 'he', 'ka', 'lld', 'la', 'lv', 'lt', 'hu', 'mk', 'arz', 'ms', 'min', 'my', 'nl',
+                                'ja', 'nb', 'nn', 'ce', 'uz', 'pt', 'kk', 'ro', 'ru', 'ceb', 'sk', 'sl', 'sr', 'sh',
+                                'fi', 'sv', 'ta', 'tt', 'th', 'tg', 'azb', 'tr', 'uk', 'ur', 'vi', 'war', 'zh', 'yue'])
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "query": {
+                "name": "Query",
+                "type": "line"
+            }
+        }
+
+class Wikipedia(ToolBase, ABC):
+    component_name = "Wikipedia"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 60)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("query"):
+            self.set_output("formalized_content", "")
+            return ""
+
+        last_e = ""
+        for _ in range(self._param.max_retries+1):
+            try:
+                wikipedia.set_lang(self._param.language)
+                wiki_engine = wikipedia
+                pages = []
+                for p in wiki_engine.search(kwargs["query"], results=self._param.top_n):
+                    try:
+                        pages.append(wikipedia.page(p))
+                    except Exception:
+                        pass
+                self._retrieve_chunks(pages,
+                                      get_title=lambda r: r.title,
+                                      get_url=lambda r: r.url,
+                                      get_content=lambda r: r.summary)
+                return self.output("formalized_content")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"Wikipedia error: {e}")
+                time.sleep(self._param.delay_after_error)
+
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"Wikipedia error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return """
+Keywords: {}
+Looking for the most relevant articles.
+        """.format(self.get_input().get("query", "-_-!"))

agent/tools/yahoofinance.py

@@ -0,0 +1,114 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+import os
+import time
+from abc import ABC
+import pandas as pd
+import yfinance as yf
+from agent.tools.base import ToolMeta, ToolParamBase, ToolBase
+from api.utils.api_utils import timeout
+
+
+class YahooFinanceParam(ToolParamBase):
+    """
+    Define the YahooFinance component parameters.
+    """
+
+    def __init__(self):
+        self.meta:ToolMeta = {
+            "name": "yahoo_finance",
+            "description": "The Yahoo Finance is a service that provides access to real-time and historical stock market data. It enables users to fetch various types of stock information, such as price quotes, historical prices, company profiles, and financial news. The API offers structured data, allowing developers to integrate market data into their applications and analysis tools.",
+            "parameters": {
+                "stock_code": {
+                    "type": "string",
+                    "description": "The stock code or company name.",
+                    "default": "{sys.query}",
+                    "required": True
+                }
+            }
+        }
+        super().__init__()
+        self.info = True
+        self.history = False
+        self.count = False
+        self.financials = False
+        self.income_stmt = False
+        self.balance_sheet = False
+        self.cash_flow_statement = False
+        self.news = True
+
+    def check(self):
+        self.check_boolean(self.info, "get all stock info")
+        self.check_boolean(self.history, "get historical market data")
+        self.check_boolean(self.count, "show share count")
+        self.check_boolean(self.financials, "show financials")
+        self.check_boolean(self.income_stmt, "income statement")
+        self.check_boolean(self.balance_sheet, "balance sheet")
+        self.check_boolean(self.cash_flow_statement, "cash flow statement")
+        self.check_boolean(self.news, "show news")
+
+    def get_input_form(self) -> dict[str, dict]:
+        return {
+            "stock_code": {
+                "name": "Stock code/Company name",
+                "type": "line"
+            }
+        }
+
+class YahooFinance(ToolBase, ABC):
+    component_name = "YahooFinance"
+
+    @timeout(int(os.environ.get("COMPONENT_EXEC_TIMEOUT", 60)))
+    def _invoke(self, **kwargs):
+        if not kwargs.get("stock_code"):
+            self.set_output("report", "")
+            return ""
+
+        last_e = ""
+        for _ in range(self._param.max_retries+1):
+            yohoo_res = []
+            try:
+                msft = yf.Ticker(kwargs["stock_code"])
+                if self._param.info:
+                    yohoo_res.append("# Information:\n" + pd.Series(msft.info).to_markdown() + "\n")
+                if self._param.history:
+                    yohoo_res.append("# History:\n" + msft.history().to_markdown() + "\n")
+                if self._param.financials:
+                    yohoo_res.append("# Calendar:\n" + pd.DataFrame(msft.calendar).to_markdown() + "\n")
+                if self._param.balance_sheet:
+                    yohoo_res.append("# Balance sheet:\n" + msft.balance_sheet.to_markdown() + "\n")
+                    yohoo_res.append("# Quarterly balance sheet:\n" + msft.quarterly_balance_sheet.to_markdown() + "\n")
+                if self._param.cash_flow_statement:
+                    yohoo_res.append("# Cash flow statement:\n" + msft.cashflow.to_markdown() + "\n")
+                    yohoo_res.append("# Quarterly cash flow statement:\n" + msft.quarterly_cashflow.to_markdown() + "\n")
+                if self._param.news:
+                    yohoo_res.append("# News:\n" + pd.DataFrame(msft.news).to_markdown() + "\n")
+                self.set_output("report", "\n\n".join(yohoo_res))
+                return self.output("report")
+            except Exception as e:
+                last_e = e
+                logging.exception(f"YahooFinance error: {e}")
+                time.sleep(self._param.delay_after_error)
+
+        if last_e:
+            self.set_output("_ERROR", str(last_e))
+            return f"YahooFinance error: {last_e}"
+
+        assert False, self.output()
+
+    def thoughts(self) -> str:
+        return "Pulling live financial data for `{}`.".format(self.get_input().get("stock_code", "-_-!"))