An AI agent technology-based micro-service process orchestration method

Abstract

The application discloses a micro-service process arrangement method based on AI agent technology, and the arrangement method comprises the following steps: step S1, ATS document analysis; step S2, ACS document analysis; step S3, generating a node according to the analysis result and according to a rule; step S4, edge generation; step S5, topology verification; and step S6, outputting a standardized process definition JSON. The conversion from a natural language description to structured data is automatically completed, and the problems of low efficiency and easy omission caused by manual understanding of documents piece by piece are solved.

Description

Technical Field

[0001] This invention relates to the field of information system construction, and in particular to a method for microservice process orchestration based on AI agent technology. Background Technology

[0002] In existing technologies, when enterprises build information systems, they typically first establish systematic IT modeling results to guide subsequent service code development. These modeling results are generally divided into two main categories: IT logical models and IT physical models, which respectively characterize the system from the business abstraction level and the implementation technology level and guide the code implementation of business logic.

[0003] The IT logical model primarily describes the system's business functions, business processes, and business objects. System functions and system use cases define the business capabilities the system needs to provide and the user interaction scenarios with the system; Business Object Components (BOC) and Product Components (PBB) describe the core entities in the business domain and their attributes and behaviors; System Workflow Components (PBC) and Application Transaction Services (ATS) define the process steps and atomic transaction services across multiple business objects; Basic Services (PBS) and Application Component Services (ACS) describe the system's common basic capabilities and reusable application component interfaces.

[0004] The IT physical model, based on the logical model, is further refined into deployable and runnable implementation components. Microservice components and modules clarify the microservice division of the system and the module structure within each service; data entity C' and data entity D define in detail the database table structure, field types, primary and foreign key relationships, and data constraints; basic components (BCC / BQC) are the specifications for underlying general components and core business components.

[0005] Currently, relying on manual processes combined with IT models for process orchestration suffers from low efficiency, document asynchrony, and error-prone process configuration. To address this, this solution integrates IT models with AI agent technology, automatically generating microservice process orchestration topology diagrams based on ATS and ACS data, thus automating process orchestration.

[0006] As enterprise information systems expand and business processes under microservice architectures become increasingly complex, traditional manual flowchart drawing methods suffer from problems such as high workload, potential for document and drawing synchronization issues, and confusion regarding node types. With the rapid development of AI technology, AI is increasingly replacing manual labor in repetitive modeling tasks. This invention introduces a Skill mechanism, encapsulating domain-specific parsing rules and generation logic into reusable skill units. This enables AI to automatically parse ATS / ACS documents and generate standardized process orchestration diagrams, achieving automation and standardization of process modeling.

[0007] During enterprise IT infrastructure development, business personnel use IT modeling tools to create ATS and ACS service definition documents, which describe the complete logic of business processes. Existing methods for converting modeling documents into flowcharts mainly include the following categories: The purely manual drawing method involves developers or business analysts using ATS / ACS documents as a reference to manually draw flowcharts in drawing tools (such as Visio, ProcessOn, Draw.io, etc.). The entire process relies on manual understanding of the document content, identification of component relationships, drawing of graphics, and labeling of connecting lines, which is time-consuming and prone to overlooking details.

[0008] Semi-automated tools offer basic graphical export functionality, displaying tabular data from documents as a list. Users need to manually select component types, drag and drop graphics, and establish connections, resulting in limited automation.

[0009] Fixed template filling is a common method where some systems provide predefined flowchart templates. Users fill in the data in the ATS / ACS according to the template format to generate a fixed-format flowchart. However, templates lack flexibility and are difficult to adapt to different business process structures.

[0010] The existing technology has the following drawbacks: Manual drawing is labor-intensive and inefficient. Manually drawing flowcharts relies on people manually understanding the contents of ATS / ACS documents, identifying component types, and determining call relationships, which is time-consuming. When the business process is complex (containing 10+ component nodes and 20+ connection edges), the workload of manual drawing increases exponentially.

[0011] Flowcharts and service definition documents are prone to becoming out of sync: Once the flowchart is drawn manually, it needs to be updated manually when the ATS / ACS document changes (such as adding or deleting components, modifying the call order, or adjusting conditional branches). Inconsistencies between the two can easily occur, causing confusion for subsequent developers.

[0012] It is difficult to guarantee the accuracy of node types and connection relationships: When drawing flowcharts manually, it is easy to confuse different node types (such as mislabeling a query verification component as a regular business component) or omit the conditional expressions of conditional edges, resulting in the flowchart not accurately reflecting the business logic.

[0013] Automatic layout and hierarchical display are not supported: The layout of manually drawn flowcharts depends on personal habits. Different people draw different styles of graphics, making it difficult to form a unified visualization standard and unable to achieve automatic hierarchical layout (such as the main process being horizontal and branches being downward). Summary of the Invention

[0014] In view of the above problems, the present invention is proposed to provide a microservice process orchestration method based on AI agent technology to overcome or at least partially solve the above problems.

[0015] According to one aspect of the present invention, a method for microservice process orchestration based on AI agent technology is provided, the orchestration method comprising: Step S1: ATS document parsing; Step S2: ACS document parsing; Step S3: Generate nodes according to the rules based on the parsing results; Step S4: Edge generation; Step S5: Topology verification; Step S6: Output the standardized process definition JSON.

[0016] Optionally, step S1: ATS document parsing specifically includes: Collect ATS documents; AI analyzes the ATS / ACS table structure based on semantics: Automatically recognizes service inputs, service outputs, call descriptions, and processing logic table areas in Excel; No manual labeling of table types is required; AI infers the meaning of the table based on column names and content.

[0017] Optionally, step S2: ACS document parsing specifically includes: Enter the ACS document; The parsed content is: ACS number and name → basic properties of subFlowComponent; Input Information Form → componentMethodParams (Business Component Input Parameters); Output Information Table → SystemCompMethodReturnConf Business Component Parameter Output; BOC type → Node type mapping rules; AI automatically identifies BOC types; Automatically identify the type BCC / PBB / PBC / BQC / SVC from the BOC encoding, and automatically map it to the corresponding "dataType" based on the type.

[0018] Optionally, step S3: generating nodes according to the rules based on the parsing results specifically includes: Start node generation rules: ATS service input form → contextVarAttributes[]; Sub-process node generation rules, ATS layer Each record in the ATS call description → a subFlowComponent node; Business component node generation rules, ACS layer Each BOC record in the ACS processing logical table → a systemComponent node; serviceName mapping: Deposit product → pilot-deposit-product-server; beanName mapping: Look up the table based on the service type; methodName: Inferred from the BOC name; End node generation rules: ATS service output table → endCompConf.paramMappingList[]; Interruption node generation rules: Error code ErrCode003 / 004 / 005 → handleErrorService component.

[0019] Optionally, step S4: edge generation specifically includes: Sequential edge generation rule: Connect adjacent nodes sequentially according to the "step number" order in the ATS table calling instructions; Conditional edge generation rules: Generate conditional branch edges based on the conditional expressions defined by the ACS error codes. Loop edge generation rule: When the process contains loop logic, generate edges with special markings: Optionally, step S5: topology verification specifically includes: verifying that the generated flowchart satisfies convergence constraints.

[0020] This invention provides a microservice process orchestration method based on AI agent technology. The orchestration method includes: Step S1: ATS document parsing; Step S2: ACS document parsing; Step S3: Generating nodes according to rules based on the parsing results; Step S4: Edge generation; Step S5: Topology verification; Step S6: Outputting standardized process definition JSON. This automatically completes the conversion from natural language descriptions to structured data, solving the problems of low efficiency and easy omissions caused by relying on manual document interpretation.

[0021] The above description is merely an overview of the technical solution of the present invention. In order to better understand the technical means of the present invention and to implement it in accordance with the contents of the specification, and in order to make the above and other objects, features and advantages of the present invention more apparent and understandable, specific embodiments of the present invention are described below. Attached Figure Description

[0022] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. 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.

[0023] Figure 1 A flowchart of a microservice process orchestration method based on AI agent technology is provided as an embodiment of the present invention; Figure 2 A schematic diagram illustrating the input of an ATS document as provided in an embodiment of the present invention; Figure 3 This is a schematic diagram of the parsing result after inputting an ATS document, as provided in an embodiment of the present invention. Figure 4 This is a schematic diagram of the ATS service input form provided in an embodiment of the present invention; Figure 5 This is a schematic diagram of an ATS call instruction table provided in an embodiment of the present invention; Figure 6 This is a schematic diagram of an ATS error information table provided in an embodiment of the present invention; Figure 7 This is a schematic diagram illustrating the input of ACS document information provided in an embodiment of the present invention; Figure 8 This is a schematic diagram of ACS document output information provided in an embodiment of the present invention; Figure 9 This is a schematic diagram illustrating the processing logic and rules provided in the embodiments of the present invention; Figure 10 A schematic diagram of ACS numbering and naming provided for embodiments of the present invention; Figure 11 This is a schematic diagram of the input information table provided in an embodiment of the present invention; Figure 12 This is a schematic diagram of the output information table provided in an embodiment of the present invention; Figure 13 A schematic diagram of BOC type provided in an embodiment of the present invention; Figure 14 This is a schematic diagram of the edge generation logic provided in an embodiment of the present invention; Figure 15 This is a schematic diagram of the conditional edge generation rules provided in an embodiment of the present invention; Figure 16 This is a schematic diagram of the conditional edge JSON structure provided in an embodiment of the present invention; Figure 17 This is a schematic diagram of the cyclic edge generation rules provided in an embodiment of the present invention; Figure 18A schematic diagram illustrating that the verification process generated in this embodiment of the invention satisfies convergence constraints; Figure 19 A schematic diagram of the standardized output process definition JSON provided for embodiments of the present invention; Figure 20 This is a schematic diagram of the structure of the AI ​​intelligent agent platform provided in an embodiment of the present invention. Detailed Implementation

[0024] Exemplary embodiments of the present disclosure will now be described in more detail with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.

[0025] The terms "comprising" and "having," and any variations thereof, in the specification, embodiments, claims, and drawings of this invention are intended to cover non-exclusive inclusion, such as including a series of steps or units.

[0026] The technical solution of the present invention will be further described in detail below with reference to the accompanying drawings and embodiments.

[0027] Method implementation steps: Step 1: ATS Document Parsing Input an ATS document (Excel format), such as Figure 2 , Figure 3 As shown; AI analyzes the ATS / ACS table structure based on semantics: Automatically recognizes service inputs, service outputs, call descriptions, processing logic, and other table areas in Excel. No manual labeling of table types is required; AI infers the meaning of tables based on column names and content. The following content is analyzed: like Figure 4 As shown, in the service input table → contextVarAttributes (start node input parameters).

[0028] like Figure 5 As shown in the ATS call description table → subFlowComponent sub-flow node.

[0029] like Figure 6 As shown, the ATS error information table → interruption nodes and condition edges.

[0030] Step 2: ACS document parsing Enter the ACS document (Excel format), and enter the information as follows: Figure 7 As shown, the output information is as follows Figure 8 As shown, the processing logic and rules are as follows: Figure 9 As shown.

[0031] Parse the following: ACS number and name → basic properties of subFlowComponent, such as Figure 10 As shown.

[0032] Input information form → componentMethodParams (business component input parameters), such as Figure 11 As shown.

[0033] Output information table → systemCompMethodReturnConf (business component output parameters), such as Figure 12 As shown.

[0034] BOC type → node type mapping rules, such as Figure 13 As shown.

[0035] AI automatically identifies BOC types; Automatically identify the type (BCC / PBB / PBC / BQC / SVC) from the BOC encoding and automatically map it to the corresponding "dataType".

[0036] Step 3: Node Generation Based on the parsing results, nodes are generated according to the following rules: Start Node Generation Rules ATS Service Input Form → contextVarAttributes[] For example: Product No., is it required? (Yes) → {"contextVarKey": "$productNo", "contextVarDesc": "Product Number", "required": true} Sub-process node generation rules (ATS layer) Each record in the ATS call description → a subFlowComponent node flowVersData.subFlowCode = ACS number flowVersData.flowName = ACS name + "ACS" subFlowKey format: {projectCode}_$_{flowCode}_$_0.0.0 Business component node generation rules (ACS layer) ACS processes each BOC record in the logical table into a systemComponent node. serviceName mapping: Deposit product → pilot-deposit-product-server beanName mapping: Lookup table based on service type methodName: Inferred from the BOC name End node generation rules ATS service output table → endCompConf.paramMappingList[] For example: TradeCode → {"fieldName": "tradeCode", "contextVarKey":"$resp.tradeCode"} Interruption Node Generation Rules (Error Handling) Error codes ErrCode 003 / 004 / 005 → handleErrorService component contextVarKey = error code, such as "$ErrCode003" Step 4: Edge Generation Sequential edge generation rule: Connect adjacent nodes sequentially according to the "step number" order in the ATS table calling instructions. For example... Figure 14 As shown.

[0037] Conditional edge generation rules: Generate conditional branch edges based on the conditional expressions defined by the ACS error codes, such as... Figure 15 As shown.

[0038] AI extracts conditional semantics from error descriptions. For example, "Contract signing failed" → `$xxxResp.depProdConNum==null`. AI needs to understand the business semantics rather than mechanically matching.

[0039] Conditional edge JSON structure as follows Figure 16 As shown.

[0040] The rule for generating loop edges is to generate edges with special tags when the process contains loop logic, such as... Figure 17 As shown.

[0041] Step 5: Topology verification. Verify that the generated flowchart satisfies the convergence constraints, such as... Figure 18 As shown.

[0042] Step 6: JSON output. Output the standardized process definition JSON, such as... Figure 19 As shown.

[0043] Based on a preset ATS / ACS parsing algorithm, it automatically identifies the document structure; converts service definitions into standard nodes according to node type mapping rules; automatically generates connection edges between nodes based on call relationships and conditional logic; has a built-in topology verification mechanism to ensure that the generated flowchart meets convergence constraints; outputs a standardized JSON format, which can be directly integrated with visualization rendering engines such as G6 / X6; the flowchart input document (referring to the user-provided ATS / ACS service definition document) is used. Figure 20 As shown.

[0044] As input sources for flowchart generation, it includes: ATS document (Application Transaction Service Definition): describes the orchestration logic of the business process, the order of ACS calls, conditional branches, and input / output parameters; ACS document (Application Component Service Definition): describes the implementation details of the business component, BOC call chain, input and output parameters, and error handling.

[0045] Implementation steps: Installation process diagram generation skills: Within the workspace, the user installs the process diagram generation skill arch-process-assembler developed in this invention. This skill encapsulates the ATS / ACS parsing algorithm, node mapping rules, edge generation algorithm, and topology verification logic.

[0046] Upload ATS / ACS service definition documents: Users can upload ATS and ACS service definition documents to their workspace, supporting Markdown or Excel format input.

[0047] Execution flowchart generation: Input prompts through the AI ​​intelligent agent platform assistant dialog box, and the platform calls the installed generation skills to automatically execute the entire process of parsing → conversion → generation → verification, and outputs the standardized JSON format process definition to the output directory.

[0048] Visual rendering: The generated JSON can be directly imported into visual rendering engines such as G6 / X6 to generate interactive flowcharts.

[0049] ATS / ACS documents → AI Intelligent Agent Platform: Users can upload service definition documents to the platform via the platform's web interface.

[0050] AI-powered intelligent agent platform → Process orchestration diagram generation skills. The platform has a built-in skill management engine that establishes a runtime call channel between the platform and skills. The platform sends generation requests to skills, transmits document data, and receives generation results.

[0051] The flowchart generation skill → code output module: After the skill completes the flowchart generation, it outputs the process definition in JSON format to the output directory.

[0052] Code output module → Visual rendering engine: JSON format process definitions can be directly imported into rendering engines such as G6 / X6 to generate visual flowcharts.

[0053] Code output module → Git repository (optional). The generated process definition can be packaged and pushed to the Git repository for version management.

[0054] SKILL.md main document Triggering conditions: Identify user requests and automatically trigger process generation. Keywords: "Generate microservice orchestration flowchart", "Display interface call relationships", "Generate process orchestration code".

[0055] Core workflow: Input → Generation → Automatic scoring (structure + content) → Output report. ACS and ATS generate scripts separately, which are executed sequentially; scoring is performed automatically immediately after generation.

[0056] Core concepts: Define two core concepts, ATS (Application Transaction Service) and ACS (Application Component Service), as well as the relationship between nodes and edges.

[0057] Node type mapping: The mapping relationship between the dataType of 17 node types and panel components (e.g., startComponent → StartNodePanel).

[0058] BOC type mapping: Mapping rules between BOC types (BCC / PBB / PBC / BQC / SVC) and node types.

[0059] Input files: Column names and format descriptions for three types of Excel files: ATS service list, ACS service list, and BOC definition.

[0060] Scoring dimensions: Scoring is based on structural and content dimensions.

[0061] References / Reference Documents The references directory contains core rule references and examples for process orchestration, which are the key basis for generating processes.

[0062] The mapping-rules.md file contains all the rules for generating nodes and edges, as well as Python code templates.

[0063] examples.md: Flowchart examples and rating report templates.

[0064] flow_viewer.html: An HTML-based flowchart visualization viewer used to preview the generated flowchart JSON visualization results, which can be opened directly in a browser to view the flowchart effect.

[0065] resource / Sample data The resource directory contains sample input files and reference JSON for the target output, which are key references for understanding and verifying the generated results.

[0066] input / Input directory: The input directory contains user-uploaded Excel source files, which are processed to generate JSON for workflow orchestration.

[0067] The target / baseline directory contains a JSON file that serves as a reference for the output and is a template for the correct generated results.

[0068] outputs / Output directory The outputs directory is the final output location of the process, containing the generated JSON files and scoring reports.

[0069] The orchestration_flow_detail_define / directory stores the generated orchestration JSON files.

[0070] The py / directory contains Python code used to generate JSON for workflow orchestration.

[0071] Detailed Explanation of the Scoring System The scoring system is the core mechanism to ensure the quality of JSON compilation during the generation process. It has a total score of 100 points and is divided into two main parts: structural dimension and content dimension.

[0072] Key Design: Multi-dimensional IT modeling results serve as a unified input entry point The "User Input" area on the left side of the image uses the modeling results ATS and ACS as direct input sources, eliminating the need for manual conversion or writing of intermediate code. This enables source-driven processing from the original model of business requirements and business processes to the service code.

[0073] Standardized generation base library The "Generation Basis" area in the middle of the image defines the nodes, edges, and complete code templates for generating the visual flowchart.

[0074] Node rules: 11 node types are defined—startComponent, endComponent, systemComponent (business component / BOC call), subFlowComponent (sub-flow / ACS), rpcComponent (RPC call), rpcVerifyComponent (verification), jsonComponent (JSON conversion), ruleComponent (rule), varComponent (variable assignment), cycleComponent (loop), and interrupt node (error handling). Each node has a fixed JSON structure, attribute fields, and position coordinate rules.

[0075] Edge rules: Connect via source / target, sourceAnchor / targetAnchor define the anchor direction, conditional edges are distinguished by condition expressions and label tags, and cyclic lines are marked with color using cycleLineType.

[0076] Convergence rules: Start point index=0, end point index=99, all edge directions must be from smallest to largest, reverse direction is not allowed, and unidirectional flow is ensured.

[0077] Error handling: ErrCode 003 / 004 / 005 triggers the interrupt node (handleErrorService), while other error codes flow directly to the end node.

[0078] Scoring system: 50 points for structure dimension (node ​​type, topology, connection) + 50 points for content dimension (completeness of each node attribute), ≥90 points is excellent.

[0079] Interactive generation process management The "Generation Process" section on the right side of the image allows users to view the task progress in real time, making the process visualized. After generation, the system will automatically compare the data with baseline data and assign a score to determine the accuracy of the flowchart.

[0080] Beneficial effects: AI-driven intelligent parsing capabilities for unstructured documents Traditional methods rely on manual, line-by-line interpretation of ATS / ACS documents, which is inefficient and prone to overlooking details. This invention leverages AI's semantic understanding capabilities to intelligently parse semi-structured service definition documents like ATS / ACS, automatically identifying service input / output parameters, ACS call steps and sequences, conditional branching logic, BOC call chains, and error code definitions. AI understands business semantics rather than mechanically matching table formats, automatically inferring table types (e.g., identifying service input tables as contextVarAttributes and call description tables as subFlowComponent). This eliminates the need for manual annotation, completing the conversion from natural language descriptions to structured data, significantly improving document parsing efficiency and accuracy.

[0081] The Skill architecture enables end-to-end automation, lowering the barrier to entry. This invention constructs a dedicated microservice orchestration diagram generation skill within an AI intelligent agent platform, encapsulating capabilities such as ATS / ACS document parsing, node transformation, edge generation, and topology verification into independent, reusable skill modules. This skill can be invoked through natural language interaction to control the entire generation process, achieving end-to-end automation from "upload document → automatic parsing → flowchart generation." Users do not need to write any parsing code or manually configure parameters; they can drive flowchart generation simply by describing their needs through dialogue, significantly lowering the technical barrier and enabling non-technical personnel to quickly generate professional flowcharts.

[0082] Automated and precise conversion based on node type mapping rules Traditional methods require manual identification and labeling of node types, which can easily lead to confusion between different node types. This invention designs a complete node type decision tree within Skill, automatically mapping service definitions in ATS / ACS / BOC to standardized flowchart node types after AI intelligent identification. Based on the type identifier (BCC / PBB / PBC / BQC / SVC) in the BOC encoding, the invention automatically determines the node type (e.g., BCC / PBB / PBC maps to systemComponent, BQC to rpcVerifyComponent, and ACS calls to subFlowComponent), and automatically generates corresponding JSON structure attributes based on the node type, including serviceName, beanName, methodName, componentMethodParams, etc., ensuring the completeness and accuracy of node information.

[0083] An automated edge generation algorithm based on a call relationship graph Traditional manual drawing methods are prone to missing connections and incorrect directions. This invention automatically generates sequential edges based on the ATS call sequence obtained from AI parsing, automatically generates conditional edges based on ACS error code definitions and conditional judgment logic, and automatically generates loop edges marked with `cycleLineType` based on loop components. AI extracts conditional semantics from error descriptions to generate conditional expressions. (e.g., "Contract signing failed" → $xxxResp.depProdConNum==null), understanding business semantics rather than mechanical matching, the generated edges completely cover all branch paths, forming a complete process connectivity graph.

[0084] Automatic verification mechanism for process topology that meets convergence constraints Traditional methods often fail to detect potential topological defects. This invention designs a single-entry, single-exit topological constraint rule. AI automatically verifies that the generated flowchart satisfies the following: exactly one start node (index=0), exactly one end node (index=max), all edges have increasing indices, and all non-end nodes have successor nodes. Immediately after generation, an automatic scoring process is performed, evaluating the flowchart from both structural (node ​​type 15 points, topological structure 20 points, connection relationships 15 points) and content (start node 10 points, business components 15 points, sub-processes 10 points, end node 8 points, exception handling 7 points) dimensions to ensure the flowchart meets standards in both structural correctness and content completeness.

[0085] This invention provides end-to-end fully automated flowchart generation and standardized output, automating the entire process from ATS / ACS document input to standardized JSON format flowchart definition output. The generated JSON includes flowDetailId, flowCode, flowName, flowVersion, projectCode, and flowDefineText (arrays of nodes and edges), which can be directly used in visualization rendering engines such as G6 / X6, achieving one-click conversion of "modeling document as flowchart". When the ATS / ACS document changes, the flowchart can be quickly regenerated, ensuring that the flowchart remains synchronized with the source document and avoiding the desynchronization problems caused by manual drawing.

[0086] The above specific embodiments further illustrate the purpose, technical solution, and beneficial effects of the present invention. It should be understood that the above are merely specific embodiments of the present invention and are not intended to limit the scope of protection of the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A method for microservice process orchestration based on AI intelligent agent technology, characterized in that, The arrangement method includes: Step S1: ATS document parsing; Step S2: ACS document parsing; Step S3: Generate nodes according to the rules based on the parsing results; Step S4: Edge generation; Step S5: Topology verification; Step S6: Output the standardized process definition JSON.

2. The microservice process orchestration method based on AI agent technology according to claim 1, characterized in that, Step S1: ATS document parsing specifically includes: Collect ATS documents; AI analyzes the ATS / ACS table structure based on semantics: Automatically recognizes service inputs, service outputs, call descriptions, and processing logic table areas in Excel; No manual labeling of table types is required; AI infers the meaning of the table based on column names and content.

3. The microservice process orchestration method based on AI agent technology according to claim 1, characterized in that, Step S2: ACS document parsing specifically includes: Enter the ACS document; The parsed content is: ACS number and name → basic properties of subFlowComponent; Input Information Form → componentMethodParams (Business Component Input Parameters); Output Information Table → SystemCompMethodReturnConf Business Component Parameter Output; BOC type → Node type mapping rules; AI automatically identifies BOC types; Automatically identify the type BCC / PBB / PBC / BQC / SVC from the BOC encoding, and automatically map it to the corresponding "dataType" based on the type.

4. The microservice process orchestration method based on AI agent technology according to claim 1, characterized in that, Step S3: Generating nodes according to the rules based on the parsing results specifically includes: Start node generation rules: ATS service input form → contextVarAttributes[]; Sub-process node generation rules, ATS layer Each record in the ATS call description → a subFlowComponent node; Business component node generation rules, ACS layer Each BOC record in the ACS processing logical table → a systemComponent node; serviceName mapping: Deposit product → pilot-deposit-product-server; beanName mapping: Look up the table based on the service type; methodName: Inferred from the BOC name; End node generation rules: ATS service output table → endCompConf.paramMappingList[]; Interruption node generation rules: Error code ErrCode003 / 004 / 005 → handleErrorService component.

5. The microservice process orchestration method based on AI agent technology according to claim 1, characterized in that, Step S4: Edge generation specifically includes: Sequential edge generation rule: Connect adjacent nodes sequentially according to the "step number" order in the ATS table calling instructions; Conditional edge generation rules: Generate conditional branch edges based on the conditional expressions defined by the ACS error codes. Cyclic edge generation rule: When the process contains cyclic logic, generate edges with special markings.

6. The microservice process orchestration method based on AI agent technology according to claim 1, characterized in that, Step S5: Topology verification specifically includes: verifying that the generated flowchart satisfies convergence constraints.

Images