A visual intelligent process assembly system and method for heterogeneous service capabilities

Abstract

The application relates to the technical field of intelligent process assembly, in particular to a visual intelligent process assembly system and method for heterogeneous business capabilities. The visual intelligent process assembly system for the heterogeneous business capabilities integrates a visual designer, a standardized heterogeneous capability component library, a unified metadata model and a bidirectional real-time synchronization engine, so that business personnel can visually drag and assemble a complex business process fused with advanced technologies such as RPA and AI without coding, while ensuring strict real-time synchronization between the graphical design and the underlying executable code, thereby completely breaking the barrier between business requirements and IT implementation and greatly reducing the construction threshold and maintenance cost of the intelligent process.

Description

Technical Field

[0001] This invention relates to the field of intelligent process assembly technology, and in particular to a visual intelligent process assembly system for heterogeneous business capabilities, a component encapsulation method based on the visual intelligent process assembly system, and a process assembly method. Background Technology

[0002] Currently, enterprise digital transformation has entered a more complex phase, with business departments increasingly demanding and fragmented personalized, agile process automation. Traditional software development models, due to their lengthy cycles, high costs, and specialized coding barriers, struggle to meet these needs. Although Robotic Process Automation (RPA) tools and various low-code / no-code systems have emerged in the market to lower the technical barriers to automation implementation, they still have significant limitations in practical applications.

[0003] Existing RPA tools primarily focus on simulating user operations on graphical user interfaces, and their capabilities are typically limited to repetitive tasks with well-defined rules and stable interfaces. When business processes need to incorporate intelligent decision-making, complex data analysis, or calls to diverse backend services, relying solely on RPA falls short. On the other hand, mainstream low-code systems mostly focus on the rapid construction of forms, reports, and simple workflows. Their pre-built component libraries are often geared towards general information management scenarios, lacking deep encapsulation and integration support for complex and heterogeneous capabilities within enterprises, such as artificial intelligence models, dedicated APIs, and legacy system interfaces. This prevents business personnel from independently building intelligent processes that integrate advanced technologies, even without coding skills, due to the lack of suitable business building blocks.

[0004] A deeper challenge lies in the disconnect between development and maintenance. Many visualization tools generate unreadable or difficult-to-edit black-box process packages. Once business logic needs adjustment or optimization, maintenance personnel often have to redesign or delve into the generated code, which is difficult to understand, leading to a significant maintenance burden and knowledge loss. A new collaboration gap has formed between business personnel and professional developers due to the different tools they use: prototypes built by business personnel are difficult to transfer to development for in-depth customization, while complex logic written by developers cannot be intuitively presented to business personnel for understanding. Although there is some research that allows natural language instructions to generate machine learning pipelines, or technologies that generate front-end code from UI design diagrams, none of them systematically solve the fundamental problem of how to unify and abstract fundamentally different operations such as clicking buttons, calling AI, executing queries, and waiting for approvals into a unified visual object that the business can understand, and ensure strict, real-time, and bidirectional synchronization between this visual expression and the underlying executable code. Therefore, enterprises urgently need a new process assembly system that can integrate heterogeneous execution capabilities and connect business and IT perspectives to truly realize the vision of everyone being a digital enabler. Summary of the Invention

[0005] Therefore, the technical problem to be solved by the present invention is to overcome the problem in the prior art that business personnel cannot independently and intuitively assemble heterogeneous business capabilities with huge differences within the enterprise (such as RPA desktop operation, AI model calling, API services, etc.) into intelligent business processes like building blocks, and the assembly process cannot achieve bidirectional real-time synchronization with the underlying code, which leads to difficulties in business and development collaboration.

[0006] To address the aforementioned technical problems, this invention provides a visualized intelligent process assembly system for heterogeneous business capabilities, comprising:

[0007] The visual designer provides a graphical interface that includes a component panel, a process canvas, and a property configuration area, for assembling business processes through drag-and-drop and connection operations. The heterogeneous capability component library contains multiple pre-packaged graphical components, including at least Robotic Process Automation (RPA) operation components, Artificial Intelligence (AI) model invocation components, and database operation components. A unified component metadata model is used to standardize and encapsulate the description of each component in the heterogeneous capability component library. The metadata model defines functional signatures, runtime requirements, interaction descriptions, and configuration interface descriptions. A process logic generation engine is used to generate an executable process definition file based on the connection diagram formed by assembling the components on the process canvas. A bidirectional real-time synchronization engine is used to maintain a unified process abstract syntax tree (AST) as the sole true source of the business process and to achieve bidirectional real-time synchronization between the graphical operations in the visual designer and the underlying code. The process scheduling and execution engine is used to load and execute the process definition file to run the assembled business process.

[0008] Preferably, the unified component metadata model includes: Function signatures are used to declare the input parameter patterns and output parameter patterns of a component; Runtime requirements are used to declare the type of execution engine and resource dependencies required for component execution. Interaction description, used to declare the icons displayed by the components on the process canvas, as well as the type and number of input and output ports; The configuration interface description is used to declare the interface definition for dynamically generating user configuration forms in the attribute configuration area.

[0009] Preferably, the bidirectional real-time synchronization engine includes: The first synchronization module is used to convert the user's drag-and-drop, connection and configuration operations on the process canvas into modification instructions for the process abstract syntax tree AST in real time, drive the visualization renderer to update the canvas display, and drive the code generator to serialize the updated process abstract syntax tree AST into target code. The second synchronization module integrates an incremental parser, which responds to direct modifications made by the user to the target code in the code editor, parses the code changes, and attempts to merge them into the current process abstract syntax tree (AST). If the merge is successful, the visualization renderer will be driven to update the canvas display. If a logical conflict is detected, the user will be provided with a visual comparison of the differences and suggested solutions.

[0010] Preferably, the second synchronization module uses semantic merging, whereby the incremental parser can understand the semantics of code changes and map the semantic changes to modifications of the corresponding node attributes in the process abstract syntax tree (AST).

[0011] Preferably, the metadata of the AI ​​model calling component includes a configuration interface description that allows users to visually select different AI models integrated into the system and configure the system prompt word "Prompt" and the mapping relationship between input and output parameters.

[0012] Preferably, the system further includes a shared marketplace module, which allows users to publish and share packaged components or assembled process templates so that other users can obtain the published components or process templates from the shared marketplace module for reuse, rating, or secondary development.

[0013] Preferably, the system also includes an intelligent agent incubation framework, which guides users to build and deploy their own digital intelligent agents through three steps: knowledge base construction, intelligent agent role construction, and system access.

[0014] Preferably, the system further includes a scene marketplace module and a calendar task module; The scenario marketplace module is used to display and share automated process scenario templates built by different users; The calendar task module is used to configure scheduled or periodic automatic execution plans for the assembled business processes.

[0015] This invention provides a component encapsulation method for the above-mentioned system, comprising: Based on a unified component metadata model, various heterogeneous business operation capabilities are standardized and encapsulated to form graphical components with standardized functional signatures, runtime requirements, interaction descriptions, and configuration interface descriptions. The encapsulated components are registered in the heterogeneous capability component library of the system, making them available for use by the visual designer.

[0016] This invention provides a process assembly method for the above-mentioned system, comprising: Using the visual designer, users can drag and drop graphical components from the heterogeneous capability component library onto the process canvas, and define the execution logic and data flow between components by connecting them. In the attribute configuration area, a configuration form dynamically generated based on the component metadata is used to configure the parameters of the components in the canvas; During the assembly process, the bidirectional real-time synchronization engine enables real-time synchronization between graphical changes on the canvas and the underlying process definition code. The assembled graphical process is converted into an executable process definition file by the process logic generation engine, and then executed by the process scheduling and execution engine. Compared with the prior art, the above-mentioned technical solution of the present invention has the following advantages: The visual intelligent process assembly system for heterogeneous business capabilities described in this invention integrates a visual designer, a standardized heterogeneous capability component library, a unified metadata model, and a bidirectional real-time synchronization engine. This allows business personnel to intuitively drag and drop to assemble complex business processes that incorporate advanced technologies such as RPA and AI without coding. At the same time, it ensures strict real-time synchronization between the graphical design and its underlying executable code, thereby completely breaking down the barriers between business requirements and IT implementation and significantly reducing the threshold for building and maintaining intelligent processes. Attached Figure Description

[0017] To make the content of this invention easier to understand, the invention will be further described in detail below with reference to specific embodiments and accompanying drawings, wherein: Figure 1 This is a schematic diagram of the structure of a visual intelligent process assembly system for heterogeneous business capabilities provided by the present invention; Figure 2 This is a flowchart of the component encapsulation method based on the visual intelligent process assembly system provided by the present invention; Figure 3 This is a flowchart of the process assembly method based on the visual intelligent process assembly system provided by the present invention. Detailed Implementation

[0018] The core of this invention is to provide a visual intelligent process assembly system for heterogeneous business capabilities, a component encapsulation method based on the visual intelligent process assembly system, and a process assembly method. By standardizing the encapsulation of heterogeneous capabilities such as RPA and AI into draggable components through a unified metadata model, and by leveraging a bidirectional real-time synchronization engine based on an abstract syntax tree, it ensures lossless and real-time mutual translation between graphical design and underlying code, thereby effectively solving the technical problems of business personnel's difficulty in independently building intelligent processes and the disconnect between business and development collaboration.

[0019] To enable those skilled in the art to better understand the present invention, the invention will be further described in detail below with reference to the accompanying drawings and specific embodiments. Obviously, the described embodiments are merely some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0020] Please refer to Figure 1. Figure 1 This is a schematic diagram of the structure of a visualized intelligent process assembly system for heterogeneous business capabilities provided by the present invention; specifically including: The Visual Designer 100 provides a graphical interface that includes a component panel, a process canvas, and a property configuration area, for assembling business processes through drag-and-drop and connection operations. The heterogeneous capability component library 200 contains multiple pre-packaged graphical components, including at least a Robotic Process Automation (RPA) operation component, an Artificial Intelligence (AI) model invocation component, and a database operation component. A unified component metadata model 300 is used to standardize the encapsulation description of each component in the heterogeneous capability component library. The metadata model defines functional signatures, runtime requirements, interaction descriptions, and configuration interface descriptions. The process logic generation engine 400 is used to generate an executable process definition file based on the connection diagram formed by assembling the components on the process canvas. The bidirectional real-time synchronization engine 500 is used to maintain a unified process abstract syntax tree (AST) as the sole true source of the business process and to achieve bidirectional real-time synchronization between the graphical operations in the visual designer and the underlying code. The process scheduling and execution engine 600 is used to load and execute the process definition file to run the assembled business process.

[0021] Based on the above embodiments, this embodiment provides a detailed description of the visual designer 100: In some embodiments, the visual designer 100 is the core interface for system-user interaction, comprising at least three main functional areas: a component panel 101, a process canvas 102, and an attribute configuration area 103. The component panel 101 displays all available components in the heterogeneous capability component library in the form of graphical icons, categorized as RPA operations, AI services, data connections, logic control, etc. The process canvas 102 is the main workspace for users to orchestrate processes. Users can drag and drop the required component icons from the component panel 101 onto the canvas and define the execution order and data flow between components using connecting lines. The attribute configuration area 103 is a dynamic area. When a user selects any component on the canvas 102, this area automatically renders and generates a corresponding configuration form (such as a text box, dropdown list, checkbox, etc.) based on the configuration interface description defined for that component in the unified metadata model, allowing the user to fill in specific running parameters.

[0022] In other embodiments, the visual designer 100 also provides a multi-view collaborative mode. In addition to the default design view, a logic view and a real-time synchronized code view are provided. The logic view may hide some visual details, but more clearly displays the control flow logic such as conditional statements and loops between components. The code view is directly associated with the bidirectional real-time synchronization engine 300, displaying in real-time readable code (such as JSON, YAML, or a domain-specific language) corresponding to the current graphical process, generated by the process logic generation engine 400, in a sidebar or split-screen format. In this view, users with programming skills can directly edit the code, and their modifications will be fed back in real-time by the synchronization engine 300 and updated in the graphical design on the canvas 102, achieving true "what you see is what you edit."

[0023] In one specific embodiment, consider a scenario for building an intelligent contract review process. The user (legal professional) first drags an AI component named "Contract Text Extraction" from the AI ​​Service class in the component panel 101 to canvas 102; then drags a database component that retrieves supplier information from the ERP system from the Data Connection class; and finally drags a conditional judgment component from the Logic Control class. The user then connects these three components sequentially using connecting lines, forming a logic that first extracts key contract clauses, then queries supplier background, and finally determines subsequent processes based on risk levels. When the user clicks on the Contract Text Extraction component on the canvas, the attribute configuration area 103 dynamically displays the fields that need to be configured: a dropdown menu for selecting a specific AI model (such as DeepSeek-Legal), a text box for entering a prompt word optimized for this task, and a field mapping table for defining which downstream variable the AI-output client name field will be mapped to.

[0024] It should be noted that the drag-and-drop and connecting line interactions mentioned in this embodiment are all converted into structured operations such as adding, deleting, and modifying nodes in the Unified Process Abstract Syntax Tree (AST) by the bidirectional real-time synchronization engine 300. Therefore, even the simplest graphical operations have complete semantic expression, laying a solid foundation for subsequent code generation, process simulation, and error checking. This direct mapping from the interaction layer to the logic layer is the core feature that distinguishes this designer from traditional graphical tools that only focus on interface layout.

[0025] Based on the above embodiments, this embodiment provides a detailed description of the heterogeneous capability component library 200: In some embodiments, the metadata of the AI ​​model invocation component includes a configuration interface description that allows users to visually select different AI models integrated into the system and configure the system prompt and the mapping relationship between input and output parameters. This enables business personnel without a technical background to intuitively invoke and customize AI capabilities; for example, selecting a dedicated legal text understanding model for a contract review assistant and setting the prompt to extract payment terms and default amounts from the contract.

[0026] In other embodiments, the metadata of the Robotic Process Automation (RPA) operation component explicitly declares the execution engine type as a specific RPA robot and defines its required resource dependencies, such as the process name or window handle of the target application. Its interaction description defines dedicated icons on the process canvas representing clicked buttons or entered data, as well as data ports for receiving trigger conditions and outputting execution status.

[0027] In one specific embodiment, an RPA component encapsulates the ability to export monthly reports from a financial system. Its metadata's function signature declares that the input parameters are the report year and report month, and the output parameter is a string pointing to the path of the generated Excel file. When a user drags this component onto a canvas and configures the specific year and month, the system can automatically drive the RPA robot to log into the financial system, navigate to the report menu, and perform the export operation at runtime.

[0028] It should be noted that the heterogeneous capabilities referred to in this invention are not limited to RPA, AI models, database operations, or API calls. The concept can be extended to any business functional unit that can be called by software, including but not limited to microservices within an enterprise, legacy system interfaces, hardware device instructions, etc.

[0029] Based on the above embodiments, this embodiment provides a detailed description of the unified component metadata model 300: In some embodiments, the unified component metadata model is the core data structure for the system to standardize the description and management of various heterogeneous capability components. This model is a mandatory structural definition, requiring every component registered in the system, whether encapsulating RPA operations, AI model calls, database queries, or API services, to declare its complete metadata information according to this model, ensuring that the system can render, connect, configure, and execute it in a unified manner. Specifically, the model mainly includes descriptive information in the following dimensions: The functional signature is used to declare the input and output parameter patterns of a component. It defines the interface contract for the component to interact with external data. For example, the input pattern of an invoice recognition AI component might be defined as an image file, while the output pattern would be a structured JSON object containing fields such as invoice code, amount, and date. This signature ensures that the system can perform type validation when connecting components on the workflow canvas, preventing data mismatches and guaranteeing the logical correctness of the workflow.

[0030] The runtime requirements declare the type of execution engine and resource dependencies needed for the component to execute. Because system integration capabilities vary greatly in technical implementation, this information specifies the specific environment required to execute the logic behind the component. For example, a Python script component might require a Python 3.8+ interpreter, a component calling a cloud-based large model API might require an HTTP client and a valid API key path, while an RPA component operating the SAP GUI might require a specific version of the RPA robot to run. The system scheduler will allocate the appropriate execution resources based on this information.

[0031] The interaction description declares the icon displayed by the component on the process canvas, as well as the type and number of input and output ports. This metadata directly determines the component's appearance and connection method in the visual designer. For example, a data processing component might be given a gear icon and have one input port and two output ports (corresponding to the success and exception branches, respectively). This allows business users to intuitively understand the component's functionality and build flowcharts by dragging and dropping ports to connect them.

[0032] The configuration interface description is used to declare the interface definition for dynamically generating user configuration forms in the attribute configuration area. It uses a declarative language (such as JSON Schema) to describe the dynamically rendered form controls for configuring the component's parameters. For example, for an email sending component, its configuration interface description defines form items such as recipient (text box), subject (text box), and email body (rich text editor) along with their validation rules. When the user clicks on the component in the designer, the attribute configuration area generates the corresponding configuration form in real time based on this description, enabling flexible configuration tailored to each user without requiring separate front-end interface development for each component.

[0033] In some embodiments, the metadata model may further include a semantic tag field. This field is used to label component functions using natural language terms that are easy for business personnel to understand (such as financial reimbursement, customer service, and data cleaning). The system can use these tags to provide scenario-based intelligent filtering in the component panel, or proactively recommend other semantically related components when a user drags a specific component into the canvas (such as automatically highlighting the compliance review AI and archiving to the file system components after dragging in contract text), thereby helping users to complete process assembly more efficiently.

[0034] In other embodiments, the configuration interface description supports context-aware dynamic configuration. That is, the selectable values ​​or states of certain controls in the form can depend on the output of other configured components in the same process, or on the user's global variables. For example, in the configuration form of a data branch component, the options in the branch condition dropdown can dynamically load the field list output by the upstream data query component, avoiding errors that may be caused by manual input by the user.

[0035] It should be noted that the terminology used here means that the model provides a common and complete descriptive framework for all types of components, rather than requiring that all components have the same specific metadata values.

[0036] Based on the above embodiments, this embodiment provides a detailed description of the process logic generation engine 400: In some embodiments, the process logic generation engine 400 is configured to generate a target process definition file that can be directly interpreted and executed by the process scheduling and execution engine, based on the process abstract syntax tree (AST) maintained by the bidirectional real-time synchronization engine. The process definition file adopts a system-neutral intermediate representation, such as a structured description language based on JSON or YAML, which fully records the node sequence, node type, parameter configuration, and data flow and control dependencies between nodes in the AST.

[0037] In other embodiments, the process logic generation engine 400 has multi-target code generation capabilities. Besides generating intermediate representation files for internal system execution, it can also compile the same process AST into different forms of executable code based on the deployment environment or integration requirements. For example, for high-performance scenarios requiring independent deployment, it can generate optimized Python scripts; for scenarios requiring integration with a specific workflow engine, it can generate XML files conforming to the BPMN 2.0 specification; and for tasks requiring execution in lightweight containers, it can generate corresponding Docker configurations and execution instructions.

[0038] It should be noted that the neutral intermediate representation in the system is a key abstraction layer between the visual graphics and the final executable code. It decouples front-end design from back-end execution, allowing the same graphical process to flexibly adapt to different runtime environments. The static semantic checks ensure the logical correctness of the business process, detecting and warning of potential errors before execution, such as data type mismatches or missing required parameters, thereby significantly improving development reliability and debugging efficiency.

[0039] Based on the above embodiments, this embodiment provides a detailed description of the bidirectional real-time synchronization engine 500: In some embodiments, the bidirectional real-time synchronization engine 500 includes a first synchronization module 501 and a second synchronization module 502.

[0040] The first synchronization module 501 is responsible for handling the synchronization from the graphical interface to the code. Its core function is to convert all user interactions on the process canvas (such as dragging components, connecting ports, and configuring parameters in the property panel) into modification instructions for the process abstract syntax tree (AST) in memory in real time and with high precision. The AST serves as the sole authoritative internal representation of the entire business process, and its structured nodes and attributes precisely correspond to the business logic. Once the AST is updated, the first synchronization module 501 immediately drives two downstream actions: first, it drives the visualization renderer to redraw the canvas according to the latest AST, ensuring that what the user sees is what they get; second, it drives the code generator to serialize the updated AST into target code (such as JSON, YAML, or a specific domain scripting language) and present it in real time in the integrated code editing window.

[0041] The second synchronization module 502 is responsible for handling reverse synchronization, i.e., synchronization from code to the graphical interface. This module integrates an incremental parser that continuously monitors direct modifications made by the user to the target code in the code editor. When a code change is detected, the incremental parser does not simply parse the entire file, but intelligently analyzes the semantics of the modification, such as whether a component parameter has been modified, a conditional branch has been added, or the data flow has been adjusted. Subsequently, the system attempts to merge the parsed semantic changes into the current AST. This merging process is semantic, meaning that the system understands the intent of the modification, rather than performing a textual comparison. If the merge is successful, the second synchronization module 502 drives the visualization renderer to update the canvas, and the graphical interface will automatically and accurately reflect the code modification. If the incremental parser detects a logical conflict between the code modification and the existing AST (e.g., deleting an output port that is already referenced by other components), it will not forcibly overwrite it, but will provide the user with a visual comparison view of the differences, clearly showing the conflict points and providing solution suggestions (e.g., if the connection is invalid, please reconnect), guiding the user to resolve the conflict.

[0042] In other embodiments, the bidirectional real-time synchronization engine may employ an event-driven architecture. Each state change of the AST is published as an event. The visualization renderer and code generator, as subscribers, listen for specific types of events (such as node attribute updates and connection relationship changes) and update their respective views accordingly. This design decouples the core model (AST) from multiple views (graphics, code), improves the system's scalability, and facilitates the addition of new view formats (such as document views and debug views) in the future.

[0043] In one specific embodiment, consider a scenario where a user changes the recipient parameter of an email sending component in the canvas from "Department Manager" to "Project Leader." The first synchronization module captures this configuration operation, updates the attribute value of the corresponding node in the AST, and triggers the code generator to update the corresponding field value in the JSON code to "Project Leader." Conversely, if the developer directly modifies the value of the "subject" field in the JSON code, the incremental parser of the second synchronization module recognizes this as a node attribute update semantic, finds the corresponding node in the AST, and updates its subject attribute. Subsequently, the component's attribute panel or preview text on the canvas will be refreshed in real time with the new subject.

[0044] It should be noted that the Abstract Syntax Tree (AST) described in this article is a tree-like data structure used to represent the structure of a program or business process. Each node corresponds to an operation element in the process (such as a component, condition, or loop), and the attributes of the node correspond to configuration parameters. In this embodiment, semantic merging refers to the process of understanding the business logic intent of code modifications and applying it to the internal model, which is fundamentally different from simple text replacement or pasting.

[0045] Based on the above embodiments, this embodiment provides a detailed description of the process scheduling and execution engine 600: In some embodiments, the process scheduling and execution engine serves as the core runtime module of the intelligent process assembly system. It is responsible for loading and parsing the process definition file (typically a structured format such as JSON, YAML, or XML) output by the process logic generation engine, and driving and coordinating the actual execution of various heterogeneous components based on the component dependencies, execution logic (such as sequence, branching, and looping), and data flow defined within the file. This engine must possess cross-system compatibility, high concurrency, and fault tolerance capabilities.

[0046] In other embodiments, the engine employs a pluggable or microservice architecture. For different types of components (such as RPA components, AI model components, and API call components), the engine either builds in or dynamically loads the corresponding executor adapters. For example, for RPA components, the engine invokes the RPA robot executor to operate the user interface; for AI model call components, the engine sends requests to the model server via an HTTP client or a dedicated SDK. This design allows the system to flexibly expand its support for new types of capability components.

[0047] It should be noted that the execution engine type is already declared in the component metadata model. The process scheduling and execution engine assigns an appropriate executor to each component based on this declaration. Furthermore, the engine supports both synchronous and asynchronous execution modes. For time-consuming AI model calls, an asynchronous approach can be used, where the engine listens for callbacks immediately after initiating a request, rather than blocking and waiting, thereby improving the overall process throughput.

[0048] Based on the above embodiments, the system also includes a shared marketplace module, which allows users to publish and share packaged components or assembled process templates so that other users can obtain the published components or process templates from the shared marketplace module for reuse, rating, or secondary development.

[0049] In some embodiments, the shared marketplace module provides a unified metadata description framework for components and templates. This framework includes at least a function description, version information, applicable business scenario tags, creator information, and user review data to support accurate search and intelligent recommendation.

[0050] In other embodiments, the shared marketplace module is deeply integrated with the bidirectional real-time synchronization engine and the unified component metadata model. When a user reuses a process template from the marketplace, the system can automatically identify the differences between the components referenced in the template and the local environment (such as API addresses, database connections, etc.), and trigger the dynamic generation of an adaptation wizard in the attribute configuration area to guide the user to complete the necessary parameter reconfiguration, achieving one-click reuse and flexible adaptation.

[0051] It should be noted that the shared marketplace module is not a simple file repository or showcase, but a core operating system for building an enterprise-level digital capability ecosystem.

[0052] Based on the above embodiments, the system also includes an intelligent agent incubation framework, which guides users to build and deploy their own digital intelligent agents through three steps: knowledge base construction, intelligent agent role construction, and system access.

[0053] In some embodiments, the agent incubation framework is presented as a separate wizard-style functional module within the system. After the user launches this module, the interface will guide the user through three core steps in sequence, providing necessary templates, examples, and validations at each step to ensure a smooth construction process and the usability of the results.

[0054] In other embodiments, the knowledge base construction steps of the framework support multiple knowledge sources. Specifically, users can provide raw knowledge materials by uploading internal enterprise standard documents (such as Word and PDF), importing structured data tables (such as Excel), or directly connecting to existing databases or knowledge base systems. The system utilizes an integrated large language model and natural language processing technology to automatically parse, vectorize, and classify these multi-source heterogeneous knowledge materials, constructing a dedicated knowledge base that can be invoked and used for reasoning by intelligent agents.

[0055] It should be noted that the digital employees or digital intelligent agents in this embodiment specifically refer to software entities created through this system that have specific business roles (such as financial assistants, compliance specialists, and customer service agents) and automated execution capabilities. Essentially, they are schedulable processes that encapsulate business logic, knowledge, judgment, and execution capabilities.

[0056] Based on the above embodiments, the system further includes a scene market module and a calendar task module; The scenario marketplace module is used to display and share automated process scenario templates built by different users; The calendar task module is used to configure scheduled or periodic automatic execution plans for the assembled business processes.

[0057] In some embodiments, the scenario marketplace module further supports users in searching, previewing, reusing with one click, rating, and evaluating shared process templates. When a user reuses a template, the system can automatically identify the differences between the current user environment and the original template environment (such as system address, account permissions, and department identifiers), and guide the user to complete the necessary adaptation configurations, thereby enabling the rapid and scalable replication and cross-business unit promotion of automated best practices.

[0058] In other embodiments, the triggering rules of the calendar task module not only support basic timed events (such as 9 AM daily) and periodic events (such as every Monday), but also support more complex business calendar rules (such as the last working day of each quarter, excluding holidays) and event-based triggering conditions (such as when an email with a specific topic is received or when a file is generated by an upstream system). The execution plan supports configuring a failure retry mechanism, timeout alerts, and automatic archiving of execution logs.

[0059] It should be noted that the template mentioned in this embodiment refers to the encapsulation of a complete, independently runnable business process instance, which includes the process's logical structure, component configuration, and initial parameters. The scenario emphasizes the specific business problem context that the process solves, such as employee onboarding or supplier reconciliation.

[0060] This invention addresses the core contradiction in enterprise digital transformation—the difficulty for business personnel to innovate and the slow response of developers—caused by the proliferation of heterogeneous systems and high technical barriers. Specifically, its benefits are as follows: For business personnel, the system abstracts and encapsulates complex heterogeneous technologies such as RPA scripts, AI models, and API interfaces into Lego-like visual components with clear business semantics, such as financial auditing and contract parsing. This allows business experts without programming skills (such as HR and finance personnel) to intuitively and quickly assemble intelligent business processes that meet personalized needs (such as intelligent recruitment screening and automated expense reimbursement approval) through intuitive drag-and-drop functionality, truly breaking down the barriers between technology and business, and enabling everyone to become a digital enabler. For developers, the bidirectional real-time synchronization engine based on the unified abstract syntax tree (AST) ensures lossless and real-time mapping between the visual canvas and the underlying code. With this system, developers can directly modify code for in-depth optimization or integration of new capabilities without disrupting business logic. This enables seamless collaboration between business and development on the same asset, completely resolving the pain points of traditional low-code systems where development and maintenance are disconnected and disconnection occurs upon export. For the organization as a whole, the system's built-in shared marketplace and intelligent agent incubation framework can quickly transform successfully validated automated processes (such as nuclear power plant safety inspections) into reusable scenario templates. Through configurable adaptation (such as switching to the wind power business system), these templates can be replicated at scale across the entire group, greatly accelerating the accumulation and promotion of digital transformation experience. This provides support at the tool level for the enterprise's digital culture transformation from top-level drive to company-wide innovation.

[0061] Please refer to Figure 2 The present invention also provides a component encapsulation method based on the above system, comprising: S101: Based on a unified component metadata model, various heterogeneous business operation capabilities are standardized and encapsulated to form a graphical component with standardized functional signatures, runtime requirements, interaction descriptions, and configuration interface descriptions. S102: Register the encapsulated component to the heterogeneous capability component library of the system so that it can be called by the visual designer.

[0062] The component encapsulation method described in this embodiment aims to realize the aforementioned visualized intelligent process assembly system for heterogeneous business capabilities. Therefore, the system architecture, module functions, and specific technical details involved in this method can be found in the detailed embodiment section of the system described above, and will not be repeated here.

[0063] Please refer to Figure 3 The present invention also provides a process assembly method based on the above system, comprising: S201: Using the visual designer, drag and drop graphical components from the heterogeneous capability component library onto the process canvas, and define the execution logic and data flow between components by connecting them; S202: In the attribute configuration area, configure the parameters of the components in the canvas using a configuration form dynamically generated based on the component metadata. S203: During the assembly process, a bidirectional real-time synchronization engine is used to achieve real-time synchronization between graphical changes in the canvas and the underlying process definition code. S204: Through the process logic generation engine, the assembled graphical process is converted into an executable process definition file, which is then run by the process scheduling and execution engine.

[0064] The process encapsulation method described in this embodiment aims to specifically implement the aforementioned visualized intelligent process assembly system for heterogeneous business capabilities. The specific architecture, module functions, and implementation methods of this system have been described in detail in the preceding embodiments and will not be repeated here. This method embodiment will directly operate and implement based on the described system.

[0065] Obviously, the above embodiments are merely illustrative examples for clear explanation and are not intended to limit the implementation. Those skilled in the art will recognize that other variations or modifications can be made based on the above description. It is neither necessary nor possible to exhaustively list all possible implementations here. However, obvious variations or modifications derived therefrom are still within the scope of protection of this invention.

Claims

1. A visualized intelligent process assembly system for heterogeneous business capabilities, characterized in that, include: The visual designer provides a graphical interface that includes a component panel, a process canvas, and a property configuration area, for assembling business processes through drag-and-drop and connection operations. The heterogeneous capability component library contains multiple pre-packaged graphical components, including at least Robotic Process Automation (RPA) operation components, Artificial Intelligence (AI) model invocation components, and database operation components. A unified component metadata model is used to standardize and encapsulate the description of each component in the heterogeneous capability component library. The metadata model defines functional signatures, runtime requirements, interaction descriptions, and configuration interface descriptions. A process logic generation engine is used to generate an executable process definition file based on the connection diagram formed by assembling the components on the process canvas. A bidirectional real-time synchronization engine is used to maintain a unified process abstract syntax tree (AST) as the sole true source of the business process and to achieve bidirectional real-time synchronization between the graphical operations in the visual designer and the underlying code. The process scheduling and execution engine is used to load and execute the process definition file to run the assembled business process.

2. The system according to claim 1, characterized in that, The unified component metadata model includes: Function signatures are used to declare the input parameter patterns and output parameter patterns of a component; Runtime requirements are used to declare the type of execution engine and resource dependencies required for component execution. Interaction description, used to declare the icons displayed by the components on the process canvas, as well as the type and number of input and output ports; The configuration interface description is used to declare the interface definition for dynamically generating user configuration forms in the attribute configuration area.

3. The system according to claim 1, characterized in that, The bidirectional real-time synchronization engine includes: The first synchronization module is used to convert the user's drag-and-drop, connection and configuration operations on the process canvas into modification instructions for the process abstract syntax tree AST in real time, drive the visualization renderer to update the canvas display, and drive the code generator to serialize the updated process abstract syntax tree AST into target code. The second synchronization module integrates an incremental parser, which responds to direct modifications made by the user to the target code in the code editor, parses the code changes, and attempts to merge them into the current process abstract syntax tree (AST). If the merge is successful, the visualization renderer will be driven to update the canvas display. If a logical conflict is detected, the user will be provided with a visual comparison of the differences and suggested solutions.

4. The system according to claim 3, characterized in that, The second synchronization module uses semantic merging, whereby the incremental parser can understand the semantics of code changes and map the semantic changes to modifications of the corresponding node attributes in the process abstract syntax tree (AST).

5. As described in claim 1, characterized in that, The metadata of the AI ​​model calling component describes a configuration interface that allows users to visually select different AI models integrated into the system and configure the system prompt word "Prompt" as well as the mapping relationship between input and output parameters.

6. The system according to claim 1, characterized in that, The system also includes a shared marketplace module, which allows users to publish and share packaged components or assembled process templates so that other users can obtain the published components or process templates from the shared marketplace module for reuse, rating, or secondary development.

7. The system according to claim 1, characterized in that, The system also includes an intelligent agent incubation framework, which guides users to build and deploy their own digital intelligent agents through three steps: knowledge base construction, intelligent agent role construction, and system access.

8. The system according to claim 1, characterized in that, The system also includes a scenario marketplace module and a calendar task module; The scenario marketplace module is used to display and share automated process scenario templates built by different users; The calendar task module is used to configure scheduled or periodic automatic execution plans for the assembled business processes.

9. A component encapsulation method based on the system according to any one of claims 1-8, characterized in that, include: Based on a unified component metadata model, various heterogeneous business operation capabilities are standardized and encapsulated to form graphical components with standardized functional signatures, runtime requirements, interaction descriptions, and configuration interface descriptions. The encapsulated components are registered in the heterogeneous capability component library of the system, making them available for use by the visual designer.

10. A process assembly method based on the system according to any one of claims 1-8, characterized in that, include: Using the visual designer, users can drag and drop graphical components from the heterogeneous capability component library onto the process canvas, and define the execution logic and data flow between components by connecting them. In the attribute configuration area, a configuration form dynamically generated based on the component metadata is used to configure the parameters of the components in the canvas; During the assembly process, the bidirectional real-time synchronization engine enables real-time synchronization between graphical changes on the canvas and the underlying process definition code. The assembled graphical process is converted into an executable process definition file by the process logic generation engine, and then run by the process scheduling and execution engine.

Images