Task flow generation method and device, electronic equipment and storage medium

Abstract

The embodiment of the invention provides a task flow generation method and device, electronic equipment and a storage medium, and the method comprises the steps: determining a business scene type, and determining a standardized task name of the business scene type; constructing a graph data structure through the standardized task name, and creating an initial task flow based on the graph data structure; and determining the output format, and outputting the target task flow by adopting the initial task flow based on the output format, thereby realizing the purposes of standardizing the initial task, intelligently generating the task skeleton and filling detailed execution information, and finally outputting the standardized and executable automatic workflow. Therefore, the technical problems of flexibility, accuracy, maintenance cost and information association efficiency of traditional task arrangement are effectively solved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of task flow generation, in particular to a task flow generation method, a task flow generation device, an electronic device and a computer readable storage medium. BACKGROUND

[0002] A task flow is a process in which a series of interrelated tasks are organized in a certain logical order in order to complete a specific goal.

[0003] In complex business scenarios (such as enterprise automation processes, intelligent customer service systems, data analysis pipelines, etc.), task orchestration technology needs to dynamically generate task flows according to user needs, so how to improve the generation efficiency and accuracy of task flows at the same time has become a technical problem that needs to be overcome by technical personnel in the field. SUMMARY

[0004] The embodiments of the present application provide a task flow generation method, device, electronic device and computer readable storage medium to overcome the above problems or at least partially solve the above problems.

[0005] The embodiments of the present application disclose a task flow generation method, comprising:

[0006] determining a business scenario category and determining a standardized task name of the business scenario category;

[0007] constructing a graph data structure through the standardized task name, and creating an initial task flow based on the graph data structure;

[0008] determining an output format, and outputting a target task flow based on the output format using the initial task flow.

[0009] Optionally, it further comprises:

[0010] generating function description information for the standardized task name; a plurality of standardized task names correspond one-to-one to a plurality of function description information;

[0011] constructing a task name list using the standardized task name and the function description information; the task name list is used to store the standardized task name and the function description information corresponding to the business scenario category.

[0012] Optionally, the method is applied to a task flow generation system, the task flow generation system is configured with a user interaction interface, the user interaction interface is configured to display the task name list, and the method further comprises:

[0013] displaying prompt information for guiding users to use the task name list through the user interaction interface.

[0014] Optionally, the step of creating an initial task flow based on the graph data structure comprises:

[0015] determining task nodes and first association relationships among the task nodes based on the standardized task names;

[0016] constructing a graph data structure based on the task nodes and the first association relationships;

[0017] in response to listening to the user selecting a target task name from the standardized task names in the task name list through the prompt information, determining second association relationships among the target task nodes based on the graph data structure;

[0018] creating an initial task flow based on the second association relationships.

[0019] Optionally, the method further comprises:

[0020] creating a graph database knowledge base based on the graph data structure;

[0021] outputting a search result for the initial task flow based on the second association relationships using the graph database knowledge base.

[0022] Optionally, the step of outputting a target task flow based on the output format using the initial task flow comprises:

[0023] determining execution information of a target task of the target task name based on the search result;

[0024] outputting a target task flow based on the output format using the initial task flow and the execution information.

[0025] Optionally, the step of determining second association relationships among the target task nodes based on the graph data structure comprises:

[0026] performing a multi-hop path query based on the graph data structure to generate a task combination and a precondition of a target task of the target task name;

[0027] determining target paths of the target task name based on logical rules defined in the graph data structure using the task combination and / or the precondition;

[0028] the step of creating an initial task flow based on the second association relationships comprises:

[0029] creating an initial task flow based on the target paths using a plurality of the target task names.

[0030] The embodiment of the application further discloses a task flow generation device, comprising:

[0031] A business scenario category determination module is configured to determine a business scenario category and determine a standardized task name of the business scenario category.

[0032] An initial task flow creation module is configured to construct a graph data structure through the standardized task name and create an initial task flow based on the graph data structure.

[0033] A target task flow output module is configured to determine an output format and output a target task flow based on the initial task flow and the output format.

[0034] The embodiment of the application further discloses an electronic device comprising a processor, a communication interface, a memory and a communication bus, wherein the processor, the communication interface and the memory complete communication with each other through the communication bus.

[0035] The memory is configured to store a computer program.

[0036] The processor is configured to execute the program stored on the memory to implement the method according to the embodiment of the application.

[0037] The embodiment of the application further discloses a computer readable storage medium having instructions stored thereon, which, when executed by one or more processors, cause the processors to perform the method according to the embodiment of the application.

[0038] The embodiment of the application has the following advantages:

[0039] The embodiment of the application determines a business scenario category and a standardized task name of the business scenario category, constructs a graph data structure through the standardized task name, creates an initial task flow based on the graph data structure, determines an output format, and outputs a target task flow based on the initial task flow and the output format, thereby realizing task standardization from the beginning, intelligently generating a task skeleton and filling detailed execution information, and finally outputting a standardized and executable automated workflow, so that the technical problems of flexibility, accuracy, maintenance cost and information association efficiency of traditional task arrangement are effectively solved.

[0040] Further, the embodiment of the application also realizes the combination of strong constraints on a standardized knowledge base, dynamic generation capability of a large model and efficient association retrieval mechanism of a graph database, and the scheme can:

[0041] Realize accurate and dynamic generation of a task flow: overcome the disadvantages of poor flexibility and low generation accuracy of traditional schemes, so that the task flow can be highly customized according to user demand and can be executed on the ground, and ensure that the task name is accurately matched with the actual function.

[0042] Significantly improve information matching efficiency and accuracy: Solve the bottleneck of traditional relational databases in handling complex multi-layer dependency relationships, realize efficient and accurate association and retrieval of task, function, parameter, plug-in and other information through graph database, ensure that task nodes can accurately call required function modules, parameters and dependent resources.

[0043] Realize end-to-end full-process automation: From user demand analysis to standardized workflow output, the whole process is automated, which significantly reduces manual intervention and maintenance cost, and improves the deployment and operation efficiency of business process. BRIEF DESCRIPTION OF DRAWINGS

[0044] Figure 1 is a step flowchart of a task flow generation method provided in an embodiment of the present application;

[0045] Figure 2 is a structural block diagram of a task flow generation device provided in an embodiment of the present application;

[0046] Figure 3 is a hardware structural block diagram of an electronic device provided in an embodiment of the present application;

[0047] Figure 4 is a schematic diagram of a computer readable medium provided in an embodiment of the present application. DETAILED DESCRIPTION

[0048] In order to make the above-mentioned purposes, features and advantages of the present application more obvious and easy to understand, the present application will be further described in detail below with reference to the drawings and specific embodiments.

[0049] In increasingly complex business automation processes, intelligent customer service systems, data analysis pipelines and other business scenarios, task orchestration technology faces severe challenges: not only to dynamically build task flow according to user demand, but also to ensure that each task node in the process can accurately call the corresponding function module, pass necessary parameters and manage dependent resources.

[0050] The traditional technical solutions mainly fall into two categories. One is the static task flow design based on rule engine, which relies on manual preset task execution sequence and parameters, and is triggered through fixed rules. This solution has poor flexibility, is difficult to adapt to individual needs, and has high maintenance cost. The second is the natural language generation task flow relying on general large models, which can directly analyze user demand, but lacks effective constraints on task name, parameters and execution logic. This often leads to the task name generated by the large model not matching the actual function, making the process difficult to implement.

[0051] In addition, when processing parameter information required by a task, a conventional relational database has difficulty in efficiently associating the task, a function, parameters, plug-ins and other complex dependencies, thereby greatly reducing the accuracy of information matching.

[0052] To solve the above technical problems, an embodiment of the present application provides a task flow generation system (hereinafter referred to as the system), and a technical architecture of the system includes four layers.

[0053] 1. Task knowledge base construction layer: defining a list of standardized task names and function descriptions to form task metadata.

[0054] 2. Large model task flow generation layer: through constraint prompt word engineering, it is ensured that the task flow name output by the large model strictly matches the knowledge base.

[0055] 3. Graph database information retrieval layer: based on graph structure, it stores tasks, functions, parameters, plug-ins and their association relationships, and supports efficient multi-hop query.

[0056] 4. Interface generation layer: combined with templated prompt words, the task flow and retrieval information are output as standardized workflows in a preset format.

[0057] Among them, the key technical details include:

[0058] 1. Prompt word design for task flow generation: the task name list in the knowledge base is embedded in the prompt word, which forcibly constrains the large model to use only standardized task names, and generates a logically coherent flow through a sequential flow template. For example, "generate a task flow based on user requirements, the task name must be selected from the following list: [task 1: function description 1, task 2: function description 2…], and the output format is: task flow = [task A→task B→task C]."

[0059] 2. Graph database knowledge base design: a property graph model (such as Neo4j) is used to build multiple layers of associations, with tasks, functions, parameters, plug-ins, etc. as nodes, and task calls functions, function dependencies parameters, parameter association default values, and plug-in binding tasks as relationship types. Through task name retrieval, its associated functions, parameter default values and dependent plug-ins are quickly implemented to achieve information query.

[0060] 3. Interface generation prompt word design: define the output template, and forcibly make the large model fill in the task flow and the graph database retrieval results according to the field mapping, to ensure the format is uniform.

[0061] Reference Figure 1 The embodiment of the present application provides a task flow generation method, as shown in the step flowchart of the task flow generation method, which can specifically include the following steps:

[0062] Step 101: determine the business scenario category, and determine the standardized task name of the business scenario category.

[0063] Step 102, constructing a graph data structure through the standardized task name, and creating an initial task flow based on the graph data structure;

[0064] Step 103, determining an output format, and outputting a target task flow based on the output format using the initial task flow.

[0065] Business scenario category: refers to the specific field or industry to which the task flow generation method is applied, such as enterprise automation process, intelligent customer service system, data analysis pipeline, CAE simulation process, etc. Different categories have their specific business logic and executable task sets.

[0066] CAE simulation (Computer-Aided Engineering Simulation) refers to the use of computer software to simulate the physical behavior and performance of products, structures or systems to verify designs, predict problems and optimize product development processes.

[0067] Standardized task name: refers to a task name that is artificially defined, sorted and standardized in a specific business scenario, has a unique identifier and clear functional meaning. These names constitute a "white list" or "vocabulary" of system recognizable and executable tasks, such as "create preprocessing document", "open preprocessing document", "create cuboid", etc. in CAE simulation. Standardized task names are usually associated with their functional description information, together forming "task metadata".

[0068] The embodiments of the present application determine the business scenario category and the standardized task names of the business scenario category, achieving the following purposes:

[0069] Establish a unified task language: solve the problem of "flying sky" or inconsistency with actual functions that may occur when a general large model generates task names, and ensure that all task names are system understandable and executable.

[0070] Provide constraints and guidance for large models: provide clear boundaries and selection range for subsequent large model task flow generation, through prompt word engineering, force large models to select only from these standardized task names, thereby ensuring the standardization and feasibility of the generated task flow.

[0071] Build a field knowledge base: provide basic task entity information for subsequent graph data structure and retrieval.

[0072] By determining the business scenario category and the standardized task names of the business scenario category, the following beneficial effects are achieved:

[0073] Improve the accuracy of task flow generation: Avoid the problem that the process cannot be landed due to the mismatch of task names.

[0074] Reduce maintenance costs: The standardization of the task knowledge base makes the definition and management of tasks more centralized and efficient.

[0075] Enhance system controllability: Ensure that large models generate tasks within an expected range, reducing uncontrollable factors.

[0076] API stands for Application Programming Interface. Simply put, API is a set of defined rules and protocols that allow different software applications to communicate and interact. It specifies how software components call each other's functions and pass data.

[0077] Graph data structure: For example, it can be a property graph model using a graph database such as Neo4j. The standardized task name expressed as a node, and further associated API functions, parameter information, implementation plugins, parameter names, parameter default values, plugin modules, and plugin names as other nodes. The complex relationship between nodes (such as task calling functions, function dependent parameters, and plugin binding tasks) as edges, a multi-level knowledge graph is constructed. This structure can efficiently store and express all detailed dependencies and context information required for task execution.

[0078] Initial task flow: refers to a preliminary task execution sequence or logical relationship (for example "task A→task B→task C") generated by the large model according to user requirements and following the standardized task names defined in step 101. The "skeleton" of this task flow is based on the understanding of user intent and uses the standardized task names stored in the graph data structure as options to build. The initial task flow usually contains the execution order and basic logic of the task, but may not have filled in all the detailed information of the execution parameters.

[0079] The embodiment of the invention achieves the following purposes by constructing a graph data structure using standardized task names and creating an initial task flow based on the graph data structure:

[0080] Dynamic generation of task flow: Overcomes the limitations of traditional rule engine static predefinition, enabling the system to generate personalized task processes according to real-time user requirements.

[0081] Efficient management and retrieval of complex dependencies: Take advantage of the graph database to solve the low efficiency problem of traditional relational databases in handling multi-layer complex dependencies of tasks, functions, parameters, and plugins, ensuring that all associated information required for task execution can be quickly and accurately located.

[0082] Filling in execution details for the task flow: The graph data structure in this step provides each node of the subsequent task flow with the detailed functions, parameters, and other information required for its runtime, making the task flow from a concept to an executable entity.

[0083] By constructing a graph data structure based on the standardized task names, and creating an initial task flow based on the graph data structure, the following beneficial effects are achieved:

[0084] Significantly improve system flexibility: dynamically adapt to diverse and personalized user needs.

[0085] Improve information matching accuracy and efficiency: the multi-hop query capability of the graph database ensures the quick and accurate acquisition of complex associated information.

[0086] Support advanced functions (such as path discovery and rule reasoning): the "multi-hop path query" and "rule reasoning" capabilities mentioned in the optional embodiment play a role at this stage, enabling the discovery of the optimal or most robust task execution path based on the graph data structure, further optimizing the quality of the task flow.

[0087] Output format: refers to the standardized data structure or file format of the final generated workflow, such as a JSON format document containing the overall structure of the task flow, the name of each task, the called function, the passed parameters and their values, the dependent plugins, and all other detailed information required for execution. This format is preset and usually constrained by "templated prompts" for large model generation.

[0088] Target task flow: refers to the final output, fully parameterized and detailed defined, standardized workflow that can be directly called by external systems or automated execution engines. It is the final product of the "initial task flow" after detailed information supplementation and formatted packaging.

[0089] In the embodiment of the present application, by determining the output format, the initial task flow is used to output the target task flow based on the output format, achieving the following purposes:

[0090] Implement end-to-end automation: after intelligent processing and information integration of user needs, the final output is converted into executable automation instructions without the need for manual secondary understanding or conversion.

[0091] Ensure interoperability: through a unified standardized output format, ensure that the generated task flow can be seamlessly parsed and executed by different downstream systems or execution engines.

[0092] Provide a clear execution blueprint: make the execution logic and required resources of the task flow clear at a glance, facilitating subsequent monitoring, debugging, and management.

[0093] By determining the output format, the initial task flow is used to output the target task flow based on the output format, which achieves the following beneficial effects:

[0094] Significantly reduces manual intervention: The automation link from demand to execution reduces a large amount of manual configuration and conversion work.

[0095] Improves system integration efficiency: The standardized output format facilitates seamless integration with existing automation infrastructure.

[0096] Enhances the reliability of process execution: Clear execution parameters and unified format reduce the possibility of runtime errors.

[0097] Improves user experience: Users only need to provide natural language requirements to obtain structured and executable automation processes.

[0098] In the embodiment of the application, the business scenario category is determined, and the standardized task name of the business scenario category is determined. The graph data structure is constructed based on the standardized task name, and the initial task flow is created based on the graph data structure. The output format is determined, and the initial task flow is used to output the target task flow based on the output format. From the beginning of task standardization to intelligent generation of task skeleton and filling of detailed execution information, the final output is standardized and executable automation workflow, thereby effectively solving the technical problems of traditional task arrangement in flexibility, accuracy, maintenance cost and information association efficiency.

[0099] On the basis of the above-mentioned embodiments, variant embodiments of the above-mentioned embodiments are proposed. It should be noted that in order to make the description brief, only the differences between the above-mentioned embodiments are described in the variant embodiments.

[0100] In an optional embodiment of the application, it further comprises:

[0101] Generating function description information for the standardized task name; a plurality of standardized task names correspond to a plurality of function description information one by one;

[0102] Using the standardized task name and the function description information to construct a task name list; the task name list is used to store the standardized task name and the function description information corresponding to the business scenario category.

[0103] Function description information: refers to the textual description of the specific function, operation details, expected effect, input and output, and any related constraints of each "standardized task name". These descriptions are the key for humans or large models to understand the behavior of the task, for example, the function description of "creating pre-processing document" may be "initializing a blank document for CAE simulation preprocessing, preparing for model definition".

[0104] Each standardized task name must have a unique and clear functional description associated with it, forming a key-value pair, such as (task name: functional description).

[0105] By generating functional description information for the standardized task names, the following purposes can be achieved:

[0106] Deepen task semantic understanding: help large models understand the actual function and context of each standardized task more deeply, not just its name, which is crucial for large models to perform intelligent reasoning and task combination.

[0107] Assist large models to generate more reasonable task flow: large models will not only consider the name, but also combine the functional description to judge the logical relationship and applicability between tasks when selecting and arranging tasks.

[0108] Provide the basis for manual maintenance and understanding: facilitate system developers or administrators to understand and maintain the task knowledge base.

[0109] By generating functional description information for the standardized task names, the following beneficial effects can be achieved:

[0110] Improve the accuracy and rationality of large model task selection: large models can better match user needs and task functions.

[0111] Enhance the logical coherence of task flow: large models can more effectively organize tasks, avoiding functional conflicts or unnecessary steps.

[0112] Improve the usability of the knowledge base: make the task knowledge base not just a list of names, but a clear "dictionary" of functions.

[0113] The embodiment of the application can construct a task name list using the standardized task names and the functional description information; the task name list is used to store the standardized task names and the functional description information corresponding to the business scenario category.

[0114] Task name list: a structured data collection that contains all standardized task names and their corresponding functional description information in a specific business scenario. It may be stored in JSON, CSV, database table or other formats that are easy for machines to read and retrieve. This list is a specific embodiment of the "task knowledge base".

[0115] The embodiment of the application, by using standardized task names and functional description information to construct a task name list, can achieve the following purposes:

[0116] Form a callable task knowledge base: consolidate scattered task names and function descriptions into a unified resource that can be directly referenced by the system, especially large models.

[0117] As the basis for large model prompt engineering: the contents of this list will be embedded into the prompts of large models as "mandatory choices" that must be followed when the large model generates a task flow.

[0118] Provide basic node information for subsequent graph data structure construction: the task nodes in the graph database are derived from the standardized task names in this list.

[0119] The implementation of the present invention, by adopting standardized task name and function description information to construct the task name list, can achieve the following beneficial effects:

[0120] Realize the centralized management and reuse of task knowledge: avoid the problem of scattered and inconsistent task information.

[0121] Simplify the prompt engineering of large models: the entire list can be directly referenced as a constraint, improving the efficiency and effectiveness of prompts.

[0122] Ensure the accuracy of the source of task flow generation: all subsequent task flow generation will be based on this authoritative task knowledge base.

[0123] Lay the foundation for the standardization and scalability of the entire automation system.

[0124] Example: construction of task knowledge base in CAE simulation process

[0125] Background:

[0126] Suppose we are currently building a system for automating CAE simulation analysis. In this system, users can describe the simulation steps they want to perform through natural language, and then the system will automatically generate an executable simulation task flow.

[0127] For the stage of generating function description information for standardized task names, we can sort out the common and automatically executable "operations" in CAE simulation, define their standardized names, and write clear function descriptions for each name, as shown in Table 1.

[0128] Table 1:

[0129]

[0130]

[0131] Table 1 shows the "one-to-one correspondence" relationship between standardized task names and function description information. Each task name is explicitly and uniquely associated with a specific and understandable operation description.

[0132] For the task name list construction phase using standardized task names and function description information, the above sorted information can be stored in a computer-readable structured format to form a "task name list" (i.e., a task knowledge base in the CAE simulation field).

[0133] Example task name list (JSON format):

[0134]

[0135]

[0136]

[0137]

[0138] The role of the task name list:

[0139] 1. As part of the large model prompt: When the user inputs "Please help me with a stress analysis, first create a cuboid, then divide the grid, and finally generate a stress cloud map", the system will embed this task list into the prompt for the large model, for example: "You are a professional CAE simulation task arrangement assistant. Please select the appropriate task from the following task list based on user requirements to generate a task flow that is executed in order. The task name must be strictly selected from the list and remain unchanged. If the user description contains parameter information, add it to the task name in the form of 'task name, parameter1 = value1, parameter2 = value2'. If the user does not provide parameters, do not write parameters. Task list: [{"name":"create cuboid","description":"..."},{"name":"divide grid","description":"..."},...] User requirements: Please help me with a stress analysis, first create a cuboid, then divide the grid, and finally generate a stress cloud map. Output format: {"workflow":[]}"

[0140] The large model is constrained to only use standardized names such as "create cuboid", "divide grid", and "generate stress cloud map".

[0141] 2. Provide a basis for graph database construction: When creating task nodes, the graph database uses names from this list.

[0142] Through this example, it can be clearly seen how the "standardized task names and function description information" are generated, and it shows the one-to-one correspondence between multiple "standardized task names" and multiple "function description information", and finally how to build a structured task name list and store it for subsequent constraint prompt word engineering.

[0143] In an optional embodiment of the present application, the method is applied to a task flow generation system configured with a user interaction interface configured to display the task name list, the method further comprising:

[0144] Displaying prompt information for guiding users to use the task name list through the user interaction interface.

[0145] Embodiments of the present application can be applied to a task flow generation system configured with a user interaction interface configured to display the task name list, the task flow generation system configured with a user interaction interface configured to display the task name list.

[0146] User interaction interface (UI): a graphical or command line interface through which users interact with the task flow generation system. It provides visual elements and controls that allow users to input information, view results, perform operations, etc.

[0147] Embodiments of the present application can present the above-mentioned task name list containing standardized task names and their function descriptions to users in a visual manner on the user interface, for example, in the form of a drop-down menu, a searchable list, a tag cloud, etc.

[0148] Objective:

[0149] Enhance user's understanding of system capabilities: let users clearly know what the current system can do, i.e. which standardized tasks the system can recognize and handle.

[0150] Guide users to express norms: by showing the available task list, subtly guide users to use the standardized task names in the list or their approximate descriptions when describing requirements, so as to improve the accuracy of large models in analyzing user's intentions.

[0151] Improve user experience: provide intuitive and convenient task selection methods, reduce the threshold for users to understand and use the system.

[0152] Beneficial effects:

[0153] Improve the accuracy of user requirement input: after understanding the available tasks, users can more accurately construct their own requirement description, reducing ambiguity and misunderstanding.

[0154] Accelerate task flow generation process: Standardized user inputs allow large models to more efficiently match to the correct tasks, reducing iterations and corrections.

[0155] Reduce system error rate: Decrease instances of large model misjudgments or generation of unexecutable task flows due to non-standardized user inputs.

[0156] Prompt information: A piece of text or visual cue displayed on the user interaction interface, aiming to guide users on how to effectively use the task name list and how to describe their needs to be better understood and processed by the system.

[0157] Displaying prompt information for guiding users to use the task name list through the user interaction interface can achieve the following purposes:

[0158] Further guide user behavior: Not only show the list, but also explicitly tell users how to use this list to optimize their inputs.

[0159] Optimize user interaction with large models: Help users understand that using standardized names or following specific formats (such as explicit parameters) can obtain more accurate generation results.

[0160] Improve user input quality: Encourage users to provide structured or semi-structured needs, even if it is a natural language description, which can be closer to the system's expectations.

[0161] Benefits:

[0162] Enhance the convenience of user operations: Users do not have to guess how to describe their needs, but have clear guidance.

[0163] Improve the success rate of task flow generation: High-quality user inputs are the basis for generating high-quality task flows.

[0164] Reduce user learning cost: Through explicit guidance, users can quickly get started and efficiently use the system.

[0165] Exemplary prompt information:

[0166] Suppose the business scenario is "CAE simulation process", and we have a list of standardized tasks including "create preprocessing document", "import geometry model", "create cuboid", "divide mesh", "submit simulation calculation", "generate stress cloud map", "output analysis report", etc.

[0167] In the user interaction interface, in addition to displaying this task name list (such as a drag-and-drop list on the left or an autocomplete search box on the right), the system may display the following prompt information near the user input box:

[0168] 1. Concise guidance type:

[0169] "Please describe the CAE simulation steps you want to automate. You can choose from the task list on the left or type directly, and the system will generate a task flow for you."

[0170] 2 Emphasize the normative type (closer to the purpose of the scheme):

[0171] "Please describe the CAE simulation steps you want to automate. You can choose from the task list on the left or type directly, and the system will generate a task flow for you."

[0172] Available task list:

[0173] Create pre-processing document

[0174] Import geometry model

[0175] Create a cuboid (function: create a parameterized cuboid in the model)

[0176] ...(complete list)

[0177] Please enter your requirements below:

[0178] 3 Intelligent recommendation type (combined with large model capabilities):

[0179] "Please tell me the CAE simulation tasks you want to do. The more specific your input, the more accurate the task flow generated by the system.

[0180] Suggestion: Try to use the task names in the list or describe its core function. For example:

[0181] 'I want to start a new simulation project' (corresponding to: Create pre-processing document)

[0182] 'Import a component' (corresponding to: Import geometry model)

[0183] 'Calculate the stress distribution' (corresponding to: Generate stress cloud map)

[0184] Common tasks: [Create pre-processing document] [Import geometry model] [Divide mesh]...(clickable shortcut buttons)

[0185] Your requirements: [___________]"

[0186] These prompt messages aim to guide users intuitively to understand how to interact more effectively with the underlying large model and knowledge base, thereby improving the accuracy of task flow generation and user satisfaction.

[0187] In an optional embodiment of the present application, the step of creating an initial task flow based on the graph data structure constructed by the standardized task names comprises:

[0188] determining a task node by the standardized task name, and a first association relationship of the task node;

[0189] constructing a graph data structure based on the task node and the first association relationship;

[0190] determining a second association relationship between the target task nodes by the graph data structure in response to listening to the user selecting a target task name in the standardized task name list of the task name list through the prompt information;

[0191] creating an initial task flow by using the second association relationship.

[0192] The embodiment of the present application can determine a task node by the standardized task name, and a first association relationship of the task node;

[0193] Task node: In the graph data structure, each standardized task name corresponds to an independent task node (Node). These task nodes are the basic elements of the task flow and the knowledge graph.

[0194] First association relationship: refers to the basic and direct connection relationship between the task node and its directly related functional modules, parameters, plug-ins and other entities. The first association relationship describes the preliminary requirements of task execution, such as "task A calls function F1" and "task B needs parameter P1".

[0195] Purpose:

[0196] Building a basic entity of the graph: converting discrete standardized tasks into connectable entities in the graph database, laying a foundation for subsequent complex associations.

[0197] Defining the basic execution attributes of the task: when the task node is determined, the most direct and basic execution dependencies (such as which function to call and which core parameters to depend on) are identified at the same time, forming an initial association network.

[0198] Beneficial effects:

[0199] Realize the structured representation of the task: convert the task from pure text description to programmable and queryable data objects in the graph database.

[0200] Improve the information association efficiency: by defining the direct association early, provide a clear starting point for subsequent graph data construction and query.

[0201] The embodiment of the application can also construct a graph data structure based on the task node and the first association relationship.

[0202] Graph data structure: a complete knowledge graph, which is composed of a large number of task nodes, function function nodes, parameter nodes, plug-in nodes and complex first association relationships (such as task calling function, function dependent parameter, parameter associated default value, plug-in binding task, etc.) among them. This forms a networked and semantic representation of all detailed information required for task execution.

[0203] Purpose:

[0204] Form a comprehensive task knowledge graph: organize all standardized tasks and their related execution details (functions, parameters, plug-ins, etc.) in the form of a graph, providing a "knowledge base" for subsequent intelligent generation and accurate calling.

[0205] Support efficient multi-hop query: the non-relational nature of the graph data structure enables efficient complex and deep association queries, which is an advantage that traditional relational databases cannot match.

[0206] Beneficial effects:

[0207] Solve the traditional database association problem: effectively overcome the efficiency bottleneck and low accuracy problem of relational databases in associating multi-layer complex dependency relationships.

[0208] Provide a rich task execution context: any task node can be traced back to all required parameters, functions and dependent plug-ins through the graph, providing complete information for subsequent accurate calling.

[0209] Lay the foundation for intelligent reasoning: a perfect graph data structure is the prerequisite for implementing advanced functions such as "path discovery and optimization" and "rule reasoning".

[0210] The embodiment of the application can determine the second association relationship between the target task nodes through the graph data structure in response to listening to the user selecting a target task name in the standardized task name list of the task name list through the prompt information.

[0211] In specific implementation, the system of the embodiment of the application can receive user input (usually natural language requirements), and through internal large model analysis, combined with the guidance of the "task name list" and "prompt information" displayed in the user interaction interface (UI), identify the specific "target task name" (i.e. standardized task) expected to be executed in the user's intention. This is the process of selecting a task from the standardized task list according to the user input by the large model.

[0212] Target task node: refers to the specific standardized task that the user's intention points to and will appear in the task flow in the corresponding task node in the graph data structure.

[0213] Second association relationship: after determining the "target task node" expected by the user, the system discovers all deep and complex execution dependencies and logical relationships between these target task nodes other than simple sequential connections through querying the graph data structure (such as "multi-hop path query" and "rule reasoning"). This may include task preconditions, data flow between tasks, parallel execution relationships, conditional branching logic, and specific function and parameter details required for each task, etc. It is more complex than the "first association relationship" and closer to the actual task flow execution logic.

[0214] Purpose:

[0215] Implement the preliminary conversion of user intention to task flow: convert the user's unstructured natural language requirements into a preliminary process that can be recognized by the system and consists of standardized tasks.

[0216] Dig deep execution logic between tasks: when the user only gives the task name (or part of the logic), the system can automatically fill in the dependencies and execution details between tasks through the graph data structure, such as "task A must be successful before task B can be executed" or "tasks C and D can be executed in parallel".

[0217] Lay the foundation for the intelligence and robustness of the task flow: identifying complex association relationships is a prerequisite for building efficient and robust task flows.

[0218] Beneficial effects:

[0219] Improve the intelligence level of task flow generation: the system can automatically complete and optimize the logical relationships between tasks, reducing manual intervention.

[0220] Improve the accuracy and executability of the task flow: identify all necessary dependencies to avoid execution failures due to missing preconditions or parameters.

[0221] Enhance the robustness of the process: by understanding the complex associations between tasks, more flexible and fault-tolerant task flows can be designed.

[0222] The embodiments of the present application can also construct an initial task execution sequence, i.e. an initial task flow, according to the user's intention and the "second association relationship" mined from the graph data structure. At this time, the task flow not only contains standardized task names, but also contains the logical order, parallel relationship, conditional branching between these tasks, and the basic information required for their execution (but may not be fully formatted into the final interface).

[0223] Purpose:

[0224] Forming a logically complete task execution sequence: integrating scattered "target task nodes" and their "second association relationships" to build a structured and logical preliminary workflow.

[0225] Preparing for final interface output: this initial task flow is the basic framework of the final standardized workflow.

[0226] Benefits:

[0227] Automated orchestration of task flow: complex user requirements are converted into directly executable flowcharts or execution sequences.

[0228] Improve development efficiency: automated generation of task flow reduces the time for manual writing and debugging of processes.

[0229] Ensure the correctness of the process: based on accurate second association relationships, the generated task flow is more rigorous in logic.

[0230] For example, continue to take the CAE simulation process as an example to illustrate the entire process and concept.

[0231] Business scenario: automated CAE structural static analysis

[0232] Task name list (part):

[0233] Create a pre-processing document: initialize the CAE project.

[0234] Import geometry model: load model file.

[0235] Create a cuboid: generate a parameterized cuboid.

[0236] Define material properties: set component materials.

[0237] Apply fixed constraints: apply fixed boundaries.

[0238] Apply force load: apply external force.

[0239] Divide the grid: discretize the geometric model.

[0240] Submit simulation calculation: run the solver.

[0241] Generate stress contour map: visualize stress results.

[0242] Output analysis report: generate final report.

[0243] User interface (UI): display the above task list with prompt information to guide the user.

[0244] Example: Graph data structure construction of task flow and preliminary task flow creation

[0245] Sub-step 1: Determine the task node through the standardized task name, and the first associated relationship of the task node;

[0246] At this stage, the system will extract information from pre-defined knowledge or from other metadata sources (such as API documents, code annotations) in the background to identify each standardized task and its most direct association.

[0247] Identify task nodes:

[0248] "Create pre-processing document" -> Node Task: Create pre-processing document

[0249] "Import geometry model" -> Node Task: Import geometry model

[0250] "Create cuboid" -> Node Task: Create cuboid

[0251] ...(All standardized tasks become an independent node in the graph)

[0252] Determine the first associated relationship: This is usually the task and its directly called function or application programming interface API, as well as the core parameters required by these functions.

[0253] Example:

[0254] Task: Create cuboid -- (call) --> Function: create_box

[0255] Function: create_box -- (required parameter) --> Parameter: length

[0256] Function: create_box -- (required parameter) --> Parameter: width

[0257] Function: create_box -- (required parameter) --> Parameter: height

[0258] Function: create_box -- (required parameter) --> Parameter: insert_point

[0259] Task: Divide mesh -- (call) --> Function: mesh_geometry

[0260] Function: mesh_geometry -- (requires parameters) --> Parameter: mesh_size

[0261] Function: mesh_geometry -- (requires parameters) --> Parameter: element_type

[0262] Task: submit simulation calculation -- (calls) --> Function: submit_solver

[0263] Function: submit_solver -- (requires parameters) --> Parameter: solver_type

[0264] Task: generate stress plot -- (calls) --> Function: generate_stress_plot

[0265] Function: generate_stress_plot -- (requires parameters) --> Parameter: result_file_path

[0266] Sub-step 2: Construct a graph data structure based on the task nodes and the first association relationships.

[0267] Import all the identified nodes and their first association relationships into a graph database (such as Neo4j). This constructs a large and interconnected knowledge graph representing the composition information of all executable tasks in the system and their mutual dependencies.

[0268] Graph data structure diagram (simplified):

[0269] (Task: create a cuboid) -- [calls] -- (Function: create_box)

[0270] (Function: create_box) -- [requires parameters] -- (Parameter: length)

[0271] (Function: create_box) -- [requires parameters] -- (Parameter: width)

[0272] (Function: create_box) -- [requires parameters] -- (Parameter: height)

[0273] (Function: create_box) -- [requires parameters] -- > (Parameter: insert_point)

[0274] (Task: mesh geometry) -- [calls] -- > (Function: mesh_geometry)

[0275] (Function: mesh_geometry) -- [requires parameters] -- > (Parameter: mesh_size)

[0276] (Function: mesh_geometry) -- [requires parameters] -- > (Parameter: element_type)

[0277] (Task: submit solver) -- [calls] -- > (Function: submit_solver)

[0278] (Function: submit_solver) -- [requires parameters] -- > (Parameter: solver_type)

[0279] (Task: generate stress plot) -- [calls] -- > (Function: generate_stress_plot)

[0280] (Function: generate_stress_plot) -- [requires parameters] -- > (Parameter: result_file_path)

[0281] / / In addition to direct invocation relationships, there are dependencies between tasks (e.g., the output of one task is the input of another task)

[0282] (Task: create box) -- [outputs geometry] -- > (Geometry: box_model)

[0283] (Geometry: box_model) -- [inputs geometry] -- > (Task: mesh geometry)

[0284] (Task: mesh geometry) -- [outputs mesh model] -- > (Mesh: meshed_model)

[0285] (Mesh: meshed_model) -- [inputs model] -- > (Task: submit solver)

[0286] (Task: submit simulation computation) -- [output file] -- (File: simulation_result.op2)

[0287] (File: simulation_result.op2) -- [input data] -- (Task: generate stress map)

[0288] / / Even a rule node can be present

[0289] (Task: submit simulation computation) -- [success trigger] -- (Rule: if_success_then_plot_stress)

[0290] (Rule: if_success_then_plot_stress) -- [condition satisfied trigger] -- (Task: generate stress map)

[0291] Sub-step 3: In response to listening to the user selecting a target task name in the standardized task names of the task name list through the prompt information, determining the second association relationship between the target task nodes through the graph data structure;

[0292] User input example: The user inputs the requirement in the graphical user interface (UI): "I need to create a cuboid, then divide the grid, then submit simulation computation, and finally generate a stress map." The prompt information on the UI guides the user to use standardized task names and specified parameters.

[0293] Listening and recognition: The system listens to the user input and, combined with the large model and the task name list, identifies the "target task name" in the user's intention:

[0294] Task: create a cuboid; Task: divide the grid; Task: submit simulation computation; Task: generate a stress map;

[0295] Determine the second association relationship through the graph data structure:

[0296] a. Sequential / data flow dependency (multi-hop query):

[0297] The system queries in the graph database: The output of Task: create a cuboid (Geometry: box_model) is the input of Task: divide the grid.

[0298] The output of Task: divide the grid (Mesh: meshed_model) is the input of Task: submit simulation computation.

[0299] Task: Submit the output of the simulation calculation (File: simulation_result.op2) is the input of Task: Generate stress contour plot.

[0300] Result: A strict sequential execution dependency was identified among these tasks.

[0301] b. Rule-based reasoning (if it exists):

[0302] The system discovered a rule between "submit simulation calculation" and "generate stress contour plot": "If the task submission for simulation calculation is successful, then generate stress contour plot." This reinforces the sequential and conditional dependency between them.

[0303] c. Parameter association (multi-hop query):

[0304] For the Task: Creating a cuboid, the graph shows that it requires the parameters length, width, height, and insert_point.

[0305] For Task: Mesh Generation, the parameters mesh_size and element_type are required.

[0306] For Task: Submitting simulation calculations, the solver_type parameter is required.

[0307] For the Task: Generating stress contour plots, the result_file_path parameter is required (which can be inferred to be the output of the simulation calculation).

[0308] Sub-step 4: Create an initial task flow using the second association relationship.

[0309] The system integrates all identified target task nodes and the complex "secondary relationships" between them to construct a preliminary, logically clear task flow.

[0310] Initial task flow (logic illustration):

[0311]

[0312] The “Initial Task Flow” already includes the target task name of the target task node, the execution order among multiple target task nodes, potential parameter placeholders (to be filled or default values ​​are used if not explicitly given by the user), and logical dependencies inferred from the graph (such as conditional execution).

[0313] It is a structured blueprint that awaits to be fully populated with parameters and formatted into executable JSON and other interface documents in the final interface generation layer.

[0314] The above examples show how to generate a preliminary task flow that meets user intent and is logically rigorous from the bottom layer of standardized task definitions through the powerful association and inference capabilities of graph data structures.

[0315] In an optional embodiment of the present application, it further comprises:

[0316] Creating a graph database knowledge base based on the graph data structure;

[0317] Using the graph database knowledge base to output retrieval results for the initial task flow based on the second association relationship.

[0318] The embodiment of the present application can create a graph database knowledge base based on the graph data structure;

[0319] Graph database knowledge base: refers to the actual storage and management of the above graph data structure in a specific graph database management system (such as Neo4j). This system not only contains data, but also provides efficient query language (such as Cypher for Neo4j), indexing mechanism, transaction management and other functions, making it a real-time query and operation "knowledge base". It turns the abstract "graph data structure" into a usable "database".

[0320] Purpose:

[0321] Prolonged and operable: The abstract graph data structure is landed as a specific database instance to ensure the persistent storage and efficient access of knowledge.

[0322] Provide query capabilities: enable the system to use the powerful query capabilities provided by the graph database knowledge base to perform complex relationship traversal and information retrieval.

[0323] Support real-time query: can quickly retrieve relevant information at any stage of task flow generation or execution as needed.

[0324] Beneficial effects:

[0325] Efficient storage and management of data: Optimizes the storage method of complex task-related information, and is more suitable for handling multi-level, network-related data than traditional relational databases.

[0326] Provide a basis for subsequent information retrieval: Only by establishing a usable graph database knowledge base can subsequent retrieval operations be performed.

[0327] Improved robustness of graph database knowledge base operation: Graph database knowledge bases usually include transaction, backup and recovery mechanisms, which ensure the stability and reliability of the knowledge base.

[0328] The embodiment of the application can also output a retrieval result for the initial task flow based on the second correlation relationship according to the graph database knowledge base.

[0329] The system of the embodiment of the application can directly call the graph database knowledge base filled with data created above, perform a query operation, and identify deep logic and execution dependency between task nodes in the initial task flow identified by the large model in combination with a graph data structure, that is, the second correlation relationship.

[0330] Initial task flow: refers to a preliminary task execution sequence identified by a large model according to user demand and in combination with a graph data structure, which contains standardized task names and logical relationships (second correlation relationship) therebetween, but has not yet filled all specific parameters and function call details required for execution.

[0331] Retrieval result: refers to all detailed execution information corresponding to each task node and the second correlation relationship thereof in the initial task flow, which is queried and extracted from the graph database knowledge base, and the information includes:

[0332] Specific API function / call interface of each task, parameter name required for each function, default value or acquisition method of the parameters, specific plug-in or module that the task can depend on, data flow path between tasks, which can be further refined if not fully embodied in the second correlation relationship, and other execution configuration information, and the like.

[0333] Purpose:

[0334] Fill specific execution parameters and details for the initial task flow: the initial task flow has a logical skeleton, but lacks actual executable parameter details and complete call information. The purpose of this step is to extract all necessary parameters, functions and dependency information from the graph database knowledge base "on demand" according to the structure of the initial task flow and the second correlation relationship identified therein.

[0335] Prepare information required for accurate calling of tasks: ensure that each task node can obtain its accurate call function, correct parameter value, and access to required resources when the final task flow is executed.

[0336] Key step of converting a logical flow into executable instructions: the retrieval result is important data support for converting the abstract "initial task flow" into the "executable instruction set" with complete execution elements.

[0337] Beneficial effects:

[0338] Ensure the accuracy of task execution: provide all accurate parameters and dependency information required for task execution, and avoid execution failure caused by missing or incorrect information.

[0339] Enhanced automation: Automatic completion of parameters and dependency information, eliminating the need for manual searching or configuration.

[0340] Improved system efficiency: The efficient query capability of the graph database ensures quick retrieval of a large amount of associated information.

[0341] Enhanced completeness of the final task flow: The final output target task flow can contain all details from concept to execution.

[0342] In an optional embodiment of the present application, the step of outputting a target task flow based on the output format using the initial task flow comprises:

[0343] Determining the output format according to the prompt word;

[0344] Determining the execution information of the target task based on the search result;

[0345] Outputting a target task flow based on the output format using the initial task flow and the execution information.

[0346] Embodiments of the present application can determine the output format according to the preset prompt word;

[0347] The prompt word can be a command or template preset in the system design phase to guide the large model (or internal component of the system) to generate the final output in a specific structure and format. This is usually achieved through "template prompt word engineering", which defines the fields, nesting relationships and data types of the final target task flow (such as JSON).

[0348] Output format: refers to the standardized data structure or file format followed by the final generated target task flow, such as a specific JSON schema, YAML configuration, or some workflow definition language (such as a simplified representation of BPMN). It ensures the consistency and machine readability of the generated results.

[0349] Purpose:

[0350] Standardize the final output: Ensure that the final generated task flow is presented in a unified, standard, and downstream system-parsable format regardless of user requirements.

[0351] Implement system interoperability: Through the pre-defined format, the task flow generation system can seamlessly interface with various automated execution engines or business systems.

[0352] Reduce integration complexity: The unified output format reduces the difficulty of other systems to parse and understand the task flow.

[0353] Advantages:

[0354] Improving system integration efficiency: achieving plug-and-play with external systems.

[0355] Ensuring the accuracy of data transmission and analysis: standardization of format avoids problems caused by format incompatibility or analysis errors.

[0356] Facilitating automated execution: uniform format allows the automation engine to write a general parser to handle all generated task flows.

[0357] The embodiment of the present application can also determine the execution information of the target task of the target task name based on the search results;

[0358] Search results: refers to all detailed execution information corresponding to each task node in the initial task flow and its second association relationship extracted from the graph database knowledge base. These information includes but not limited to each task specific API function / call interface, required parameter name, parameter default value, task may depend on specific plug-in or module, data flow path between tasks, etc.

[0359] Execution information of the target task of the target task name: this refers to the final detailed (task) instruction set for each standardized task name in the initial task flow (also the "target task" in the final "target task flow") based on the search results, which can be directly used for execution. It converts abstract task name into specific execution action.

[0360] Purpose:

[0361] Perfect task execution details: accurately match and fill the rich information provided by the graph database (search results) with the task names in the initial task flow, so that each task is no longer just a name, but has complete execution instructions.

[0362] Ensure task executability: clearly specify which function each task needs to call, which parameters to pass, and the specific values or acquisition methods of these parameters, thereby ensuring the correctness and success rate of task execution.

[0363] Beneficial effects:

[0364] Provide all elements required for task execution: eliminate uncertainty in task execution, so that task flow can be directly understood and run by machine.

[0365] Improve the accuracy and success rate of task execution: avoid task failure due to missing or incorrect parameters.

[0366] Implement automated filling of task parameters: no need for manual configuration of parameters, greatly improving the degree of automation.

[0367] According to the embodiments of the present application, the initial task flow and the execution information can be used to output the target task flow based on the output format.

[0368] Initial task flow: This is the task sequence skeleton generated by the large model initially and determined in combination with the second association relationship. It defines the logical order and dependency of tasks.

[0369] Execution information: refers to the detailed calling parameters and function information specific to each task determined based on the retrieval results in the previous step.

[0370] Output format: refers to the standardized data structure or file format determined in the first sub-step.

[0371] Target task flow: This is the final product of the entire task flow generation method. It is a fully executable standardized workflow that combines the logical structure of the initial task flow with the detailed execution information of each task (from the retrieval results) and is strictly packaged according to the preset output format. It represents the automated implementation of user requirements.

[0372] Purpose:

[0373] Implement end-to-end automated process: The user's initial natural language requirements are converted into a complete instruction set that can be directly executed by an automated engine after a series of intelligent processing and information integration.

[0374] Complete the final packaging of the task flow: all dispersed knowledge and generated logic are aggregated into a single, structured, callable interface.

[0375] Beneficial effects:

[0376] Achieve an automated closed loop from "requirements to execution": greatly reduces manual intervention and improves the deployment and operation efficiency of business processes.

[0377] Improve overall system efficiency and throughput: automated output enables task flow to be quickly generated and scheduled.

[0378] Enhance system usability and user experience: users only need to provide requirements to obtain an instantly available automated solution.

[0379] Provide a clear execution blueprint: the structured and detailed nature of the target task flow makes it easier to monitor, debug, and audit the process.

[0380] Through the above examples, all the accumulated intelligence and knowledge (task knowledge base, large model generation logic, graph database retrieval ability) are ensured to be finally converted into an operational, executable, standardized automated process, thus perfectly solving the automation, precision and efficiency problems of task orchestration in complex business scenarios.

[0381] For example, continue to take the CAE simulation process as an example to specifically illustrate the two steps of "determining the execution information of the target task with the target task name based on the retrieval results" and "outputting the target task flow based on the output format using the initial task flow and the execution information".

[0382] Assumptions:

[0383] 1 Initial Task Flow (Initial Task Flow):

[0384] After the large model according to the user demand (for example: "Please help me create a cuboid model, then perform mesh division, then submit static simulation calculation, and finally generate stress nephogram.") and combined with the "second association relationship" reasoning of the graph database, we get a preliminary task sequence. This sequence contains task names and their basic logical dependencies.

[0385]

[0386]

[0387] Retrieval Results (Retrieval Results):

[0388] The system has queried and obtained the detailed execution information (function call, parameter definition, default value, plug-in dependency, etc.) corresponding to each task from the graph database knowledge base according to the standardized task name in the initial task flow.

[0389]

[0390]

[0391] 3 Preset Output Format (Output Format) Definition:

[0392] Suppose we want the final "target task flow" to be a JSON array, and each task object contains id, name, function, arguments, dependencies, conditions, plugin_id, etc.

[0393] Sub-step 1: Determine the execution information of the target task with the target task name based on the retrieval results;

[0394] In this sub-step, the system will go through each task in the "initial task flow" and match the corresponding details from the "search result" according to its name, thus "determining" the final "execution information" for each task. It is an information integration and preparation phase.

[0395] Processing logic:

[0396] 1.1 For T1: Create a box: extract its function_call (cad_api.create_box), parameters (including default values length=10.0, width=5.0, height=2.0, insert_point=[0,0,0]), plugin_id (CAD_Plugin_v1), and its output_provides from the search result.

[0397] 1.2 For T2: Mesh: extract function_call (mesh_api.generate_mesh). For parameters, geometry_id is identified as referencing the output model_id of T1; other parameters use default values. Extract plugin_id and output_provides.

[0398] 1.3 For T3: Submit simulation job: extract function_call (solver_api.submit_job). Parameter model_id references the output meshed_model_id of T2; solver_type uses default value. Extract plugin_id and output_provides.

[0399] 1.4 For T4: Generate stress plot: extract function_call (post_process_api.plot_stress). Parameter result_file_path references the output result_file_path of T3; plot_type uses default value. Extract plugin_id.

[0400] Determined "execution information" (conceptually, not yet fully formatted):

[0401] This stage produces not a final JSON, but an internal execution object for each task, containing all executable details.

[0402] / / Execution information for T1

[0403] {

[0404] "function":"cad_api.create_box",

[0405] "arguments":{"length":10.0,"width":5.0,"height":2.0,"insert_point":[0,0,0]},

[0406] "plugin_id":"CAD_Plugin_v1"

[0407] }

[0408] / / T2's execution information (including reference handling)

[0409] {

[0410] "function":"mesh_api.generate_mesh",

[0411] "arguments":{"geometry_id":"output_of_T1_model_id","mesh_size":1.0,"element_type":"tetrahedral"},

[0412] "plugin_id":"Meshing_Plugin_v2"

[0413] }

[0414] / / ... and so on, for all tasks

[0415] Sub-step 2: Output the target task flow based on the output format, using the initial task flow and the execution information.

[0416] This is the final encapsulation step. The system fuses the structure of the initial task flow (the second association relation expressing the order of tasks, the dependency relations) with the detailed execution information of each task determined in advance, and organizes it according to the predefined output format, finally generating a "target task flow" that can be directly parsed and executed by external systems.

[0417] Processing logic:

[0418] Iterate through each (user-selected) target task (T1, T2, T3, T4) in the "initial task flow".

[0419] For each target task, extract its id, name, and depends_on, etc. structural information.

[0420] Map the "execution information" (including function_call, parameters, etc.) that is "determined" for this target task to the corresponding fields (e.g. function, arguments, plugin_id) in the output format.

[0421] Process the references in the parameters, converting them into actual resolvable variables or expressions (e.g. convert "output_of_T1_model_id" to "{{tasks.T1.outputs.model_id}}" or pass through internal variables).

[0422] Assemble all information into the final JSON document according to the preset "output format".

[0423] Output example: Target Task Flow - JSON format;

[0424]

[0425]

[0426]

[0427]

[0428] The final JSON document is the "Target Task Flow". It can be directly parsed and executed by an external automation engine (such as Airflow, Prefect, or a custom task scheduler), thereby achieving the automation of the entire CAE simulation analysis.

[0429] In an optional embodiment of the present application, the step of determining the second association relationship between the target task nodes based on the graph data structure comprises:

[0430] Performing multi-hop path query based on the graph data structure to generate a task combination and preconditions of the target task with the target task name;

[0431] Using the task combination and / or the preconditions, determine multiple target paths of the target task with the target task name based on the logical rules defined in the graph data structure;

[0432] The step of creating an initial task flow using the second association relationship comprises:

[0433] Creating an initial task flow using multiple target task names based on the target paths.

[0434] The example of the application can perform a multi-hop path query based on the graph data structure, generate a task combination and a precondition of a target task of the target task name;

[0435] Multi-hop path query: This is a powerful query capability unique to graph databases. It allows the system to discover all possible, indirect, and deep connection paths between nodes in a graph data structure by traversing multiple nodes and edges (i.e., "multi-hop"). For example, starting from a task, querying which data it needs, and which tasks produce these data, and which inputs these tasks need, etc., forming a complete dependency chain.

[0436] Task combination of multiple target tasks: It can be a variety of different sequences or sets of target tasks that may exist to achieve a specific function or achieve a certain intermediate target. For example, "preparing a model" can be achieved by "importing a geometric model", or by combining "creating a cuboid" and "creating a cylinder".

[0437] Precondition: It refers to the task or data state that must be met before a certain task can be executed. Multi-hop path query can effectively trace back to find all dependent tasks that must be completed before the target task.

[0438] Purpose:

[0439] Explore the solution space: Through multi-hop query, the system can not only find a path, but also explore all possible task combinations to achieve a certain target, providing multiple alternative solutions.

[0440] Comprehensive identification of task dependencies: Ensure that all direct and indirect preconditions are discovered to avoid task execution failure due to missing dependencies.

[0441] Provide input for rule reasoning: The generated task combination and precondition are the basis for the next "logical rule" to reason and optimize.

[0442] Beneficial effects:

[0443] Enhance the flexibility of task flow generation: It can discover multiple implementation paths to meet different user needs or optimization goals.

[0444] Improve the integrity of the task flow: Ensure that all necessary preconditions are identified and considered, reducing omissions.

[0445] Improve the breadth of automated reasoning: Provide a more comprehensive information perspective for subsequent intelligent decision-making.

[0446] The example of the application can use the task combination and / or the precondition to determine a target path of the target task name based on the logical rules defined in the graph data structure;

[0447] Logic rules: Pre-defined and stored in the graph data structure, or business rules, best practices, constraints, or inference patterns associated with the graph data structure. For example, "if data A is missing, perform task X for supplementation; otherwise, perform task Y", "grid quality check must be performed before high-precision simulation", "task A must be successful before task B can be executed", etc.

[0448] Target path: Refers to the most suitable task execution sequence that meets the current goals and constraints based on all possible task combinations and satisfaction of all preconditions, by applying logic rules and / or specific optimization indicators (such as shortest execution time, least resource consumption, lowest cost, highest robustness, etc.).

[0449] Objective:

[0450] Implement intelligent decision and optimization: This is the key step to integrate artificial experience and domain knowledge into automated processes, enabling the system to make intelligent path selection rather than simple connection.

[0451] Ensure that the task flow complies with business rules: The generated task flow must follow the pre-set business logic and operation specifications.

[0452] Improve the quality of task flow: Through optimized selection, ensure that the generated task flow performs best in terms of efficiency, cost, reliability, etc.

[0453] Benefits:

[0454] Generate high-value task flow: The output task flow not only completes the function, but also is "best" practice optimized to meet business goals.

[0455] Improve system reliability: Rule inference can automatically handle complex scenarios and exceptions, making the task flow more robust.

[0456] Reduce manual intervention and review: Automated decision-making reduces dependence on artificial experience.

[0457] Optionally, the step of creating an initial task flow using the second association relationship includes: creating an initial task flow based on the target path using multiple target task names.

[0458] The embodiment of the application arranges and combines the "target task name" in the user's intention according to the order and logic (including parallel, condition, etc.) determined by the "target path" to form a preliminary, structured task execution sequence. This "initial task flow" is the skeleton or blueprint of the final "target task flow", containing the logical relationship of the task, but not yet filling in all the detailed execution parameters and external interface call information.

[0459] Objectives:

[0460] Convert intelligent decisions into structured output: Materialize abstract "target paths" into preliminary task flow structures that can be further processed by the system.

[0461] Prepare for subsequent parameter filling and formatting: Provide a clear and logically correct task sequence framework for detailed execution information retrieved from the graph database to fill in.

[0462] Benefits:

[0463] Automated task sequencing and logical arrangement: No need for manual planning of task execution order and dependency.

[0464] Ensure the logical correctness of the task flow: Based on the "target path" constructed by intelligent selection, ensure the rationality of the process from the source.

[0465] Improve the efficiency of task flow generation: Automatically build a preliminary task flow to speed up the generation speed of the entire process.

[0466] In order for those skilled in the art to better understand the embodiments of the present application, the following will use an example to describe the embodiments of the present application.

[0467] 1. Task knowledge base construction:

[0468] Collect task names and function descriptions in business scenarios, organize them into structured data to form a knowledge base, design a constraint prompt word project, and ensure that the task flow names output by the large model strictly match the task knowledge base. In the CAE simulation process, task names include but are not limited to creating a preprocessing document, opening a preprocessing document, creating a cuboid, etc. The main idea of the constraint prompt word project is to prompt the large model to act as a professional workflow engine to select appropriate tasks from the following tasks to generate DAG according to user requirements, and the output format requires { "workflow": ["create preprocessing document, prompt word does not give parameter, do not write parameter, has parameter, add parameter", "create cuboid, prompt word does not give parameter, do not write parameter, has parameter, add parameter"]}.

[0469] 2. Graph data construction:

[0470] Analyze the association between tasks and functions, parameters, and import graph databases (such as Neo4j) to build attribute graphs. Design API functions, parameter information, implementation plugins, and corresponding parameter names, parameter default values, plugin modules, and plugin names into graph data, query corresponding data according to user prompt words, and assign them to corresponding tasks as additional information for the task.

[0471] 3, the prompt word engineering makes the large model generate the interface task flow: the task flow keyword information, the task information knowledge, the task arrangement template, the user problem requirement and other preset prompt word requirements are summarized as the input of the large model, and the large model realizes the output of the task flow json format document according to the large model input.

[0472] It should be noted that, for the method embodiments, in order to simply describe, they are all described as a series of action combinations, but those skilled in the art should know that the embodiments of the present application are not limited to the order of the described actions, because according to the embodiments of the present application, certain steps can be performed in other order or at the same time. Secondly, those skilled in the art should know that the embodiments described in the specification all belong to preferred embodiments, and the actions involved are not necessarily the necessary of the embodiments of the present application.

[0473] Referring to Figure 2 , a structural block diagram of a task flow generation device provided in the embodiments of the present application is shown, which can specifically include the following modules:

[0474] The business scenario category determination module 201 is configured to determine a business scenario category and determine a standardized task name of the business scenario category;

[0475] The initial task flow creation module 202 is configured to construct a graph data structure through the standardized task name and create an initial task flow based on the graph data structure;

[0476] The target task flow output module 203 is configured to determine an output format and output a target task flow based on the initial task flow and the output format.

[0477] For the device embodiments, since they are basically similar to the method embodiments, the description is relatively simple, and the related parts refer to the part of the method embodiments.

[0478] In addition, the embodiments of the present application also provide an electronic device, as shown in Figure 3 , including a processor 301, a communication interface 302, a memory 303 and a communication bus 304, wherein the processor 301, the communication interface 302 and the memory 303 complete the communication among each other through the communication bus 304,

[0479] The memory 303 is configured to store a computer program;

[0480] The processor 301 is configured to execute the program stored in the memory 303, and realize the task flow generation method in any of the above embodiments;

[0481] The communication bus mentioned above can be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus, etc. The communication bus can be divided into an address bus, a data bus, a control bus, etc. For the convenience of representation, only one thick line is used in the figure, but it does not mean that there is only one bus or one type of bus.

[0482] The communication interface is used for communication between the terminal and other devices.

[0483] The memory can include a Random Access Memory (RAM) and can also include a non-volatile memory, such as at least one disk memory. Optionally, the memory can also be at least one storage device located away from the processor.

[0484] The processor mentioned above can be a general-purpose processor, including a Central Processing Unit (CPU), a Network Processor (NP), etc. It can also be a Digital Signal Processing (DSP), an Application Specific Integrated Circuit (ASIC), a Field-Programmable Gate Array (FPGA) or other programmable logic devices, discrete gates or transistor logic devices, discrete hardware components.

[0485] As shown in FIG. 4, in another embodiment provided by the present application, a computer readable storage medium 401 is also provided, and the computer readable storage medium 401 stores instructions, when the instructions are run on a computer, the computer executes the task flow generation method described in the above embodiment. Figure 4

[0486] The embodiments of the present application are described above in combination with the drawings, but the present application is not limited to the above-mentioned specific embodiments, and the above-mentioned specific embodiments are only illustrative and not restrictive. Those skilled in the art can make many forms under the inspiration of the present application without departing from the purpose of the present application and the scope protected by the claims, and all of them belong to the protection of the present application.

[0487] ​Those skilled in the art can clearly understand the unit and algorithm steps of each example described in combination with the embodiments disclosed in the embodiments of the present application can be realized by electronic hardware or a combination of computer software and electronic hardware. Whether the functions are realized in hardware or software manner depends on the specific application and design constraints of the technical solution. The skilled person can use different methods to realize the described functions for each specific application, but such implementation should not be considered beyond the scope of the present application.

[0488] Those skilled in the art can clearly understand that, for the convenience and brevity of the description, the specific working processes of the above-described system, device and unit can refer to the corresponding processes in the foregoing method embodiments, which will not be repeated here.

[0489] In the embodiments provided in the present application, it should be understood that the disclosed apparatus and method can be implemented in other ways. For example, the apparatus embodiments described above are merely schematic, for example, the division of the units is only a logical function division, and actual implementation can have another division manner, for example, a plurality of units or components can be combined or integrated into another system, or some features can be ignored or not executed. In addition, the coupling or direct coupling or communication connection between the units shown or discussed can be indirect coupling or communication connection through some interfaces, devices or units, which can be electrical, mechanical or other forms.

[0490] The units described as separate components can or can not be physically separated, and the components shown as units can or can not be physical units, that is, they can be located in one place, or can be distributed on a plurality of network units. Part or all of the units can be selected according to actual needs to achieve the purpose of the embodiment.

[0491] In addition, each functional unit in each embodiment of the present application can be integrated into a processing unit, or each unit can exist physically independently, or two or more units can be integrated into one unit.

[0492] If the functions are realized in the form of software function units and sold or used as independent products, they can be stored in a computer readable storage medium. Based on this understanding, the technical solutions of the present application or the parts of the present application that essentially contribute to the prior art or the parts of the technical solutions can be embodied in the form of software products. The computer software product is stored in a storage medium and includes a plurality of instructions for causing a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the method described in the various embodiments of the present application. The aforementioned storage medium includes various storage media that can store program codes, such as a U disk, a mobile hard disk, a ROM, a RAM, a magnetic disk or an optical disk.

[0493] The above is only a specific implementation of the present application, but the protection scope of the present application is not limited thereto. Any person skilled in the art can easily think of changes or replacements within the technical range disclosed by the present application, which should be covered within the protection scope of the present application. Therefore, the protection scope of the present application should be subject to the protection scope of the claims.

Claims

1. A task flow generation method characterized by comprising: The method comprises: determining a business scenario category and determining a standardized task name of the business scenario category; constructing a graph data structure through the standardized task name, creating an initial task flow based on the graph data structure; determining an output format, and outputting a target task flow based on the output format using the initial task flow.

2. The method of claim 1, wherein, Further comprising: generating function description information for the standardized task name; a plurality of the standardized task names correspond to a plurality of the function description information one by one; constructing a task name list using the standardized task name and the function description information; the task name list is used to store the standardized task name and the function description information corresponding to the business scenario category.

3. The method of claim 2, wherein, The method is applied to a task flow generation system configured with a user interaction interface, the user interaction interface is configured to display the task name list, and the method further comprises: displaying prompt information for guiding the user to use the task name list through the user interaction interface.

4. The method of claim 3, wherein, The step of constructing a graph data structure through the standardized task name, and creating an initial task flow based on the graph data structure comprises: determining a task node and a first association relationship of the task node through the standardized task name; constructing a graph data structure based on the task node and the first association relationship; in response to listening to the user selecting a target task name in the standardized task name of the task name list through the prompt information, determining a second association relationship between the target task nodes through the graph data structure; creating an initial task flow using the second association relationship.

5. The method of claim 4, wherein, Further comprising: creating a graph database knowledge base based on the graph data structure; outputting a retrieval result for the initial task flow based on the second association relationship using the graph database knowledge base.

6. The method of claim 5, wherein, The step of outputting a target task flow based on the output format using the initial task flow comprises: determining execution information of a target task of the target task name based on the retrieval result; outputting a target task flow based on the output format using the initial task flow and the execution information.

7. The method of claim 4, wherein, The step of determining a second association relationship between the target task nodes through the graph data structure comprises: performing a multi-hop path query based on the graph data structure, generating a task combination and a precondition of a target task of the target task name; determining a target path of a plurality of the target task names based on a logical rule defined in the graph data structure using the task combination and / or the precondition; The step of creating an initial task flow using the second association relationship comprises: creating an initial task flow based on the target path using a plurality of the target task names.

8. A task flow generation apparatus characterized by comprising: The method comprises: a business scenario category determination module for determining a business scenario category and determining a standardized task name of the business scenario category; an initial task flow creation module for constructing a graph data structure through the standardized task name, and creating an initial task flow based on the graph data structure; a target task flow output module for determining an output format, and outputting a target task flow based on the output format using the initial task flow.

9. An electronic device, comprising: comprising a processor, a communication interface, a memory and a communication bus, wherein the processor, the communication interface and the memory accomplish mutual communication through the communication bus; the memory, configured to store a computer program; the processor, configured to execute the program stored on the memory, so as to realize the method in any one of claims 1-7.

10. A computer readable storage medium having stored thereon instructions which, when executed by one or more processors, cause the processors to perform the method of any one of claims 1-7.

Images