Workflow generation method and device based on large model and product

Abstract

The invention provides a workflow generation method and device based on a large model, electronic equipment, a storage medium and a computer program product, relates to the technical field of artificial intelligence, in particular to the technical fields of large models, natural language understanding, workflows and the like, and can be applied to a workflow generation scene. According to the specific implementation scheme, a workflow generation request is analyzed, and a workflow generation intention is determined; through an artificial intelligence large model, a target tool used for generating a workflow meeting the workflow generation intention is determined from a tool library, and the tool library comprises a plurality of workflow construction tools; and generating the workflow by adopting the target tool. According to the method and the device, the workflow generation request is mapped into the target tool for constructing the workflow based on the artificial intelligence large model, so that the workflow meeting the workflow generation intention is generated, the automatic process development threshold is greatly reduced, and the automatic experience that the workflow generation request is what is obtained (workflow) is realized.

Description

Technical Field

[0001] This disclosure relates to the field of artificial intelligence technology, specifically to the fields of large models, natural language understanding, and workflow, and particularly to a workflow generation method, apparatus, electronic device, storage medium, and computer program product based on a large model, which can be applied to workflow generation scenarios. Background Technology

[0002] Developers and operations staff face numerous repetitive, high-frequency cross-system operation requirements in their daily work, such as in-app promotion, data collection, automated testing, and content publishing. These tasks typically require scripting or the use of complex RPA (Robotic Process Automation) tools. Summary of the Invention

[0003] This disclosure provides a workflow generation method, apparatus, electronic device, storage medium, and computer program product based on a large model.

[0004] According to the first aspect, a workflow generation method based on a large model is provided, including: parsing a workflow generation request and determining the workflow generation intent; using an artificial intelligence large model to determine a target tool from a tool library for generating a workflow that meets the workflow generation intent, wherein the tool library includes multiple workflow building tools; and using the target tool to generate the workflow.

[0005] According to the second aspect, a workflow generation device based on a large model is provided, comprising: an intent determination unit configured to parse a workflow generation request and determine a workflow generation intent; a tool determination unit configured to determine a target tool for generating a workflow that satisfies the workflow generation intent from a tool library using an artificial intelligence large model, wherein the tool library includes multiple workflow building tools; and a workflow generation unit configured to use the target tool to generate a workflow.

[0006] According to a third aspect, an electronic device is provided, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform a method as described in any implementation of the first aspect.

[0007] According to a fourth aspect, a non-transitory computer-readable storage medium is provided that stores computer instructions for causing a computer to perform the method described in any implementation of the first aspect.

[0008] According to a fifth aspect, a computer program product is provided, comprising: a computer program that, when executed by a processor, implements the method as described in any implementation of the first aspect.

[0009] According to the technology disclosed herein, a workflow generation method and apparatus based on a large model are provided. The method involves parsing a workflow generation request to determine the workflow generation intent; using an artificial intelligence large model, a target tool is identified from a tool library to generate a workflow that satisfies the workflow generation intent, wherein the tool library includes multiple workflow building tools; and the target tool is used to generate the workflow. This mapping of the workflow generation request to the target tool for workflow construction, based on the artificial intelligence large model, significantly reduces the development threshold for automated processes and achieves an automated experience where "what is (the workflow generation request) is what you get (the workflow)".

[0010] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this disclosure, nor is it intended to limit the scope of this disclosure. Other features of this disclosure will become readily apparent from the following description. Attached Figure Description

[0011] The accompanying drawings are provided to better understand this solution and do not constitute a limitation of this disclosure. Wherein: Figure 1 This is an exemplary system architecture diagram that can be applied to an embodiment of this disclosure; Figure 2 This is a flowchart of an embodiment of the workflow generation method based on a large model according to the present disclosure; Figure 3 This is a schematic diagram of the architecture of the workflow generation system based on a large model according to this embodiment; Figure 4 This is a schematic diagram of the workflow generation process based on a large model according to this embodiment; Figure 5 This is a schematic diagram of the framework corresponding to the workflow in this embodiment; Figure 6 This is a schematic diagram illustrating an application scenario of the workflow generation method based on a large model according to this embodiment; Figure 7 This is a data flow diagram of the workflow generation process according to this embodiment; Figure 8 This is a flowchart of yet another embodiment of the workflow generation method based on a large model according to the present disclosure; Figure 9 This is a structural diagram of an embodiment of the workflow generation apparatus based on a large model according to the present disclosure; Figure 10This is a schematic diagram of the structure of a computer system suitable for implementing the embodiments of the present disclosure. Detailed Implementation

[0012] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding, and should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0013] The collection, storage, use, processing, transmission, provision, and disclosure of user personal information involved in the technical solution disclosed herein comply with the provisions of relevant laws and regulations and do not violate public order and good morals.

[0014] Figure 1 An exemplary architecture 100 is shown that can be applied to the large-model-based workflow generation method and apparatus disclosed herein.

[0015] like Figure 1 As shown, the system architecture 100 may include terminal devices 101, 102, and 103, a network 104, and a server 105. The communication connections between terminal devices 101, 102, and 103 form a network topology. Network 104 serves as the medium for providing communication links between terminal devices 101, 102, and 103 and server 105. Network 104 may include various connection types, such as wired or wireless communication links or fiber optic cables, etc.

[0016] Terminal devices 101, 102, and 103 can be hardware or software that supports network connectivity for data interaction and processing. When terminal devices 101, 102, and 103 are hardware, they can be various electronic devices that support network connectivity, information acquisition, interaction, display, and processing functions, including but not limited to smartphones, tablets, e-book readers, laptops, and desktop computers. When terminal devices 101, 102, and 103 are software, they can be installed in the aforementioned electronic devices. They can be implemented as, for example, multiple software programs or software modules to provide distributed services, or as a single software program or software module. No specific limitations are imposed here.

[0017] Server 105 can be a server that provides various services, such as a backend processing server that receives workflow generation requests from users through terminal devices 101, 102, and 103, and combines them with a large artificial intelligence model and a toolkit for building workflows. As an example, server 105 can be a cloud server.

[0018] It should be noted that a server can be either hardware or software. When the server is hardware, it can be implemented as a distributed server cluster consisting of multiple servers, or as a single server. When the server is software, it can be implemented as multiple software programs or software modules (such as software programs or software modules used to provide distributed services), or as a single software program or software module. No specific limitations are made here.

[0019] It should also be noted that the workflow generation method based on a large model provided in the embodiments of this disclosure is generally executed by a server, but the possibility of it being executed by a terminal device, or by a combination of the server and the terminal device, is not excluded. Accordingly, the various parts (e.g., various units) of the workflow generation device based on a large model can be all located in the server, all located in the terminal device, or separately located in the server and the terminal device.

[0020] It should be understood that Figure 1 The number of terminal devices, networks, and servers shown is merely illustrative. Any number of terminal devices, networks, and servers can be included depending on implementation needs. When the electronic devices running the workflow generation method based on the large model do not require data transmission with other electronic devices, the system architecture may consist only of the electronic devices (e.g., servers or terminal devices) running the workflow generation method based on the large model.

[0021] Please refer to Figure 2 , Figure 2 A flowchart illustrating a workflow generation method based on a large model, provided for embodiments of this disclosure. Flowchart 200 includes the following steps: Step 201: parse the workflow generation request and determine the workflow generation intent.

[0022] In this embodiment, the execution entity of the workflow generation method based on the large model (e.g., Figure 1 The server in the middle can parse the workflow generation request and determine the workflow generation intent.

[0023] Users can issue workflow generation requests via text, voice, or based on triggering actions on workflow generation examples. Workflow requests can include things like "Please check the promotional price of sweet potatoes on the fresh food shopping app," "Please check the two newly released product manager positions, listing the companies and approximate salaries," or "Please check if there are any seats available for the new movie showing at the nearby cinema today."

[0024] As an example, an AI big data model is used to parse workflow generation requests and determine the workflow generation intent. The workflow generation request and prompts used to guide the big data model in parsing the request intent are input into the AI ​​big data model, and the AI ​​big data model outputs the workflow generation intent.

[0025] Large-scale artificial intelligence models (or simply large models) refer to a class of artificial intelligence models with a large number of parameters built from artificial neural networks, such as large language models, large vision models, multimodal large models, and basic science large models. Taking a large language model as an example, it is a large-scale language model built based on deep learning technology, primarily used for natural language processing tasks. Through training on large-scale data, it learns language patterns and structures, enabling it to generate natural language text or understand natural language input. This embodiment may specifically employ a multimodal large language model, which typically includes the following modules: Input module: Receives multimodal data such as text, voice, images, and video input from users, such as workflow generation requests.

[0026] Preprocessing module: preprocesses the input multimodal data. For example, the preprocessing of text data represented by speech includes word segmentation, text cleaning and other operations to convert the text into a form that the model can process.

[0027] The encoding module encodes the preprocessed multimodal data into vector form so that the model can understand and process it. Common encoding methods include word embeddings and encoders in the Transformer architecture. Word embeddings include, for example, Word2Vec (Words to Vector) and GloVe (Global Vectors for Word Representation).

[0028] Model module: The core component, typically based on a deep learning architecture (such as Transformer), responsible for processing encoded data vectors and performing language understanding and generation. The model learns complex patterns and semantic relationships of language through multi-layered neural network structures.

[0029] Decoding module: Decodes the model's output vectors into natural language text, images, and videos, generating response data to user input. Decoding methods can include greedy decoding, beam search, etc.

[0030] Output module: Outputs the decoded text in a user-readable format, such as text, images, and videos displayed on the screen.

[0031] Continue to refer to Figure 3 The diagram shows the architecture of a workflow generation system based on a large model.

[0032] As another example, the workflow generation system includes a Web User Interface (WebUI). The WebUI provides an intuitive interface for users to interact with the system. Users submit automation requests (workflow generation requests) using natural language descriptions. This interface transmits user input to the backend agent (intelligent agent) generated based on a large model and returns the execution results. The workflow generation system guides users to clearly express the core information required for the automation task, such as the triggering conditions and execution actions. Through example-guided and step-by-step confirmation, the accuracy of requirement understanding is improved, ensuring that the input data is structured and complete.

[0033] Continue to refer to Figure 4 This diagram illustrates the workflow generation process based on a large model.

[0034] In some optional implementations of this embodiment, the execution entity can perform step 201 as follows: The first step is to parse the workflow generation request and determine the initial generation intent. The second step involves performing experience recall, application recall, and scenario recall operations based on the initial generated intent, thereby obtaining experience recall data, application recall data, and scenario recall data.

[0035] The third step involves combining the initial generation intent, experience recall data, application recall data, and scenario recall data to obtain the workflow generation intent.

[0036] Experience recall refers to retrieving experiences similar to the current user's input from historical interaction data, common problem solutions, and user behavior preferences accumulated by the system, providing a reference for intent recognition. Data sources include, but are not limited to: user historical dialogue records (e.g., a user repeatedly searched for 'Beijing trending topics' last week, preferring to return the top 10 results); a common problem solution library (e.g., when most users say 'check the weather,' they actually need 'temperature for the next 3 days + advice on whether to bring an umbrella'); and failure case correction records (e.g., if a query error occurred due to not recognizing the time range of 'tomorrow,' experience should be recalled first to complete the time parameter).

[0037] Experience recall is used to complete ambiguous information in user input (e.g., if a user says "check trending searches", experience recall suggests "this user usually defaults to checking trending searches in Shanghai, and the city parameter needs to be added"); to predict potential user needs (e.g., if a user says "send an email", experience recall shows "this user often attaches last week's report, and should be prompted to add an attachment"); and to avoid historical errors (e.g., recall "the reason why similar expressions have caused tool calls to fail", guiding the large model to adjust the parsing logic).

[0038] Application recall refers to retrieving application nodes with the ability to fulfill user intents from the system's "application registry," identifying which applications can fulfill the needs, and providing a basis for mapping intents to application calls. Its data sources include, but are not limited to: The pre-registered application metadata database includes application function descriptions, parameter requirements, and applicable scenarios, such as "a certain application's hot search tool supports querying by city / time"; the application capability tag library (tags applications, such as "email application" is tagged with "communication, file transfer", and "hot search application" is tagged with "information aggregation, real-time data"); and application status information (such as "a certain API (Application Programming Interface) is currently under maintenance and unavailable", to avoid recalling invalid tools).

[0039] Application recall is used to narrow down the scope of application calls (e.g., when a user says "send notification", application recall returns "WeChat Work application, SMS application", excluding irrelevant applications); clarify the boundaries of application capabilities (e.g., when a user says "check overseas hot searches", application recall prompts "currently only a certain application tool supports some overseas cities, and users need to be informed of the restrictions"); and provide a basis for parameter parsing (e.g., recall "hot search tool requires 'city' parameter", guiding the large model to extract or complete this parameter from user input).

[0040] Scenario recall refers to retrieving typical scenarios (such as "multi-platform marketing content publishing" and "daily data summary report") that match user intent from a scenario template library, providing a predefined process framework reference for mapping intent to workflow. Its data sources include, but are not limited to, predefined scenario templates (containing scenario descriptions, typical node combinations, and execution logic, such as the "dual-platform hot search query scenario" template containing "application 1 node → application 2 node → summary node"); scenario tags and trigger word libraries (such as the trigger words for the "hot search query" scenario being "hot search, trending topics, and rankings," and the trigger words for the "email sending" scenario being "send email, email notification"); and scenario-appropriate user roles (such as the "enterprise report scenario" being only open to administrators to avoid recalling irrelevant scenarios to ordinary users).

[0041] Scene recall is used to quickly locate the process framework (e.g., when a user says "summarize today's hot searches", scene recall uses the "hot search summary scenario" template to directly reuse the node combination logic); standardize intent parsing (e.g., different users saying "check hot searches" or "see today's hot topics" are all uniformly mapped to "hot search query scenario" through scene recall to avoid parsing confusion); and support complex intent decomposition (e.g., when a user says "check hot searches first and then send email notification", scene recall uses the combined scenario of "hot search query + email sending" to guide the large model to be decomposed into two sub-processes).

[0042] Step 202: Using a large artificial intelligence model, identify target tools from the tool library to generate workflows that meet the workflow generation intent.

[0043] In this embodiment, the aforementioned execution entity can use a large-scale artificial intelligence model to determine the target tools from a tool library for generating workflows that meet the workflow generation intent. The tool library includes multiple workflow building tools. Workflow building tools refer to the tools involved in the entire workflow building process.

[0044] As an example, firstly, a large-scale AI model is used to deeply analyze the workflow generation intent, extracting core requirement elements, including task objectives (e.g., "data aggregation across two platforms"), input and output data formats (e.g., "receiving trending data in JSON (JavaScript Object Notation) format and outputting an Excel report"), and execution constraints (e.g., "requiring real-time invocation and support for cross-platform interfaces"). Next, the large-scale model transforms these requirement elements into standardized semantic descriptions and semantically aligns them with the capability tags of each tool in the tool library. Each tool in the tool library is pre-labeled with structured semantic tags such as functional descriptions, supported input / output types, and applicable scenarios. The large-scale model uses semantic similarity calculations (e.g., vector matching based on pre-trained language models) to select the tool with the highest match between its capabilities and requirement elements. Then, it performs a secondary ranking based on the tool's real-time availability (e.g., whether the interface is online and whether resource quotas are sufficient) to finally determine the target tool.

[0045] As another example, firstly, a historical case library of "workflow intent-tool combinations" is built. This library stores the optimal tool selection and application effects for different workflow intents in the past (e.g., "The intent 'social media data monitoring' previously used 'Application 1 API tool + Application 1 data scraping tool + data visualization tool', with a 92% success rate"). When a user inputs a new workflow intent, the large model first searches for historical cases semantically similar to the current intent and extracts the tool combinations used in those cases. Then, considering the differentiated requirements of the current intent (e.g., "The current case requires adding a 'data automatically pushed to Application 3' step, while historical cases did not have this requirement"), the tool combinations are adjusted. The large model then selects supplementary tools from the tool library that can meet the differentiated requirements (e.g., "Application 3 push tool") and verifies the compatibility between the new tools and the existing tools (e.g., "Are the data formats compatible, and are there any conflicts in the call sequence?"). Finally, it outputs a list of adjusted target tools with recommendation justifications (e.g., "Referring to the 'social media data monitoring' case, add a WeChat push tool to meet the real-time notification requirements").

[0046] Continue to refer to Figure 4In addition to identifying the target tool, the AI ​​big data model may also involve processing thought processes and textual content during the process of identifying the target tool or other data processing. Under the thought process processing branch, the focus is on the implicit decisions and logical planning of workflow generation. The core is to transform abstract workflow generation intentions into actionable construction logic, without directly processing concrete textual data. To clarify the core objectives of the workflow, the logic of node combination, and the rules of execution order, it addresses the decision-making problem of how to construct the workflow. This includes analyzing the business logic behind user needs (e.g., "data aggregation" needs to be broken down into "collection-cleaning-storage" steps), matching suitable node types and connection relationships, and determining whether to call template libraries or AI tools to assist in planning.

[0047] Under the text content processing branch, the focus is on the explicit text data and parameters of the workflow construction. The core is to transform concrete text information into structured data that conforms to specifications, supporting the implementation of the logical framework output by the content processing branch. This involves converting user-input text requirements (such as "collect daily sales data from e-commerce platforms"), node parameter text (such as "data source URL (Uniform Resource Locator), API Key"), and template metadata text into a machine-readable format, addressing the question of what data to use for construction. This includes text parsing (extracting key parameters, such as identifying "e-commerce platform" and "daily" from the requirements), format validation (checking whether the parameter text conforms to node specifications, such as the API Key format), and structured transformation (converting text parameters into key-value pair formats for node calls).

[0048] Step 203: Use the target tool to generate the workflow.

[0049] In this embodiment, the aforementioned execution entity can use the target tool to generate a workflow.

[0050] As an example, the execution order of the target tools is determined based on the workflow generation intent; the target tools are called sequentially according to the execution order to obtain the tool processing results, and the tool processing results are applied to the processing of subsequent target tools to finally generate the workflow.

[0051] Taking the workflow request "Get the top five most searched information from Application 1 and Application 2" as an example, the corresponding workflow framework is as follows: Figure 5 As shown.

[0052] The workflow generation process requires the rules defined by MCP (Model Context Protocol) to transform the abstract workflow logic into a machine-parseable and executable Workflow DSL (Domain-Specific Language) description, so as to achieve standardized generation and execution of automated processes.

[0053] Workflow MCP first establishes a rule framework for the DSL, ensuring that subsequently generated workflows conform to cross-tool and cross-platform interaction standards. Core constraints include: Data format constraints: All node inputs / outputs in the DSL description must conform to the JSON structure defined by MCP (e.g., "Tool Metadata" must include parameter name.field name / required field marker!). For example, the DSL for the "XX Application Hot Search Query" node must define... city.city! (City name is required); otherwise, it will be considered invalid. Call timing constraints: The execution order of nodes in the DSL must conform to the MCP rule that the previous step successfully triggers the next step. For example, the DSL cannot have the logic of "executing the hot search summary without obtaining application data". Tool compatibility constraints: Tools referenced in the DSL (such as application APIs and cloud phone operations) must match the tool metadata (such as tool ID and permission level) registered in the MCP to avoid calling unauthorized or incompatible tools.

[0054] Within the rules of MCP, the system generates a Workflow DSL through a workflow synthesizer. The core of this process is the transformation from "abstract logic" to "structured syntax," which includes, for example: Node Mapping: The user requests parsed from the large model (e.g., "search for app 1 + app 2 hot searches") are broken down into specific execution nodes. Each node's DSL description strictly corresponds to the tool metadata defined in the MCP. For example, the user request "search for app 1 hot searches" is mapped to the "app 1 API call node," and the DSL must include the tool name: weibo_hotsearch / parameters: city.city! / Output format: {"hot_list":[]}; User requirement "summary results" → mapped to "data summary node", the DSL must include the dependent nodes: weibo_hotsearch, jinritoutiao_hotsearch (following the MCP timing rules).

[0055] Process orchestration: According to the MCP call sequence rules, define the dependencies between nodes in the DSL (e.g., "call application 1 API first → call application 2 API then → finally summarize"), and describe complex logic through the control flow syntax (e.g., branch / loop) supported by MCP (e.g., "if application 1 fails to retrieve data, retry 3 times, and skip if it still fails").

[0056] In some optional implementations of this embodiment, the workflow is generated according to a preset workflow generation process, which includes multiple preset process stages. These multiple process stages can be flexibly set according to implementation requirements and are not limited here.

[0057] In this implementation, the aforementioned execution entity can perform step 202 as follows: For multiple process stages in the workflow generation process, the target tools required for generating the workflow in each process stage are determined from the tool library based on the workflow generation intent using a large artificial intelligence model.

[0058] The tool library is a collection of specialized tools that support the entire workflow construction process. Its core is to integrate all the tools required for each stage of the core workflow, and all tools are managed in a unified manner in accordance with the Workflow MCP protocol (including tool metadata specifications, parameter interaction specifications, and compliance verification rules).

[0059] As an example, the workflow generation intent is broken down into multiple process stages, each corresponding to a stage sub-intent. For each process stage in the workflow generation process, the target tools required for generating the workflow in that process stage are determined from the tool library using the large AI model based on the stage sub-intent corresponding to that process stage.

[0060] In this implementation, the aforementioned execution entity can perform step 203 as follows: generate a workflow by using the target tools required by each of the multiple process stages, according to the workflow generation process.

[0061] As an example, the target tools corresponding to the process stages are executed sequentially according to the workflow generation process to obtain the tool processing results. The next process stage continues to process the data based on the tool processing results, and finally outputs the workflow through the last process stage.

[0062] In this implementation, the workflow is generated according to a preset workflow generation process. The large model determines the workflow construction tool according to the workflow generation process to generate the workflow, which improves the standardization of the workflow generation process and the accuracy and feasibility of the generated workflow.

[0063] In some optional implementations of this embodiment, the workflow generation process includes a node determination stage, a node parameter configuration stage, and a workflow generation stage.

[0064] In this implementation, the aforementioned execution entity can perform the process of determining the target tool in the following manner: First, using a large-scale artificial intelligence model, based on the workflow generation intent, a node determination tool is selected from the workflow building tools in the tool library corresponding to the node determination stage to determine the target node in the workflow.

[0065] The workflow building tools in the tool library corresponding to the node determination phase include, but are not limited to: `search_nodes({query: 'keyword'})`: A node retrieval tool centered on "functional matching". It generates keywords in the intent (such as "send email" or "query trending searches") through a workflow, matches them with metadata such as functional descriptions and task tags of nodes in the tool library, and returns a list of all function-related nodes. For example, entering "data summary" can retrieve "Excel merge node" or "JSON integration node", helping users quickly locate nodes that meet their specific needs. This is suitable for scenarios where the functional goal is clear but the node name is unknown.

[0066] `list_nodes({category:'trigger'})`: A node filtering tool based on "category attribute". By specifying a node category (such as trigger, action, etc.), it returns all nodes under that category. For example, specifying `category:'trigger'` can list "time-triggered nodes", "message notification triggered nodes", etc. It is suitable for scenarios where the node category is known (such as needing "trigger-type nodes" to start a workflow) but specific options need to be browsed, helping users efficiently filter nodes by process role (trigger / execution).

[0067] `list_ai_tools()`: A node aggregation tool characterized by "AI (Artificial Intelligence) capabilities". It specifically extracts nodes with AI functionality (such as natural language processing, image recognition, and intelligent recommendation) from a tool library and returns a list of them. It's important to note that any node can be based on an AI tool; this tool does not restrict the basic category of nodes (trigger-based / action-based are both acceptable), but only uses "whether it integrates AI capabilities" as the filtering criterion. This helps users quickly locate nodes with intelligent processing capabilities and is suitable for workflow construction scenarios that require embedding AI logic (such as automatically generating text or intelligently analyzing data).

[0068] Then, using the large AI model, based on the workflow generation intent, the node parameter configuration tool is determined from the workflow building tools in the tool library corresponding to the node parameter configuration stage, to configure the parameters for the target node.

[0069] The workflow building tools in the tool library corresponding to the node parameter configuration phase include, but are not limited to: `get_node_essentials(nodeType)`: A starting tool for the node parameter configuration phase, used to extract the core basic attributes of a specified node type (such as "email sending node" or "hot search query node"). It covers the minimum necessary information for node configuration, including required parameters (such as...). The attributes include recipient (the recipient's name), output format (e.g., {send_status:boolean}), and basic function description. These attributes are prerequisites for node configuration; without them, subsequent parameter input will lack a basis.

[0070] `search_node_properties(nodeType, 'auth')`: A precise tool for retrieving specific node attributes, used to query attribute details related to specific keywords in nodes of a specified type. For example, passing `nodeType: "enterprise_email"` and `'auth'` will retrieve the authentication configuration attributes of that node (such as `smtp_username`, `password_encrypt_rule` encryption rules). Its core value is retrieving details on demand, only called when the node configuration involves specific scenarios (such as authentication, permissions, advanced parameters), avoiding information redundancy in the basic configuration stage.

[0071] `get_node_for_task('send_email')`: A tool for quickly obtaining pre-configured node templates. For a specific task (e.g., "send_email to send emails" or "hot_search to query hot searches"), it returns the corresponding pre-configured template. The template includes default values ​​for commonly used parameters (e.g., mail server address, default subject format), parameter constraints (e.g., recipient format must be an email address), etc., which can be directly reused or fine-tuned, significantly reducing manual configuration costs. It is suitable for node configurations with mature task scenarios.

[0072] `get_node_documentation(nodeType)`: A reference tool for detailed node descriptions, used to obtain human-readable documentation for nodes of a specified type. The content includes an explanation of the parameter meanings (e.g., ...). The timeout parameter includes a timeout range of 1-30 seconds, usage notes (such as "the call frequency should not exceed 10 times per minute"), and error code explanations. It is positioned as an "aid-understanding tool," only invoked when the user has questions about node attributes (such as parameter constraints and execution logic), providing supplementary support for the accuracy of the configuration.

[0073] Finally, using a large-scale artificial intelligence model, based on the workflow generation intent, the workflow generation tool that connects to the target node is determined from the workflow building tools in the tool library corresponding to the workflow generation stage.

[0074] The tool library contains workflow building tools corresponding to the workflow generation stage, such as tools for determining node order, tools for determining node connection relationships, and error handling and exception capture tools.

[0075] The node order determination tool automatically calculates the node execution order based on node metadata (such as input and output formats) obtained during the configuration phase. For example, if the data aggregation node depends on the output of the database query node, the tool will insert depends_on: ["db_query_node"] into the DSL.

[0076] Tools for determining node connections include using a built-in graphical editor in the tool library to connect target nodes and automatically generate structured JSON or YAML (a markup language) code. For example, after a user drags and drops an "email sending node" onto a "data aggregation node" on the display interface, the engine will verify the connection logic based on the node type (trigger / action) and generate the corresponding connections field.

[0077] In this implementation, the AI ​​big data model determines the target tools required for the node determination stage, node parameter configuration stage, and workflow generation stage based on the workflow generation intent. The target tools at each stage work together to generate the workflow, which can specifically match the tools required for each process stage, avoiding tool redundancy or lack. The collaborative work of tools at multiple stages reduces gaps in stage connections and improves the efficiency and reliability of workflow generation.

[0078] In some optional implementations of this embodiment, the execution entity can perform the workflow generation process in the following manner: The first step is to use a node identification tool to identify the target nodes that match the workflow generation intent from the node library.

[0079] For example, first, an AI big data model is used to analyze the workflow generation intent and extract core requirement elements (such as the task type of "dual-platform hot search query" and the output requirement of "real-time data"); then, the tag matching of the node library is called to semantically compare the requirement elements with the node's functional tags (such as "hot search acquisition") and scenario tags (such as "real-time data collection") to filter out candidate nodes; finally, a node availability verification tool is used to exclude nodes that are under maintenance or have insufficient permissions to determine the final target node.

[0080] The node library that the node determination phase depends on is maintained uniformly by Workflow MCP. MCP pre-enters all available tools (such as hot search tools and email tools) into the node library according to the tool metadata specification, including information such as node ID, function description, applicable scenarios, and execution environment requirements.

[0081] During the node identification phase, matching nodes are retrieved from the MCP node library using tools such as search_nodes({query:'keyword'}). For example, if a user wants to "search for hot searches", the system will retrieve "hot search node for application 1, hot search node for application 2". These nodes are the basic materials for building the Workflow DSL. If the nodes are not entered according to the MCP specifications, they cannot be identified and configured later, let alone written into the DSL.

[0082] The second step involves using a node parameter configuration tool to configure target parameters for the target node that align with the workflow generation intent.

[0083] During the node parameter configuration phase, MCP provides parameter specifications to ensure the validity of node configurations in the Workflow DSL. The parameter configuration during this phase is based on the parameter and interaction specifications defined by the Workflow MCP, for example: MCP defines "required parameters, optional parameters, and data type constraints" for each node type (such as hot search nodes and email nodes). city! (string) count(number)); During the configuration phase, these specifications are obtained from MCP using tools such as get_node_essentials(nodeType), and then the node parameters are completed (if the user has not specified them). (count, filled with the MCP default value of 5), ensuring that the configured parameters meet the MCP requirements. These compliant parameter configurations will be directly written to the node parameter field of the DSL (e.g., "params":{"city":"Beijing","count":5}).

[0084] The third step involves using a workflow generation tool to connect the target nodes configured with the target parameters and generate a workflow.

[0085] As an example, the workflow orchestration engine is invoked to first determine the execution order of the target nodes based on the intent (e.g., "Application 1 Hot Search Node → Application 2 Hot Search Node → Data Summary Node"); then, the data flow connection logic between nodes is automatically generated (e.g., the output of the previous node is used as the input of the next node), and basic error handling is added (e.g., node timeout retry); finally, the orchestrated nodes and logic are converted into standardized workflow files through the DSL generation tool to complete the generation.

[0086] The workflow generation phase aims to generate a Workflow DSL, whose structure fully conforms to the DSL structure specification defined by WorkflowMCP. MCP specifies a unified DSL format (e.g., JSON structure), including fixed fields such as "workflow_id," "nodes," "connections," and "output_schema." The workflow generation phase assembles compliant node materials, valid parameter configurations, and validated execution logic from previous phases into a complete DSL file according to the MCP DSL structure specification (e.g., writing the connection relationship "Application 1 node → Application 2 node → Summary node" in the MCP-defined format "connections":{"from":"node1","to":"node2"}). If the generated DSL deviates from the MCP specification, it will not be parsed by the execution layer.

[0087] In this implementation, the core objectives of each process stage are focused step by step. The node determination tool can accurately match the workflow intent and avoid selecting the wrong node; the node parameter configuration tool can ensure parameter compliance and reduce invalid configuration; the workflow generation tool realizes automated node orchestration. The three steps are seamlessly connected, which not only improves efficiency but also reduces the error rate and ensures the reliability of the workflow construction process.

[0088] In some optional implementations of this embodiment, the execution entity can configure the parameters of the target node in the following manner: First, a node parameter configuration template that matches the workflow generation intent is determined using a node parameter configuration tool. Then, target parameters are configured for the target nodes based on the node parameter configuration template.

[0089] Depending on the workflow scenario, different node parameter configuration templates can be configured for the same node. Workflow scenarios include, for example, social media content generation, cross-platform / application data integration, automated testing processes, and public opinion monitoring and early warning.

[0090] As an example, the workflow generates intents through a large AI model, extracting scenario-specific parameter requirements (such as "city" and "data volume" in "querying Beijing trending topics"). A node parameter configuration template tool (such as get_node_for_task) is invoked to retrieve a matching template from the pre-configured template library based on the target node type (such as the default parameter template for "trending topic query node"). After selecting templates that match the intent elements, personalized parameters are added based on the node's basic attributes extracted by get_node_essentials (such as replacing the default value of "city" in the template with "Beijing"). The format and constraints are validated using a parameter compliance tool, and the target parameter configuration is completed after user confirmation.

[0091] In this implementation, the parameter configuration of the target node is based on the parameter configuration template, which simplifies the configuration process and improves configuration efficiency while ensuring that the parameter configuration is accurate and complete.

[0092] In some optional implementations of this embodiment, the workflow generation process further includes a node verification stage, which is used to verify the accuracy and completeness of the target parameters configured for the target node.

[0093] In this implementation, the aforementioned execution entity determines the target tools required for the node verification stage in the following way: using an artificial intelligence big data model, it identifies the node verification tools used to verify the target parameters from the workflow construction tools corresponding to the node verification stage in the tool library.

[0094] Workflow building tools for the node verification phase include, but are not limited to: `validate_node_minimal(nodeType, config)`: A quick basic validation tool for node configurations. Its core function is to check whether the required fields in the configuration (config) of a specified node type (`nodeType`) are complete. For example, for an "email sending node", it will validate... recipient The system does not check whether required parameters such as subject exist, and does not involve format or environment adaptation checks. It only quickly intercepts obvious errors such as "missing parameters" in the early stage of configuration, prioritizing efficiency.

[0095] `validate_node_operation(nodeType, config, profile)`: A deep, full validation tool for node configurations. Building upon basic validation, it combines execution environment configurations (such as the execution server and permission information) to verify the feasibility of the configured operations. For example, it not only checks the existence of required parameters for email nodes but also validates... Is the smtp_server (server address) format correct? Does the execution environment have permission to access the server? Ensure that the port is within the allowed range, etc., so that the node configuration can be executed normally in the actual environment and cover all operational risks.

[0096] In this implementation, the aforementioned execution entity can generate a workflow in the following way: First, a node verification tool is used to verify the target node configured with the target parameters. Then, in response to successful verification, a workflow generation tool is used to connect the target node configured with the target parameters and generate a workflow.

[0097] In response to the failure to pass verification, the parameter configuration of the target node is determined to be abnormal. The abnormal parameter configuration is corrected through the rule engine. Then, a workflow generation tool is used to connect to the target node with the corrected parameter configuration and generate a workflow.

[0098] In this implementation, a node verification stage is added between the node parameter configuration stage and the workflow generation stage to verify the validity of the node parameters, thereby further improving the effectiveness and reliability of the workflow generation process.

[0099] In some optional implementations of this embodiment, the execution entity can perform the node verification process in the following manner: First, determine the node specification data of the applied workflow system; then, use a node verification tool to verify the target node with configured target parameters according to the node specification data.

[0100] Different workflow systems include n8n, dify, comfyui, appbuilder, etc.

[0101] First, the system identifies the target workflow system (such as n8n) specified by the user and retrieves the node specification data (including parameter naming format, required fields, data type constraints, etc.) of that system from the preset multi-system specification library. Then, it calls the node verification tool to compare the target node with the configured target parameters with the specification data and check whether the parameters conform to the system-specific rules (such as underscore naming in n8n and camelCase format in dify). If there are any discrepancies, the rule engine corrects them until the verification passes.

[0102] This implementation method can accurately adapt to the specific specifications of different workflow systems, avoiding configuration errors caused by differences in parameter formats, required fields, etc.; it ensures that the configured nodes can be executed normally in the target system, reduces deployment failures, and ensures the accuracy of workflow implementation across systems.

[0103] In some optional implementations of this embodiment, the workflow generation process further includes a workflow verification stage, which is used to verify the completeness and accuracy of the workflow.

[0104] In this implementation, the aforementioned execution entity can determine the target tool for the workflow verification phase in the following way: using a large artificial intelligence model, the workflow verification tool is determined from the workflow building tools in the tool library corresponding to the workflow verification phase.

[0105] Workflow building tools in the workflow verification phase include, but are not limited to, tools for verifying workflow connection relationships and tools for verifying workflow data flow.

[0106] In this implementation, the above execution can also perform the following operation: verify the workflow using a workflow verification tool.

[0107] During the workflow verification phase, MCP provides end-to-end compliance rules to ensure global adaptation of the Workflow DSL. The verification criteria during this phase are the cross-node collaboration rules and cross-system adaptation rules defined by Workflow MCP. Workflow MCP defines data transfer specifications between multiple nodes (e.g., the output hot_list of node 1 must match the input data_source of node 2) and adaptation rules across Workflow systems (e.g., the n8n DSL must include the "type":"n8n-node" field). During the workflow validation phase, workflow validation tools such as validate_workflow are called to check the global compliance of the DSL according to the MCP specifications (e.g., whether node connections conform to data transfer rules and whether they are compatible with the target deployment system), ensuring that the DSL not only executes but also executes correctly on the target system.

[0108] If the workflow passes validation, it can be deployed or executed. If validation fails, the workflow can be modified through the rules engine to eventually obtain a validated workflow.

[0109] In this implementation, the workflow is validated as a whole during the workflow validation phase, which helps to further improve the effectiveness and reliability of the workflow.

[0110] In some optional implementations of this embodiment, the workflow verification tool includes a connection relationship verification tool, an expression verification tool, and a completeness verification tool. The aforementioned execution entity can perform the workflow verification process in the following ways: 1. Use a connection verification tool to verify the node connection relationships in the workflow.

[0111] The connection validation tool validate_workflow_connections(workflow) focuses on the structure and connection logic of the workflow, checking whether the connection between nodes is closed (e.g., no isolated nodes), whether the interface between AI tools and nodes is reachable, and whether the connection sequence conforms to the business logic (e.g., trigger nodes need to be in advance), to avoid process interruption due to broken or disordered connections.

[0112] 2. Use an expression validation tool to validate the workflow expressions in the workflow.

[0113] The expression validation tool `validate_workflow_expressions(workflow)` is specifically designed to validate dynamic expressions in workflows, such as... Check whether variable references such as node["A"].json are valid, and whether the syntax of conditional expressions (such as ifcount>10) is correct. Ensure that the expressions can be correctly parsed and data is passed, and avoid node execution failure due to invalid parameters.

[0114] 3. Use a complete verification tool to verify node connection relationships and workflow expressions.

[0115] The complete validation tool validate_workflow(workflow) integrates the validation results of the previous two tools and adds full-process compliance checks (such as permission adaptation and resource quotas) to fully validate the workflow, confirming that it has no problems in structure, expression, and overall logic, and providing the ultimate guarantee for final deployment.

[0116] In this implementation, the workflow compliance can be verified from multiple dimensions using connection relationship verification tools, expression verification tools, and full verification tools, further improving workflow reliability.

[0117] In some optional implementations of this embodiment, the execution entity can perform the node connection verification process as follows: First, generate a directed acyclic graph representing the workflow; then, use a connection verification tool to verify the node connection relationships of the directed acyclic graph.

[0118] As an example, firstly, based on the execution order and connection logic of the workflow nodes, a directed acyclic graph with nodes as vertices and connection directions as edges is generated to clearly present the upstream and downstream dependencies of each node; then, a connection relationship verification tool is called to check whether there are cycles (violating acyclicity) or isolated nodes in the graph, and at the same time, it verifies whether the connection between the triggering node and subsequent nodes conforms to the process rules and whether the interface connection of the AI ​​tool node is valid, to ensure that the connection relationship is compliant.

[0119] When generating a directed acyclic graph, implicit cycles may be introduced due to incorrect node connection configurations (such as mistakenly setting reverse connections), so verification is necessary. Starting from the trigger node, a connection verification tool is invoked to traverse all nodes in the graph and record the access path of each node. When the tool detects that a node's downstream connection points to its upstream visited node (such as node B's downstream connection returning to node A, and A being in B's access path), it determines that a cycle exists.

[0120] In this implementation, the effectiveness and accuracy of workflow verification results are further improved by using a directed acyclic graph.

[0121] See also Figure 6 , Figure 6This is a schematic diagram 600 illustrating an application scenario of the workflow generation method based on a large model according to this embodiment. The target user 601 inputs a workflow generation request, "Get the top five trending search results for Application 1 and Application 2," through the request input interface of the terminal device 602. The server 603 parses the workflow generation request and determines the workflow generation intent; using an artificial intelligence large model, it identifies target tools from a tool library to generate a workflow that meets the workflow generation intent. The tool library includes multiple workflow building tools; using the target tool, the workflow is generated, and the flowchart representing the workflow is shown in 6031.

[0122] This embodiment provides a workflow generation method based on a large model. By parsing the workflow generation request, the workflow generation intent is determined. Using an artificial intelligence large model, a target tool for generating a workflow that meets the workflow generation intent is identified from a tool library, which includes multiple workflow building tools. The target tool is then used to generate the workflow. Thus, based on the artificial intelligence large model, the workflow generation request is mapped to the target tool for building the workflow, thereby generating a workflow that meets the workflow generation intent. This significantly reduces the development threshold for automated processes and achieves an automated experience where "what is (the workflow generation request) is what you get (the workflow)".

[0123] In some optional implementations of this embodiment, the execution entity may also generate the workflow in the following ways: First, the system uses a large AI model to identify workflow templates in the workflow template library that meet the intent of workflow generation. Then, the workflow is generated based on the workflow templates.

[0124] Workflow templates are predefined, standardized workflow frameworks that conform to the Workflow MCP specification. They contain fixed node combination logic, node connection relationships, default parameter configurations, and execution rules. They can be quickly reused and adjusted according to specific workflow generation intentions and are the basic units that support the efficient construction of workflows.

[0125] First, the AI ​​big data model analyzes the workflow generation intent and extracts core requirement features (such as "cross-platform data aggregation"). Then, it calls the template library retrieval tool to match the features with the template's scene tags and node structure to determine the target template that meets the intent. Next, it uses the template instantiation tool to replace the configurable placeholder parameters in the template (such as "data source address") with the specific values ​​corresponding to the intent, generating the initial workflow. Finally, the workflow is completed after verification by the validation tool.

[0126] It should be noted that, in the method of generating workflows based on workflow templates, data processing for the node parameter configuration stage, node verification stage, workflow generation stage, and workflow verification stage can also be performed in accordance with the above embodiments.

[0127] During the node parameter configuration phase, the workflow template contains default parameters, which need to be adjusted according to the specific intent (such as changing the "default data source" to the target data source); during the node verification phase, verify whether the adjusted parameters conform to the node specifications (such as format and permissions); during the workflow generation phase, assemble the template structure and configuration parameters into an executable workflow; during the workflow verification phase, check the overall connections, expressions, and compliance to ensure that the template can be executed normally after instantiation.

[0128] In this implementation, workflows can be generated based on reusable templates, which can reduce the cost of repeatedly building workflows, and parameter adjustments can focus on intent details to improve efficiency; the templates come with specifications to ensure compliance, which can reduce the verification error rate at each stage.

[0129] In some optional implementations of this embodiment, the execution entity may also perform the following operations: first, generate a workflow template based on the workflow; then, add the workflow template to the workflow template library.

[0130] As an example, firstly, a workflow parsing tool is invoked to disassemble the generated compliant workflow, extracting the common node combination logic, connection relationships, and execution rules. Simultaneously, personalized parameters (such as specific data source addresses and account information) are replaced with standardized placeholders (such as "target data source authentication information"), forming a template prototype. Then, according to the WorkflowMCP specification, a node verification tool is used to verify the compliance of the template prototype's node structure, and a connection verification tool is used to confirm the universal compatibility of the connection logic between nodes. Next, meta-information such as scenario tags (such as "e-commerce data aggregation") and applicable system identifiers (such as "n8n / dify") are added to the template. Finally, through a template library access tool, the verified template is stored in the workflow template library, and the retrieval index within the library is updated synchronously, completing the addition process.

[0131] In this implementation, mature and compliant workflows are transformed into reusable templates, avoiding redundant development, reducing the workload of workflow generation, and improving the overall efficiency and standardization of workflow construction.

[0132] In some optional implementations of this embodiment, the execution entity may also perform the following operations: in response to a target node in the workflow involving a backend operation, the backend operation is completed by calling the corresponding backend service of the target node through the interface adapter; in response to a target node in the workflow involving a frontend operation, the frontend operation is completed by calling the terminal device.

[0133] Terminal devices include, but are not limited to, IoT (Internet of Things) devices, cloud terminals, local terminals, and other terminal devices.

[0134] Continue to refer to Figure 3 The data communication layer uses a generic API Client to encapsulate the REST API details for communication with the general automation platform. The system abstracts various API call operations, freeing upper-layer logic from concern itself with the specific communication implementation. For tasks such as workflow creation, execution, updating, and status management, the client layer provides a unified interface to simplify system integration.

[0135] When executing a workflow, firstly, the metadata of the target node is parsed to identify its operation type (backend / frontend). If it is a backend operation, the interface adapter reads the service address and authentication information configured on the node, converts the parameter format to adapt to the backend interface specification, initiates the call, and returns the execution result. If it is a frontend operation, the terminal device receives the node's interaction instructions (such as page rendering and form submission), calls the corresponding frontend component library to generate the interface, and after completing the operation, synchronizes the result to the workflow to ensure seamless connection between frontend and backend operations.

[0136] Interface adapters are underlying technical components that resolve communication compatibility issues and belong to the infrastructure of the data communication layer. API HUB MCP is an AI integration platform based on the MCP protocol, belonging to the upper-layer business capabilities, and relies on interface adapters to interact with external services. Interface adapters are the foundation for the implementation of API HUB MCP, while API HUB MCP, through the MCP protocol, empowers interface adapters with AI-driven dynamic invocation capabilities. Together, they construct a complete architecture of "data communication + intelligent collaboration."

[0137] This implementation method can specifically match the operational needs of both the front-end and back-end. The interface adapter can adapt to the back-end service specifications, avoiding calling format conflicts and ensuring smooth execution of back-end operations. The terminal device is tailored to the actual interaction scenario of the front-end, ensuring accurate implementation of front-end operations. The clear division of labor between the two allows for seamless connection between front-end and back-end workflow operations, improving overall execution efficiency and accuracy.

[0138] In some optional implementations of this embodiment, the execution entity may also perform the following operation: update the node library including candidate nodes for building the workflow according to the received node library update operation.

[0139] Receive node library update operations, parse the operation type (add / delete / modify candidate node), call the node specification verification tool to check whether the metadata and parameter structure of the node to be updated conform to the Workflow MCP specification. After confirming that there are no compliance issues, update the candidate node list in the node library and update the node retrieval index synchronously.

[0140] Update the tool library based on the received tool library update operation.

[0141] Receive tool library update requests, parse the request content (adding a tool / iterating the tool version), verify the compatibility of the tool to be updated with the existing node library and workflow system using the tool compatibility verification tool, ensure that the tool functions can be called normally, update the tool library after the verification is passed, and simultaneously update the mapping relationship of the tool call interface to complete the overall update.

[0142] In this implementation, the tool library and node library can be updated in a timely manner based on the update operation, providing accurate data for the workflow generation process and helping to improve the efficiency and reliability of workflow generation.

[0143] In some optional implementations of this embodiment, the execution entity may also perform the following operations: First, display a framework diagram representing the workflow. For example, the framework diagram representing the workflow can be displayed via a display screen device.

[0144] Then, adjust the workflow based on the adjustment information or actions for the framework diagram.

[0145] In the Workflow Editor, adjustment information for the flowchart, such as text or voice messages, can be analyzed by the AI ​​model to adjust the workflow. Adjustment actions for the flowchart include dragging and dropping, which allows for workflow adjustments.

[0146] In this implementation, users can adjust the workflow based on adjustment information or actions, which improves the convenience of workflow adjustment and helps to further enhance the adaptability between the workflow and the user.

[0147] For further explanation of this disclosure, please refer to [link / reference]. Figure 7 This shows a data flow diagram of the workflow generation process.

[0148] The system consists of components such as an input parsing module, a language model invocation module, a workflow synthesizer, and a DAG (Directed Acyclic Graph) builder. Users describe workflow generation requests in natural language, which are then processed by the Prompt project and sent to the large language model in the backend.

[0149] The large model parses user intent, retrieves or generates suitable workflow solutions, and then the workflow synthesizer converts them into specific node configurations and dependency graphs.

[0150] The DAG builder further organizes and verifies valid directed acyclic graphs, ultimately outputting an executable workflow representation (JSON configuration or visual flowchart). During this process, the system also maintains a node / template knowledge base. Larger models can retrieve existing node function descriptions or example processes from this knowledge base to improve the accuracy of the generated results.

[0151] It can execute workflows to call external APIs / Hubs, reaching diverse terminals such as local terminals, IoT terminals, cloud phones, and cloud computers.

[0152] In some optional implementations of this embodiment, the execution entity may deploy the workflow before execution: the deployed workflow can be processed using the following tools: workflow_create_workflow(workflow): The core tool for workflow deployment, responsible for instantiating pre-validated workflows (including node configurations and connection relationships) into the execution environment, allocating runtime resources (such as compute nodes and storage quotas), and generating workflow instances that can be scheduled by the system. It is a necessary step for workflows to transition from "configuration state" to "running state".

[0153] workflow_validate_workflow({id:'workflow-id'}): A post-deployment validation tool that locates the deployed instance by workflow ID, checks its status in the actual execution environment (such as whether resources are available and whether the connection with the backend service is effective), verifies the consistency between the deployment result and the expected configuration, and avoids deployment failure due to environmental differences.

[0154] workflow_update_partial_workflow(): An incremental workflow update tool that compares the current workflow with the updated content (such as changes to a node parameter or adjustments to a local connection) and updates only the changed parts. This eliminates the need to redeploy the entire workflow, reducing update time and system fluctuation risks, and is suitable for high-frequency iteration scenarios.

[0155] workflow_trigger_webhook_workflow(): A testing tool specifically designed for webhook-type workflows. It simulates external trigger signals (such as HTTP requests and event notifications) to trigger workflow execution and tracks the responses of all nodes in the process. It verifies the effectiveness of the webhook triggering mechanism (such as signal reception, parameter passing, and subsequent node linkage) and ensures that external events can correctly drive the workflow to run.

[0156] Continue to refer to Figure 8This illustrates an illustrative flow 800 of yet another embodiment of the workflow generation method based on a large model according to the present disclosure. Flow 800 includes the following steps: Step 801: parse the workflow generation request and determine the workflow generation intent.

[0157] Step 802: For multiple process stages in the workflow generation process, the target tools required for generating the workflow in each process stage are determined from the tool library based on the workflow generation intent using a large artificial intelligence model.

[0158] Step 803: Generate the workflow by using the target tools required for each of the multiple process stages, according to the workflow generation process.

[0159] Step 804: In response to the target node in the workflow involving backend operations, the backend service corresponding to the target node is called through the interface adapter to complete the backend operations.

[0160] Step 805: In response to the target node in the workflow involving front-end operations, call the terminal device to complete the front-end operations.

[0161] The workflow generation method based on the large model in this embodiment, process 800, compared with process 200 above, specifically describes the workflow generation process and execution process. Based on the artificial intelligence large model, the workflow generation request is mapped to the target tool for building the workflow, so as to generate a workflow that meets the workflow generation intention, which greatly reduces the threshold of automated process development and realizes the automated experience of "the (workflow generation request) is what you get (workflow)".

[0162] Continue to refer to Figure 9 As an implementation of the methods shown in the above figures, this disclosure provides an embodiment of a workflow generation device based on a large model. This system embodiment is similar to... Figure 2 Corresponding to the method embodiments shown, the system can be specifically applied to various electronic devices.

[0163] like Figure 9 As shown, the workflow generation device 900 based on a large model includes: an intent determination unit 901, configured to parse a workflow generation request and determine the workflow generation intent; a tool determination unit 902, configured to determine, through an artificial intelligence large model, a target tool from a tool library for generating a workflow that satisfies the workflow generation intent, wherein the tool library includes multiple workflow building tools; and a workflow generation unit 903, configured to use the target tool to generate the workflow.

[0164] In some optional implementations of this embodiment, the workflow is generated according to a preset workflow generation process, and the tool determination unit 902 is further configured to: for multiple process stages in the workflow generation process, determine the target tools required for generating the workflow in the process stage from the tool library based on the workflow generation intention using an artificial intelligence big data model; and the workflow generation unit 903 is further configured to: generate the workflow by using the target tools required for each of the multiple process stages according to the workflow generation process.

[0165] In some optional implementations of this embodiment, the workflow generation process includes a node determination stage, a node parameter configuration stage, and a workflow generation stage. The tool determination unit 902 is further configured to: use an AI big data model to determine a node determination tool from the workflow building tools in the tool library corresponding to the node determination stage, based on the workflow generation intent; use the AI ​​big data model to determine a node parameter configuration tool from the workflow building tools in the tool library corresponding to the node parameter configuration stage, based on the workflow generation intent; and use the AI ​​big data model to determine a workflow generation tool connecting the target node from the workflow building tools in the tool library corresponding to the workflow generation stage, based on the workflow generation intent.

[0166] In some optional implementations of this embodiment, the workflow generation unit 903 is further configured to: use a node determination tool to determine target nodes that are compatible with the workflow generation intent from a node library; use a node parameter configuration tool to configure target parameters that are compatible with the workflow generation intent for the target nodes; and use a workflow generation tool to connect the target nodes with the configured target parameters to generate a workflow.

[0167] In some optional implementations of this embodiment, the workflow generation unit 903 is further configured to: use a node parameter configuration tool to determine a node parameter configuration template that matches the workflow generation intent; and configure target parameters for the target node according to the node parameter configuration template.

[0168] In some optional implementations of this embodiment, the workflow generation process further includes a node verification stage, and the tool determination unit 902 is further configured to: determine a node verification tool for verifying target parameters from the workflow building tools in the tool library corresponding to the node verification stage using an artificial intelligence big data model; and the workflow generation unit 903 is further configured to: use the node verification tool to verify the target node configuring the target parameters; and in response to successful verification, use the workflow generation tool to connect the target node configuring the target parameters to generate a workflow.

[0169] In some optional implementations of this embodiment, the workflow generation unit 903 is further configured to: determine the node specification data of the applied workflow system; and use a node verification tool to verify the target node with configured target parameters based on the node specification data.

[0170] In some optional implementations of this embodiment, the workflow generation process further includes a workflow verification stage, and the tool determination unit 902 is further configured to: determine a workflow verification tool for verifying the workflow from the workflow building tools in the tool library corresponding to the workflow verification stage through an artificial intelligence big data model; and the workflow generation unit 903 is further configured to: verify the workflow using the workflow verification tool.

[0171] In some optional implementations of this embodiment, the workflow generation unit 903 is further configured to: use a connection relationship verification tool to verify the node connection relationship of the workflow; use an expression verification tool to verify the workflow expression in the workflow; and use a complete verification tool to verify the node connection relationship and the workflow expression.

[0172] In some optional implementations of this embodiment, the workflow generation unit 903 is further configured to: generate a directed acyclic graph representing the workflow; and use a connection verification tool to verify the node connection relationships of the directed acyclic graph.

[0173] In some optional implementations of this embodiment, the workflow generation unit 903 is further configured to: in response to determining, through a large artificial intelligence model, that the workflow template library includes workflow templates that satisfy the workflow generation intent; generate a workflow based on the workflow templates.

[0174] In some optional implementations of this embodiment, the above-mentioned device further includes a workflow execution unit (not shown in the figure), configured to: in response to a target node in the workflow involving a backend operation, call the backend service corresponding to the target node through an interface adapter to complete the backend operation; and in response to a target node in the workflow involving a frontend operation, call a terminal device to complete the frontend operation.

[0175] In some optional implementations of this embodiment, the above apparatus further includes a template library extension unit (not shown in the figure), configured to: generate a workflow template based on the workflow; and add the workflow template to the workflow template library.

[0176] In some optional implementations of this embodiment, the apparatus further includes an update unit (not shown in the figure), configured to: update the node library, including candidate nodes for building workflows, according to a received node library update operation; and update the tool library according to a received tool library update operation.

[0177] In some optional implementations of this embodiment, the above-described apparatus further includes a workflow adjustment unit (not shown in the figure), configured to: display a framework diagram representing the workflow; and adjust the workflow according to adjustment information or adjustment actions for the framework diagram.

[0178] This embodiment provides a workflow generation device based on a large model. An intent determination unit parses the workflow generation request and determines the workflow generation intent. A tool determination unit uses an artificial intelligence large model to identify target tools from a tool library for generating workflows that meet the workflow generation intent. The tool library includes multiple workflow building tools. The workflow generation unit uses the target tools to generate the workflow. By combining the artificial intelligence large model and web retrieval, the professionalism and accuracy of the answer optimization data are improved, which helps improve interviewers' interview skills and meets their mock interview needs. Thus, based on the artificial intelligence large model, the workflow generation request is mapped to the target tool for building the workflow to generate a workflow that meets the workflow generation intent. This significantly reduces the development threshold for automated processes and achieves an automated experience where "the (workflow generation request) is exactly what you get (workflow)".

[0179] According to embodiments of this disclosure, this disclosure also provides an electronic device, the electronic device comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to implement the workflow generation method based on a large model described in any of the above embodiments.

[0180] According to embodiments of this disclosure, this disclosure also provides a readable storage medium storing computer instructions that enable a computer to implement the workflow generation method based on a large model as described in any of the above embodiments when executed.

[0181] This disclosure provides a computer program product that, when executed by a processor, can implement the workflow generation method based on a large model as described in any of the above embodiments.

[0182] Figure 10A schematic block diagram of an example electronic device 1000 that can be used to implement embodiments of the present disclosure is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the present disclosure described and / or claimed herein.

[0183] like Figure 10 As shown, device 1000 includes a computing unit 1001, which can perform various appropriate actions and processes according to a computer program stored in read-only memory (ROM) 1002 or a computer program loaded into random access memory (RAM) 1003 from storage unit 1008. The RAM 1003 may also store various programs and data required for the operation of device 1000. The computing unit 1001, ROM 1002, and RAM 1003 are interconnected via bus 1004. Input / output (I / O) interface 1005 is also connected to bus 1004.

[0184] Multiple components in device 1000 are connected to I / O interface 1005, including: input unit 1006, such as keyboard, mouse, etc.; output unit 1007, such as various types of monitors, speakers, etc.; storage unit 1008, such as disk, optical disk, etc.; and communication unit 1009, such as network card, modem, wireless transceiver, etc. Communication unit 1009 allows device 1000 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0185] The computing unit 1001 can be various general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 1001 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 1001 performs the various methods and processes described above, such as a large model-based workflow generation method. For example, in some embodiments, the large model-based workflow generation method can be implemented as a computer software program tangibly contained in a machine-readable medium, such as storage unit 1008. In some embodiments, part or all of the computer program can be loaded and / or installed on device 1000 via ROM 1002 and / or communication unit 1009. When the computer program is loaded into RAM 1003 and executed by the computing unit 1001, one or more steps of the large model-based workflow generation method described above can be performed. Alternatively, in other embodiments, the computing unit 1001 may be configured to execute a workflow generation method based on a large model by any other suitable means (e.g., by means of firmware).

[0186] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0187] The program code used to implement the methods of this disclosure can be written in any combination of one or more programming languages. This program code can be provided to the processor or controller of a general-purpose computer, special-purpose computer, or other programmable large-model-based workflow generation device, such that when executed by the processor or controller, the program code enables the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code can be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0188] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0189] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0190] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as a data server), or computing systems that include middleware components (e.g., an application server), or computing systems that include frontend components (e.g., a user computer with a graphical user interface or web browser through which a user can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., a communication network). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0191] Computer systems can include clients and servers. Clients and servers are generally geographically separated and typically interact via communication networks. The client-server relationship is created by computer programs running on the respective computers and having a client-server relationship with each other. Servers can be cloud servers, also known as cloud computing servers or cloud hosts, which are hosting products within the cloud computing service system to address the management difficulties and weak business scalability inherent in traditional physical hosts and Virtual Private Servers (VPS) services; they can also be servers for distributed systems or servers incorporating blockchain technology.

[0192] According to the technical solution of the embodiments of this disclosure, a workflow generation method and apparatus based on a large model are provided. A first large model generates a retrieval request based on the question-and-answer data from an interview process; a network search is performed based on the retrieval request to obtain reference data; a second large model generates answer optimization data for the question-and-answer data based on the reference data to provide feedback to the interviewee. By combining an artificial intelligence large model and network search, the professionalism and accuracy of the answer optimization data are improved, which helps to improve the interviewee's interview skills and meets the interviewee's mock interview needs.

[0193] It should be understood that the various forms of processes shown above can be used to reorder, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution provided in this disclosure can be achieved, and this is not limited herein.

[0194] The specific embodiments described above do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure should be included within the scope of protection of this disclosure.

Claims

1. A workflow generation method based on a large model, comprising: Parse the workflow generation request to determine the workflow generation intent; Using a large artificial intelligence model, target tools for generating workflows that meet the workflow generation intent are identified from a tool library, wherein the tool library includes multiple workflow building tools; The workflow is generated using the target tool.

2. The method according to claim 1, wherein, The workflow is generated according to a preset workflow generation process, and The process of identifying target tools from a tool library using a large-scale artificial intelligence model to generate workflows that satisfy the workflow generation intent includes: For multiple process stages in the workflow generation process, the AI ​​big data model, based on the workflow generation intent, determines the target tools required for generating the workflow at each process stage from the tool library; and The process of generating the workflow using the target tool includes: The workflow is generated by employing the target tools required for each of the various process stages, according to the workflow generation process described above.

3. The method according to claim 2, wherein, The workflow generation process includes a node determination stage, a node parameter configuration stage, and a workflow generation stage. For multiple process stages in the workflow generation process, the AI ​​big data model, based on the workflow generation intent, determines from the tool library the target tools required to generate the workflow at each process stage, including: Based on the aforementioned large-scale artificial intelligence model and the workflow generation intent, a node determination tool is selected from the workflow building tools in the tool library corresponding to the node determination stage to determine the target node in the workflow. Based on the aforementioned large-scale artificial intelligence model and the workflow generation intent, a node parameter configuration tool is determined from the workflow building tools in the tool library corresponding to the node parameter configuration stage to configure the parameters for the node. Based on the stated artificial intelligence model and the stated workflow generation intent, the workflow generation tool that connects to the target node is determined from the workflow building tools in the tool library corresponding to the workflow generation stage.

4. The method according to claim 3, wherein, The process of generating the workflow according to the workflow generation flow, using the target tools required for each of the multiple process stages, includes: The node determination tool is used to identify target nodes from the node library that are compatible with the workflow generation intent. The node parameter configuration tool is used to configure target parameters for the target node that are adapted to the workflow generation intent. The workflow is generated by connecting the target nodes configured with the target parameters using the workflow generation tool.

5. The method according to claim 4, wherein, The step of using the node parameter configuration tool to configure target parameters for the target node that are adapted to the workflow generation intent includes: The node parameter configuration tool is used to determine a node parameter configuration template that is compatible with the workflow generation intent; Configure the target parameters for the target node according to the node parameter configuration template.

6. The method according to claim 4, wherein, The workflow generation process also includes a node verification phase, and For multiple process stages in the workflow generation process, the AI ​​big data model, based on the workflow generation intent, determines the target tools required for generating the workflow at each process stage from the tool library, and further includes: Using the aforementioned large-scale artificial intelligence model, node verification tools for verifying the target parameters are determined from the workflow construction tools corresponding to the node verification stage in the tool library; and The process of using the workflow generation tool to connect target nodes configured with the target parameters and generate the workflow includes: The node verification tool is used to verify the target node configured with the target parameters. Upon successful verification, the workflow generation tool is used to connect the target node configured with the target parameters and generate the workflow.

7. The method according to claim 6, wherein, The step of using the node verification tool to verify the target node configured with the target parameters includes: Determine the node specification data for the applied workflow system; The node verification tool is used to verify the target node configured with the target parameters according to the node specification data.

8. The method according to claim 4, wherein, The workflow generation process also includes a workflow verification phase, and For multiple process stages in the workflow generation process, the AI ​​big data model, based on the workflow generation intent, determines the target tools required for generating the workflow at each process stage from the tool library, and further includes: Using the aforementioned large-scale artificial intelligence model, a workflow verification tool is determined from the tool library corresponding to the workflow verification stage to verify the workflow; and Also includes: The workflow is verified using the aforementioned workflow verification tool.

9. The method according to claim 8, wherein, The process of verifying the workflow using the workflow verification tool includes: The connection relationship verification tool is used to verify the node connection relationship of the workflow; Use an expression validation tool to validate the workflow expressions in the workflow. The node connection relationships and workflow expressions are verified using a complete verification tool.

10. The method according to claim 9, wherein, The process of verifying the node connections in the workflow using a connection verification tool includes: Generate a directed acyclic graph representing the workflow; The connection relationship verification tool is used to verify the node connection relationships of the directed acyclic graph.

11. The method according to claim 1, wherein, Also includes: In response to determining, through the large AI model, that the workflow template library includes workflow templates that satisfy the workflow generation intent; The workflow is generated based on the workflow template.

12. The method according to any one of claims 1-11, wherein, Also includes: In response to a target node in the workflow involving backend operations, the backend operations are completed by calling the corresponding backend service of the target node through the interface adapter. In response to a target node in the workflow involving a front-end operation, a terminal device is invoked to complete the front-end operation.

13. The method according to claim 11, wherein, Also includes: Generate a workflow template based on the described workflow; Add the workflow template to the workflow template library.

14. The method according to any one of claims 1-11, wherein, Also includes: Based on the received node library update operation, update the node library, including candidate nodes for building the workflow. Update the tool library based on the received tool library update operation.

15. The method according to any one of claims 1-11, wherein, Also includes: Present a framework diagram representing the workflow; The workflow is adjusted based on the adjustment information or actions taken in response to the framework diagram.

16. A workflow generation device based on a large model, comprising: The intent determination unit is configured to parse the workflow generation request and determine the workflow generation intent. The tool determination unit is configured to determine, through a large artificial intelligence model, target tools from a tool library for generating workflows that satisfy the workflow generation intent, wherein the tool library includes multiple workflow building tools; The workflow generation unit is configured to generate the workflow using the target tool.

17. An electronic device, characterized in that, include: At least one processor; as well as A memory communicatively connected to the at least one processor; wherein, The memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-15.

18. A non-transitory computer-readable storage medium storing computer instructions, characterized in that, The computer instructions are used to cause the computer to perform the method according to any one of claims 1-15.

19. A computer program product comprising: A computer program that, when executed by a processor, implements the method according to any one of claims 1-15.

Images