Business process construction method and system based on process engine

Abstract

The invention discloses a business process construction method and system based on a process engine, belongs to the technical field of business process automation, and aims to solve the technical problem of how to realize intelligent generation, dynamic adjustment and one-key deployment of a business process. Comprising the steps of performing semantic analysis on a demand document uploaded by a user based on an AI large model, generating a process framework based on a key business entity, a business rule and a process node, and outputting a process definition file; based on a natural language interaction mechanism, calling the large model to perform semantic analysis on a natural language instruction input by a user, and correcting the process framework based on an analysis result; integrating the corrected process definition file to a process engine, and performing automatic verification and simulation operation on a process framework; and realizing version management, containerized packaging and one-key release of the process based on an automatic deployment assembly line.

Description

Technical Field

[0001] This invention relates to the field of business process automation technology, specifically to a business process construction method and system based on a process engine. Background Technology

[0002] In the current software development environment, business process construction mainly relies on developers manually writing process code or configuring complex rule engines. However, this approach has many shortcomings:

[0003] (1) Low development efficiency: Traditional process design requires developers to have a deep understanding of the syntax rules of the underlying engine, which not only leads to a long development cycle, but also makes it easy to make mistakes in the process of writing code;

[0004] (2) Poor flexibility in adjustment: Once business requirements change, a large amount of code often needs to be rewritten, lacking the ability to dynamically adjust processes and making it difficult to adapt to changes quickly;

[0005] (3) High collaboration threshold: It is difficult for non-technical personnel to participate directly in the process design work, which greatly increases the communication cost between different roles and affects the efficiency of project progress;

[0006] (4) Deployment relies on manual labor: The testing, deployment and version management of the process have not been automated to the end, and they rely too much on manual operation, which is not only inefficient, but also prone to various errors.

[0007] Although existing BPMN tools provide visual design interfaces, in actual use, it is still necessary to manually configure node attributes and logical relationships, and they cannot directly generate executable processes based on the requirements described in natural language.

[0008] The technical problem that needs to be solved is how to achieve intelligent generation, dynamic adjustment, and one-click deployment of business processes. Summary of the Invention

[0009] The technical objective of this invention is to address the above-mentioned shortcomings by providing a business process construction method and system based on a process engine, thereby solving the technical problems of how to achieve intelligent generation, dynamic adjustment, and one-click deployment of business processes.

[0010] In a first aspect, the present invention provides a business process construction method based on a process engine, comprising the following steps:

[0011] Requirements Analysis: Based on the AI ​​big data model, semantic analysis is performed on the user-uploaded requirements documents to extract key business entities, business rules and process nodes. Based on the key business entities, business rules and process nodes, a process framework is generated and a process definition file is output.

[0012] Conversational process modification: Based on the natural language interaction mechanism, the large model is invoked to perform semantic parsing of the natural language commands input by the user, and the process framework is modified based on the parsing results to obtain the modified process definition file;

[0013] Process Engine Integration: Integrate the revised process definition file into the process engine, and use the process engine's built-in verification tools to automatically verify and simulate the process framework.

[0014] Deployment Management: Integrate CI / CD toolchain to build automated deployment pipelines, and realize version management, containerized packaging, and one-click release based on automated deployment pipelines.

[0015] As a preferred approach, requirements analysis includes the following steps:

[0016] Multi-source document preprocessing: For user-uploaded requirement documents, tools including Apache Tika are used to parse the requirement documents, extract chapter structures and key paragraphs, perform OCR recognition and structured processing on non-text content including tables and icons in the requirement documents, extract data and convert it into JSON format, and perform sentence segmentation and semantic annotation on the requirement documents based on pre-trained models to generate a text stream with semantic tags.

[0017] Business Entity and Rule Extraction: Key business entities are extracted from the requirements document based on named entity recognition technology, and the relationships between key business entities are constructed through a relation extraction model. Business rules are identified based on regular expressions and domain dictionaries and transformed into conditional expressions that the process engine can recognize. The LSTM-CRF model is used to classify process node types and identify activity nodes, gateway nodes, and event nodes.

[0018] Process framework generation: Based on the process engine, the extracted key business entities, business rules and process nodes are mapped to standard process elements. A process node dependency graph is constructed through a graph neural network to generate an initial process framework with serial, parallel or branch structure. The output is a process definition file containing node ID, name, type and condition expression. The process definition file is an XML file and a visual flowchart is generated for users to preview.

[0019] Intelligent completion and verification: Based on the historical process template library, missing process elements are completed, and the built-in verification tool is invoked to check the syntax compliance of the process model.

[0020] As a preferred approach, the modification of the conversational process includes the following steps:

[0021] Multimodal instruction parsing: Semantic parsing of user-input natural language instructions using a large language model to extract operation type, target node, and related nodes;

[0022] Intent recognition and operation mapping: Construct a domain intent classifier, analyze user intent based on contextual understanding of natural language commands input by users, and map user intent to API operations of the process engine;

[0023] Process Modification and Visualization: Based on the DOM manipulation interface of BPMN 2.0, the process model is dynamically modified. The modifications include inserting new nodes and adjusting the node order, and real-time verification is triggered. The process changes are synchronously displayed on the front-end interface through the React Flow visualization library. Users can adjust them in real time by dragging and dropping nodes or editing attributes.

[0024] Version Management and Rollback: Correction operations generate new process versions, record modification time, operator, and changes, support version comparison and one-click rollback, adopt a Git-like version control mechanism, and support branch management and merging strategies.

[0025] As a preferred approach, process engine integration includes the following steps:

[0026] Standardized format conversion: Convert the revised process definition file into the native format of the process engine, process engine-specific attributes through XSLT templates, and generate the microservice interfaces and database scripts required by the process engine;

[0027] Verification and Simulation: The built-in verification tools of the process engine are invoked to check the syntax compliance of the process model, unit test cases are generated based on the JUnit framework, and the process instance is simulated to verify the correctness of the business logic.

[0028] Parameterized configuration and environment adaptation: Configure process variables and user roles through YAML or JSON files, automatically detect the version compatibility of the target engine, and generate adaptation code.

[0029] As a preferred option, deployment management includes the following steps: configuring exception handling strategies for each process node and generating corresponding event listeners, integrating Prometheus and Grafana, automatically collecting runtime metrics of process instances, and generating visual monitoring reports.

[0030] Secondly, the present invention provides a business process construction system based on a process engine, including a requirement parsing module, a conversational process correction module, a process engine integration module, and a deployment management module.

[0031] The requirements analysis module is used to perform the following operations: perform semantic analysis on the user-uploaded requirements documents based on the AI ​​big data model, extract key business entities, business rules and process nodes, generate a process framework based on key business entities, business rules and process nodes, and output the process definition file;

[0032] The conversational process correction module is used to perform the following operations: based on the natural language interaction mechanism, it calls a large model to perform semantic parsing of the natural language commands input by the user, and corrects the process framework based on the parsing results to obtain the corrected process definition file;

[0033] The process engine integration module is used to perform the following operations: integrate the revised process definition file into the process engine, and automatically verify and simulate the process framework through the process engine's built-in verification tools;

[0034] The deployment management module is used to perform the following operations: integrate CI / CD toolchain, build automated deployment pipeline, and implement version management, containerized packaging, and one-click release based on the automated deployment pipeline.

[0035] As a preferred option, the requirements parsing module is used to perform the following operations:

[0036] Multi-source document preprocessing: For user-uploaded requirement documents, tools including Apache Tika are used to parse the requirement documents, extract chapter structures and key paragraphs, perform OCR recognition and structured processing on non-text content including tables and icons in the requirement documents, extract data and convert it into JSON format, and perform sentence segmentation and semantic annotation on the requirement documents based on pre-trained models to generate a text stream with semantic tags.

[0037] Business Entity and Rule Extraction: Key business entities are extracted from the requirements document based on named entity recognition technology, and the relationships between key business entities are constructed through a relation extraction model. Business rules are identified based on regular expressions and domain dictionaries and transformed into conditional expressions that the process engine can recognize. The LSTM-CRF model is used to classify process node types and identify activity nodes, gateway nodes, and event nodes.

[0038] Process framework generation: Based on the process engine, the extracted key business entities, business rules and process nodes are mapped to standard process elements. A process node dependency graph is constructed through a graph neural network to generate an initial process framework with serial, parallel or branch structure. The output is a process definition file containing node ID, name, type and condition expression. The process definition file is an XML file and a visual flowchart is generated for users to preview.

[0039] Intelligent completion and verification: Based on the historical process template library, missing process elements are completed, and the built-in verification tool is invoked to check the syntax compliance of the process model.

[0040] As a preferred option, the conversational process correction module is used to perform the following operations:

[0041] Multimodal instruction parsing: Semantic parsing of user-input natural language instructions using a large language model to extract operation type, target node, and related nodes;

[0042] Intent recognition and operation mapping: Construct a domain intent classifier, analyze user intent based on contextual understanding of natural language commands input by users, and map user intent to API operations of the process engine;

[0043] Process Modification and Visualization: Based on the DOM manipulation interface of BPMN 2.0, the process model is dynamically modified. The modifications include inserting new nodes and adjusting the node order, and real-time verification is triggered. The process changes are synchronously displayed on the front-end interface through the React Flow visualization library. Users can adjust them in real time by dragging and dropping nodes or editing attributes.

[0044] Version Management and Rollback: Correction operations generate new process versions, record modification time, operator, and changes, support version comparison and one-click rollback, adopt a Git-like version control mechanism, and support branch management and merging strategies.

[0045] Preferably, the process engine integration module is used to perform the following operations:

[0046] Standardized format conversion: Convert the revised process definition file into the native format of the process engine, process engine-specific attributes through XSLT templates, and generate the microservice interfaces and database scripts required by the process engine;

[0047] Verification and Simulation: The built-in verification tools of the process engine are invoked to check the syntax compliance of the process model, unit test cases are generated based on the JUnit framework, and the process instance is simulated to verify the correctness of the business logic.

[0048] Parameterized configuration and environment adaptation: Configure process variables and user roles through YAML or JSON files, automatically detect the version compatibility of the target engine, and generate adaptation code.

[0049] Preferably, the deployment management module is used to perform the following operations: configure exception handling strategies for each process node, generate corresponding event listeners, integrate Prometheus and Grafana, automatically collect the running metrics of process instances, and generate visual monitoring reports.

[0050] The business process construction method and system based on a process engine of the present invention have the following advantages:

[0051] 1. Improved efficiency in business process development, significantly reducing manual coding workload;

[0052] 2. It supports non-technical personnel to participate in process design through natural language, which lowers the threshold for collaboration and improves collaboration efficiency;

[0053] 3. The deployment cycle is shortened to minutes, the error rate is reduced, and the stability and reliability of the system are significantly improved;

[0054] 4. The AI-based dynamic adjustment mechanism improves the speed of process iteration response and enhances the agility of the business system. Attached Figure Description

[0055] To more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0056] The invention will be further described below with reference to the accompanying drawings.

[0057] Figure 1 This is a flowchart of a business process construction method based on a process engine, as shown in Example 1. Detailed Implementation

[0058] The present invention will be further described below with reference to the accompanying drawings and specific embodiments, so that those skilled in the art can better understand and implement the present invention. However, the embodiments are not intended to limit the present invention. In the absence of conflict, the embodiments of the present invention and the technical features in the embodiments can be combined with each other.

[0059] This invention provides a business process construction method and system based on a process engine, which solves the technical problems of how to achieve intelligent generation, dynamic adjustment and one-click deployment of business processes.

[0060] Example 1:

[0061] This invention provides a business process construction method based on a process engine, comprising four steps: requirement analysis, conversational process modification, process engine integration, and deployment management.

[0062] Step S100 Requirements Analysis: Based on the AI ​​big data model, perform semantic analysis on the user-uploaded requirements document, extract key business entities, business rules, and process nodes, generate a process framework based on the key business entities, business rules, and process nodes, and output the process definition file.

[0063] As a specific implementation of requirements analysis, this step includes the following operations:

[0064] (1) Multi-source document preprocessing: For user-uploaded requirement documents (supporting Word, Markdown, PDF and other formats), the requirement documents are parsed using tools including Apache Tika, the chapter structure and key paragraphs are extracted, and the non-text content including tables and icons in the requirement documents is OCR recognized and structured. The data is extracted and converted into JSON format. Based on the pre-trained model, the requirement documents are segmented and semantically annotated to generate a text stream with semantic tags.

[0065] (2) Business Entity and Rule Extraction: Based on Named Entity Recognition (NER) technology, key business entities (such as "Purchase Request Form" and "Department Manager") are extracted from the requirements document. The relationship between key business entities is constructed through the relation extraction model (such as "Department Manager Approves Purchase Request Form"). Business rules (such as "Multi-level approval is required for amounts exceeding 100,000 yuan") are identified based on regular expressions and domain dictionaries and transformed into conditional expressions that the process engine can recognize (such as amount>100000). The LSTM-CRF model is used to classify process node types and identify activity nodes (such as "Submit Application"), gateway nodes (such as "Conditional Branch"), and event nodes (such as "Timeout Event").

[0066] (3) Process framework generation: Based on the process engine, the extracted key business entities, business rules and process nodes are mapped to standard process elements (such as "process start", "approval" and "end"). The process node dependency graph is constructed through graph neural network (GNN) to generate an initial process framework with serial, parallel or branch structure. The output is a process definition file containing node ID, name, type and condition expression. The process definition file is an XML file and a visual flowchart is generated for users to preview.

[0067] (4) Intelligent completion and verification: Based on the historical process template library (such as standard processes such as procurement and reimbursement), missing process elements are completed (such as automatically adding the "process end" node), and the built-in verification tool is called to check the grammatical compliance of the process model (such as the uniqueness of node ID and the integrity of connection).

[0068] Step S200: Dialogue-based process correction: Based on the natural language interaction mechanism, the large model is invoked to perform semantic parsing of the natural language commands input by the user, and the process framework is corrected based on the parsing results to obtain the corrected process definition file.

[0069] As a specific implementation of the dialogic process modification, this step includes the following operations:

[0070] (1) Multimodal instruction parsing: Semantic parsing of natural language instructions input by users (such as "add financial audit after purchase application") through a large language model, extracting operation type (such as "add" "delete"), target node (such as "purchase application") and related node (such as "financial audit");

[0071] (2) Intent recognition and operation mapping: Construct a domain intent classifier (such as "add node", "modify condition", "adjust branch"), perform user intent analysis on natural language instructions input by users based on context understanding (such as when the user says "optimize process", the system automatically recommends parallel branch optimization scheme), and map user intent to API operations of the process engine (such as adding user task node is mapped to addUserTask, modifying condition expression is mapped to updateConditionExpression);

[0072] (3) Process modification and visualization: Based on the DOM operation interface of BPMN 2.0, the process model is dynamically modified. The modification includes inserting new nodes and adjusting the node order, and triggering real-time verification (such as checking whether the new node conflicts with the existing node). The process changes are synchronously displayed on the front-end interface through the React Flow visualization library. Users can adjust them in real time by dragging and dropping nodes or editing attributes.

[0073] (4) Version Management and Rollback: Correction operations generate new process versions, record modification time, operator, and changes, support version comparison and one-click rollback, adopt Git-like version control mechanism, and support branch management (such as development branches and test branches) and merging strategies.

[0074] Step S300: Process Engine Integration: Integrate the revised process definition file into the process engine, and use the process engine's built-in verification tools to automatically verify and simulate the process framework.

[0075] As a specific implementation of process engine integration, this step includes the following operations:

[0076] (1) Standardized format conversion: Convert the revised process definition file into the native format of the process engine, process engine-specific attributes through XSLT templates, generate microservice interfaces and database scripts required by the process engine, and support mainstream development frameworks such as SpringBoot and Node.js;

[0077] (2) Verification and simulation: Call the built-in verification tool of the process engine to check the syntax compliance of the process model (such as the uniqueness of node ID and the integrity of connection), generate unit test cases based on the JUnit framework (such as simulating scenarios such as "approval passed" and "amount exceeded"), and execute the simulation of the process instance to verify the correctness of the business logic.

[0078] (3) Parameterized configuration and environment adaptation: Configure process variables and user roles through YAML or JSON files to achieve "one-time modeling and reuse in multiple environments", automatically detect the version compatibility of the target engine and generate adaptation code.

[0079] Step S400 Deployment Management: Integrate the CI / CD toolchain, build an automated deployment pipeline, and realize version management, containerized packaging, and one-click release based on the automated deployment pipeline.

[0080] This embodiment integrates a CI / CD toolchain to build an automated deployment pipeline, enabling version management, automated testing, containerized packaging, and one-click deployment to the cloud environment. This step significantly reduces manual intervention, shortens the deployment cycle, and lowers the error rate. An exception handling strategy is configured for each process node, and a corresponding event listener is generated. Prometheus and Grafana are integrated to automatically collect runtime metrics of the process instances and generate visual monitoring reports.

[0081] This embodiment's method, by combining AI large-scale model tools, allows developers to upload requirement documents and adjust process logic through natural language dialogue interaction, automatically generating process definition files that meet business requirements, and achieving automated deployment and release of the process. The technical solution includes intelligent parsing of requirement documents, a dialogue-based dynamic process correction mechanism, seamless integration of the process engine, and deployment pipeline design. This invention solves the problems of low efficiency and poor adjustment flexibility in traditional process construction, significantly improving the efficiency and flexibility of business process construction, lowering the development threshold, and enhancing the agility and maintainability of business systems.

[0082] Example 2:

[0083] This invention discloses a business process construction system based on a process engine, comprising a requirement parsing module, a conversational process correction module, a process engine integration module, and a deployment management module.

[0084] The requirements parsing module performs the following operations: it performs semantic analysis on the user-uploaded requirements documents based on the AI ​​big data model, extracts key business entities, business rules and process nodes, generates a process framework based on the key business entities, business rules and process nodes, and outputs a process definition file.

[0085] As a specific implementation of the requirements analysis module, this module is used to perform the following operations:

[0086] (1) Multi-source document preprocessing: For user-uploaded requirement documents (supporting Word, Markdown, PDF and other formats), the requirement documents are parsed using tools including Apache Tika, the chapter structure and key paragraphs are extracted, and the non-text content including tables and icons in the requirement documents is OCR recognized and structured. The data is extracted and converted into JSON format. Based on the pre-trained model, the requirement documents are segmented and semantically annotated to generate a text stream with semantic tags.

[0087] (2) Business Entity and Rule Extraction: Based on Named Entity Recognition (NER) technology, key business entities (such as "Purchase Request Form" and "Department Manager") are extracted from the requirements document. The relationship between key business entities is constructed through the relation extraction model (such as "Department Manager Approves Purchase Request Form"). Business rules (such as "Multi-level approval is required for amounts exceeding 100,000 yuan") are identified based on regular expressions and domain dictionaries and transformed into conditional expressions that the process engine can recognize (such as amount>100000). The LSTM-CRF model is used to classify process node types and identify activity nodes (such as "Submit Application"), gateway nodes (such as "Conditional Branch"), and event nodes (such as "Timeout Event").

[0088] (3) Process framework generation: Based on the process engine, the extracted key business entities, business rules and process nodes are mapped to standard process elements (such as "process start", "approval" and "end"). The process node dependency graph is constructed through graph neural network (GNN) to generate an initial process framework with serial, parallel or branch structure. The output is a process definition file containing node ID, name, type and condition expression. The process definition file is an XML file and a visual flowchart is generated for users to preview.

[0089] (4) Intelligent completion and verification: Based on the historical process template library (such as standard processes such as procurement and reimbursement), missing process elements are completed (such as automatically adding the "process end" node), and the built-in verification tool is called to check the grammatical compliance of the process model (such as the uniqueness of node ID and the integrity of connection).

[0090] The conversational process correction module performs the following operations: based on the natural language interaction mechanism, it calls a large model to perform semantic parsing of the natural language commands input by the user, corrects the process framework based on the parsing results, and obtains the corrected process definition file.

[0091] As a specific implementation of the conversational process correction module, this module is used to perform the following operations:

[0092] (1) Multimodal instruction parsing: Semantic parsing of natural language instructions input by users (such as "add financial audit after purchase application") through a large language model, extracting operation type (such as "add" "delete"), target node (such as "purchase application") and related node (such as "financial audit");

[0093] (2) Intent recognition and operation mapping: Construct a domain intent classifier (such as "add node", "modify condition", "adjust branch"), perform user intent analysis on natural language instructions input by users based on context understanding (such as when the user says "optimize process", the system automatically recommends parallel branch optimization scheme), and map user intent to API operations of the process engine (such as adding user task node is mapped to addUserTask, modifying condition expression is mapped to updateConditionExpression);

[0094] (3) Process modification and visualization: Based on the DOM operation interface of BPMN 2.0, the process model is dynamically modified. The modification includes inserting new nodes and adjusting the node order, and triggering real-time verification (such as checking whether the new node conflicts with the existing node). The process changes are synchronously displayed on the front-end interface through the React Flow visualization library. Users can adjust them in real time by dragging and dropping nodes or editing attributes.

[0095] (4) Version Management and Rollback: Correction operations generate new process versions, record modification time, operator, and changes, support version comparison and one-click rollback, adopt Git-like version control mechanism, and support branch management (such as development branches and test branches) and merging strategies.

[0096] The process engine integration module is used to perform the following operations: integrate the revised process definition file into the process engine, and automatically verify and simulate the process framework through the process engine's built-in verification tools.

[0097] As a specific implementation of the process engine integration module, this module is used to perform the following operations:

[0098] (1) Standardized format conversion: Convert the revised process definition file into the native format of the process engine, process engine-specific attributes through XSLT templates, generate microservice interfaces and database scripts required by the process engine, and support mainstream development frameworks such as SpringBoot and Node.js;

[0099] (2) Verification and simulation: Call the built-in verification tool of the process engine to check the syntax compliance of the process model (such as the uniqueness of node ID and the integrity of connection), generate unit test cases based on the JUnit framework (such as simulating scenarios such as "approval passed" and "amount exceeded"), and execute the simulation of the process instance to verify the correctness of the business logic.

[0100] (3) Parameterized configuration and environment adaptation: Configure process variables and user roles through YAML or JSON files to achieve "one-time modeling and reuse in multiple environments", automatically detect the version compatibility of the target engine and generate adaptation code.

[0101] The deployment management module is used to perform the following operations: integrate CI / CD toolchain, build automated deployment pipeline, and implement version management, containerized packaging, and one-click release based on the automated deployment pipeline.

[0102] This embodiment integrates a CI / CD toolchain to build an automated deployment pipeline, enabling version management, automated testing, containerized packaging, and one-click deployment to cloud environments. This step significantly reduces manual intervention, shortens the deployment cycle, and lowers the error rate. An exception handling strategy is configured for each process node, and a corresponding event listener is generated. Prometheus and Grafana are integrated to automatically collect runtime metrics of process instances and generate visual monitoring reports.

[0103] The system in this embodiment can execute the method disclosed in Embodiment 1 to construct a business process.

[0104] The above provides a detailed description of the business process construction method and system based on the process engine provided by this invention. Specific examples have been used to illustrate the principles and implementation methods of this invention. The descriptions of the above embodiments are only for the purpose of helping to understand the method and core ideas of this invention. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of this invention. Therefore, the content of this specification should not be construed as a limitation of this invention.

Claims

1. A business process construction method based on a process engine, characterized in that, Includes the following steps: Requirements Analysis: Based on the AI ​​big data model, semantic analysis is performed on the user-uploaded requirements documents to extract key business entities, business rules and process nodes. Based on the key business entities, business rules and process nodes, a process framework is generated and a process definition file is output. Conversational process modification: Based on the natural language interaction mechanism, the large model is invoked to perform semantic parsing of the natural language commands input by the user, and the process framework is modified based on the parsing results to obtain the modified process definition file; Process Engine Integration: Integrate the revised process definition file into the process engine, and use the process engine's built-in verification tools to automatically verify and simulate the process framework. Deployment Management: Integrate CI / CD toolchain to build automated deployment pipelines, and realize version management, containerized packaging, and one-click release based on automated deployment pipelines.

2. The business process construction method based on a process engine according to claim 1, characterized in that, Requirements analysis includes the following steps: Multi-source document preprocessing: For user-uploaded requirement documents, tools including Apache Tika are used to parse the requirement documents, extract chapter structures and key paragraphs, perform OCR recognition and structured processing on non-text content including tables and icons in the requirement documents, extract data and convert it into JSON format, and perform sentence segmentation and semantic annotation on the requirement documents based on pre-trained models to generate a text stream with semantic tags. Business Entity and Rule Extraction: Key business entities are extracted from the requirements document based on named entity recognition technology, and the relationships between key business entities are constructed through a relation extraction model. Business rules are identified based on regular expressions and domain dictionaries and transformed into conditional expressions that the process engine can recognize. The LSTM-CRF model is used to classify process node types and identify activity nodes, gateway nodes, and event nodes. Process framework generation: Based on the process engine, the extracted key business entities, business rules and process nodes are mapped to standard process elements. A process node dependency graph is constructed through a graph neural network to generate an initial process framework with serial, parallel or branch structure. The output is a process definition file containing node ID, name, type and condition expression. The process definition file is an XML file and a visual flowchart is generated for users to preview. Intelligent completion and verification: Based on the historical process template library, missing process elements are completed, and the built-in verification tool is invoked to check the syntax compliance of the process model.

3. The business process construction method based on a process engine according to claim 1, characterized in that, The modification of the conversational process includes the following steps: Multimodal instruction parsing: Semantic parsing of user-input natural language instructions using a large language model to extract operation type, target node, and related nodes; Intent recognition and operation mapping: Construct a domain intent classifier, analyze user intent based on contextual understanding of natural language commands input by users, and map user intent to API operations of the process engine; Process Modification and Visualization: Based on the DOM manipulation interface of BPMN 2.0, the process model is dynamically modified. The modifications include inserting new nodes and adjusting the node order, and real-time verification is triggered. The process changes are synchronously displayed on the front-end interface through the React Flow visualization library. Users can adjust them in real time by dragging and dropping nodes or editing attributes. Version Management and Rollback: Correction operations generate new process versions, record modification time, operator, and changes, support version comparison and one-click rollback, adopt a Git-like version control mechanism, and support branch management and merging strategies.

4. The business process construction method based on a process engine according to claim 1, characterized in that, Process engine integration includes the following steps: Standardized format conversion: Convert the revised process definition file into the native format of the process engine, process engine-specific attributes through XSLT templates, and generate the microservice interfaces and database scripts required by the process engine; Verification and Simulation: The built-in verification tools of the process engine are invoked to check the syntax compliance of the process model, unit test cases are generated based on the JUnit framework, and the process instance is simulated to verify the correctness of the business logic. Parameterized configuration and environment adaptation: Configure process variables and user roles through YAML or JSON files, automatically detect the version compatibility of the target engine, and generate adaptation code.

5. The business process construction method based on a process engine according to claim 1, characterized in that, Deployment management includes the following steps: configuring exception handling strategies for each process node and generating corresponding event listeners, integrating Prometheus and Grafana, automatically collecting runtime metrics of process instances, and generating visual monitoring reports.

6. A business process construction system based on a process engine, characterized in that, It includes a requirements analysis module, a conversational process modification module, a process engine integration module, and a deployment management module; The requirements analysis module is used to perform the following operations: perform semantic analysis on the user-uploaded requirements documents based on the AI ​​big data model, extract key business entities, business rules and process nodes, generate a process framework based on key business entities, business rules and process nodes, and output the process definition file; The conversational process correction module is used to perform the following operations: based on the natural language interaction mechanism, it calls a large model to perform semantic parsing of the natural language commands input by the user, and corrects the process framework based on the parsing results to obtain the corrected process definition file; The process engine integration module is used to perform the following operations: integrate the revised process definition file into the process engine, and automatically verify and simulate the process framework through the process engine's built-in verification tools; The deployment management module is used to perform the following operations: integrate CI / CD toolchain, build automated deployment pipeline, and implement version management, containerized packaging, and one-click release based on the automated deployment pipeline.

7. The business process construction system based on a process engine according to claim 6, characterized in that, The requirements analysis module is used to perform the following operations: Multi-source document preprocessing: For user-uploaded requirement documents, tools including Apache Tika are used to parse the requirement documents, extract chapter structures and key paragraphs, perform OCR recognition and structured processing on non-text content including tables and icons in the requirement documents, extract data and convert it into JSON format, and perform sentence segmentation and semantic annotation on the requirement documents based on pre-trained models to generate a text stream with semantic tags. Business Entity and Rule Extraction: Key business entities are extracted from the requirements document based on named entity recognition technology, and the relationships between key business entities are constructed through a relation extraction model. Business rules are identified based on regular expressions and domain dictionaries and transformed into conditional expressions that the process engine can recognize. The LSTM-CRF model is used to classify process node types and identify activity nodes, gateway nodes, and event nodes. Process framework generation: Based on the process engine, the extracted key business entities, business rules and process nodes are mapped to standard process elements. A process node dependency graph is constructed through a graph neural network to generate an initial process framework with serial, parallel or branch structure. The output is a process definition file containing node ID, name, type and condition expression. The process definition file is an XML file and a visual flowchart is generated for users to preview. Intelligent completion and verification: Based on the historical process template library, missing process elements are completed, and the built-in verification tool is invoked to check the syntax compliance of the process model.

8. The business process construction system based on a process engine according to claim 6, characterized in that, The dialogic process correction module is used to perform the following operations: Multimodal instruction parsing: Semantic parsing of user-input natural language instructions using a large language model to extract operation type, target node, and related nodes; Intent recognition and operation mapping: Construct a domain intent classifier, analyze user intent based on contextual understanding of natural language commands input by users, and map user intent to API operations of the process engine; Process Modification and Visualization: Based on the DOM manipulation interface of BPMN 2.0, the process model is dynamically modified. The modifications include inserting new nodes and adjusting the node order, and real-time verification is triggered. The process changes are synchronously displayed on the front-end interface through the React Flow visualization library. Users can adjust them in real time by dragging and dropping nodes or editing attributes. Version Management and Rollback: Correction operations generate new process versions, record modification time, operator, and changes, support version comparison and one-click rollback, adopt a Git-like version control mechanism, and support branch management and merging strategies.

9. The business process construction system based on a process engine according to claim 6, characterized in that, The process engine integration module is used to perform the following operations: Standardized format conversion: Convert the revised process definition file into the native format of the process engine, process engine-specific attributes through XSLT templates, and generate the microservice interfaces and database scripts required by the process engine; Verification and Simulation: The built-in verification tools of the process engine are invoked to check the syntax compliance of the process model, unit test cases are generated based on the JUnit framework, and the process instance is simulated to verify the correctness of the business logic. Parameterized configuration and environment adaptation: Configure process variables and user roles through YAML or JSON files, automatically detect the version compatibility of the target engine, and generate adaptation code.

10. The business process construction system based on a process engine according to claim 6, characterized in that, The deployment management module is used to perform the following operations: configure exception handling strategies for each process node and generate corresponding event listeners, integrate Prometheus and Grafana, automatically collect the running metrics of process instances, and generate visual monitoring reports.

Images