Intelligent collaboration method and device based on CAX and medium

Abstract

The embodiment of the invention discloses an intelligent collaboration method and device based on CAX and a medium, and relates to the technical field of intelligent collaboration.The method comprises the steps that a natural language design requirement input by a user is received, multi-modal retrieval is conducted on the natural language design requirement in a preset CAX tool library, a candidate tool set is determined, and the candidate tool set is stored in the CAX tool library; pre-verifying the candidate tool set in a lightweight sandbox, and screening executable tools; according to the natural language design requirement, potential multi-field constraint conflicts are identified in a preset unified industrial semantic network, automatic conflict resolution is carried out among a plurality of professional agents through an A2A protocol based on a predefined negotiation rule, and an executable task sequence is generated; and calling the executable tool to execute the corresponding CAX operation according to the executable task sequence through the plurality of professional agents, so as to realize intelligent collaboration.

Description

Technical Field

[0001] This specification relates to the field of intelligent collaboration technology, and in particular to an intelligent collaboration method, device and medium based on CAX. Background Technology

[0002] Computer-aided technologies (CAX), including computer-aided design (CAD), computer-aided engineering (CAE), and computer-aided manufacturing (CAM), are the core pillars of modern product development. Traditionally, these fields have been operated in stages and in isolation by different software systems and professionals, resulting in broken data chains between design, simulation, and manufacturing, long iteration cycles, and heavy reliance on engineers' experience for cross-domain coordination.

[0003] In recent years, with the development of artificial intelligence and multi-agent system technologies, solutions aimed at automating CAX processes have emerged. For example, existing technologies (such as 202510569628.1) disclose a multi-agent computer-aided engineering and computer-aided design method that can understand users' natural language commands and automatically invoke CAD or CAE software to perform single-domain tasks such as modeling and simulation. These systems significantly lower the operational threshold for specific software and achieve task-level automation. However, the agent collaboration mode in existing technologies is essentially a sequential execution or task distribution and result collection driven by preset rules. For example, after the CAD modeling agent completes the design, it passes the model to the CAE simulation agent for analysis. If the result does not meet the requirements, the system iterates according to preset rules (such as returning to the previous step to modify parameters). When a design requirement involves multiple constraints such as geometric design, physical performance, and manufacturing process, professional intelligent agents from different fields, such as structural design agents, thermal simulation agents, and manufacturability analysis agents, may arrive at contradictory conclusions or solutions based on their own goals and knowledge. Therefore, they cannot proactively foresee and identify potential conflicts before or during task execution. The typical approach is to report an error and stop the process, or simply roll back to the previous step for the user to manually adjust. In reality, the most complex multi-objective trade-offs and decision-making work is left to the user, failing to achieve true intelligent collaboration. Automated processes are prone to interruption at such critical decision points.

[0004] Therefore, in the intelligent collaboration process of CAX, it is impossible to proactively foresee and identify potential conflicts before or during task execution. The intelligent agent communication is only used to transmit task instructions or fixed-format result data, which cannot meet the needs of intelligent collaboration. Summary of the Invention

[0005] This specification provides one or more embodiments of a CAX-based intelligent collaboration method, device, and medium to solve the following technical problem: In the intelligent collaboration process of CAX, it is impossible to proactively foresee and identify potential conflicts before or during task execution, and the intelligent agent communication is only used to transmit task instructions or fixed-format result data, which cannot meet the needs of intelligent collaboration.

[0006] One or more embodiments of this specification employ the following technical solutions: This specification provides one or more embodiments of a CAX-based intelligent collaboration method, the method comprising: receiving natural language design requirements input by a user; performing multimodal retrieval on the natural language design requirements in a preset CAX tool library to determine a candidate toolset; pre-validating the candidate toolset in a lightweight sandbox to screen executable tools; identifying potential multi-domain constraint conflicts in a preset unified industrial semantic network based on the natural language design requirements; automatically resolving conflicts among multiple professional intelligent agents based on predefined negotiation rules via an A2A protocol to generate an executable task sequence; and calling the executable tools to perform corresponding CAX operations through the multiple professional intelligent agents according to the executable task sequence to achieve intelligent collaboration.

[0007] This specification provides one or more embodiments of a CAX-based intelligent collaborative device, comprising: At least one processor; and, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform the above-described method.

[0008] This specification provides one or more embodiments of a non-volatile computer storage medium storing computer-executable instructions configured to perform the above-described method.

[0009] The above-described at least one technical solution adopted in the embodiments of this specification can achieve the following beneficial effects: By constructing and utilizing a unified industrial semantic network, the problem of machine-understandable and computable representation of cross-domain knowledge is solved. The unified industrial semantic network abstracts heterogeneous data scattered across design specifications, geometric models, simulation configurations, and process databases into nodes with rich attributes and their relational edges. This transforms multi-domain relational constraints, which traditionally rely on engineers' experience for interpretation, into explicit digital objects that can be directly traversed, retrieved, and reasoned about by algorithms. Based on the unified industrial semantic network, the network enables the proactive identification of multi-domain constraint conflicts and autonomous resolution based on multi-agent negotiation. Using a restricted graph traversal algorithm, starting from newly introduced design requirement nodes, it actively probes the predefined conflict relationships between these nodes and existing simulation condition nodes and manufacturing resource nodes in the network. This transforms the traditional passive error detection in the later stages into an early proactive risk warning. Each professional agent, representing the interests of its domain, generates and quantifies conflict resolution solutions based on its internal objective function and historical experience data. The negotiation process comprehensively considers the technical preferences of each domain and the effectiveness of historical solutions, ultimately reaching a consensus through predetermined decision-making rules. By integrating semantic and geometric features in multimodal retrieval, the system ensures that the candidate tools selected from the vast tool library are highly matched in terms of functional intent. The subsequent introduction of a lightweight sandbox pre-validation step allows for functional verification of the tools in an isolated and controlled environment using parameters derived from real-world requirements before they are formally scheduled. This effectively eliminates runtime failure risks caused by environmental dependencies, license expiration, or parameter incompatibility, enabling the executable task sequences planned by the intelligent agent to be deterministically and uninterruptedly transformed into actual computer-aided software operations, thus achieving intelligent collaboration within CAX. Attached Figure Description

[0010] To more clearly illustrate the technical solutions in the embodiments or prior art of this specification, the drawings used in the description of the embodiments or prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort. In the drawings: Figure 1 A flowchart illustrating a CAX-based intelligent collaboration method provided in the embodiments of this specification; Figure 2 This is a schematic diagram of the structure of a CAX-based intelligent collaborative device provided in the embodiments of this specification. Detailed Implementation

[0011] To enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this specification, and not all embodiments. Based on the embodiments of this specification, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of this specification.

[0012] This specification provides a CAX-based intelligent collaboration method. It should be noted that the execution subject in this specification can be a server or any device with data processing capabilities. Figure 1 A flowchart illustrating a CAX-based intelligent collaboration method provided in this specification is shown below. Figure 1 As shown, the main steps include the following: Step S101: Receive the natural language design requirements input by the user, perform multimodal retrieval of the natural language design requirements in the preset CAX tool library, determine the candidate toolset, and pre-validate the candidate toolset in a lightweight sandbox to screen executable tools.

[0013] In one embodiment of this specification, the user-inputted natural language design requirements are first obtained. The user-inputted natural language design requirements are received through the natural language interface, such as a descriptive text describing the product's functions, performance indicators, or process requirements, for example, designing a load-bearing bracket with a thickness of not less than 10mm, requiring static analysis, and suitable for milling. Then, a multimodal search is performed on the natural language design requirements in a preset CAX tool library to determine the candidate toolset.

[0014] Specifically, this is achieved through the following method: semantic parsing of the natural language design requirements, extracting key design parameters and at least one constraint; calling a pre-trained domain-specific large language model (such as a BERT or GPT model fine-tuned by CAX professional text) to perform semantic parsing of the natural language design requirements; identifying and extracting key design parameters (such as the implicit geometric function of the load-bearing bracket, the numerical parameter of a 10mm thickness) and at least one constraint through the model's internal attention mechanism. The constraints include geometric constraints, physical constraints, or process constraints. That is, in the CAX context, the constraints are classified as geometric constraints (such as shape, size, tolerance), physical constraints (such as load, material properties, allowable stress), and process constraints (such as milling methods, surface roughness). Based on the textual descriptions in the key design parameters and constraints, a first query vector is generated. After parsing, these unstructured textual descriptions are transformed into structured data objects. Subsequently, a general text embedding model (such as Sentence-BERT) is used to encode the overall text description containing key design parameters and constraints (e.g., load-bearing bracket, thickness requirements, static analysis, milling) into a high-dimensional semantically dense first query vector. It should be noted that the first query vector captures the overall semantic intent of the user's needs.

[0015] Conventional methods typically rely on keyword matching based on tool names or simple tags, failing to grasp the deep engineering intent and multidimensional constraints implied in users' complex and coherent natural language descriptions. For example, if a user requests the design of a lightweight and easily castable connector, traditional methods might return a large number of irrelevant tools due to matching discrete keywords such as "design" and "casting." This solution, however, uses a large language model for deep semantic parsing, mapping lightweight to physical constraints (such as topology optimization and quality objectives), and easily castable to process constraints (such as draft angle and wall thickness uniformity). It then comprehensively generates query vectors representing complex intents, enabling retrieval to transcend surface-level vocabulary and reach the core of engineering semantics, significantly improving the accuracy and relevance of tool recall.

[0016] Next, it is determined whether the natural language design requirements contain any associated user-specified geometric elements. If so, the type and size information of the geometric elements are encoded to determine the second query vector. Specifically, it is determined whether the description of the natural language design requirements explicitly or implicitly associates with specific user-specified geometric elements through the dialogue context, such as mentioning modifying the diameter of a circular hole in the previous model or uploading a reference STEP file. If so, the boundary representation (B-Rep) data of the geometric element is read through the application programming interface (API) of the geometry kernel (such as ACIS or Parasolid) integrated into the platform. Its type (such as cylindrical surface, plane) and size information (such as diameter, length) are parsed out, and a neural network encoder specifically trained for geometric shape classification and parametric regression is used to encode this structured geometric information into a second query vector aligned with the text vector space, thereby semanticizing the geometric form.

[0017] Conventional methods often overlook the strong coupling between design requirements and geometry in the CAX domain. User requirements are rarely isolated text but are presented within a specific geometric context. This solution introduces real-time encoding of user-specified geometric elements to generate a second query vector. This means that when a user requests stress analysis of the mounting holes in a bracket, the system not only understands the stress analysis task but also the type (through hole / blind hole) and size of the specific geometric feature of the mounting hole. This allows for the priority retrieval of simulation tools specifically designed for stress concentration analysis of hole features or supporting corresponding boundary condition loading, rather than general-purpose structural analysis tools.

[0018] On the other hand, the pre-built CAX tool library is constructed offline. Platform administrators or tool developers use standardized scripts to generate structured description files (such as JSON format) for each CAX tool, such as the ANSYS static analysis tool and the SolidWorks tensile cut tool. The structured description file contains two core parts: first, a paragraph providing a detailed textual description of the tool's functionality, such as "This tool is used to perform linear static structural analysis, it can define fixed constraints, force loads, and output stress contour maps and deformation results." This paragraph is encoded into a fixed capability vector using the same text embedding model. Second, an enumeration list of geometric feature types supported by the tool, extracted programmatically from the tool's encapsulation code or manually defined, such as cylindrical holes, chamfers, and tensile bosses. Each feature type in this list also corresponds to a pre-generated feature vector derived from an independent geometric feature word vector table. After determining the first and second query vectors, the pre-generated structured description file for each CAX tool in the pre-built CAX tool library is read. This structured description file includes at least the capability vector obtained by textually encoding the tool's functionality, and an enumeration list of geometric feature types supported by the CAX tool. By pre-generating structured description files for each tool and encoding their core functional descriptions into high-dimensional capability vectors, a continuous semantic space for tool capabilities is essentially constructed. Similarity calculations are performed within this space, enabling tools with similar functional descriptions but different expressions (such as structural mechanics analysis and static strength calculation) to be automatically associated, significantly enhancing semantic generalization ability and recall. Simultaneously, the explicit management and quantization of the enumerated list of geometric features supported by each tool provides a target for accurate comparison of the second query vector, ensuring the feasibility of the retrieval results at the geometric operation level.

[0019] Calculate a first similarity score between the first query vector and the capability vector of each CAX tool. If a second query vector exists, calculate a second similarity score between the second query vector and the feature vector corresponding to the geometric feature type enumeration list of each CAX tool. During retrieval, calculate the cosine similarity between the first query vector and the capability vector of each CAX tool in the tool library to obtain the first similarity score, which reflects the semantic matching degree between the user's textual requirements and the tool's functional description. If the user's requirements contain geometric elements and generate a second query vector, calculate the maximum cosine similarity between the second query vector and each feature vector in the tool's geometric feature enumeration list, which represents the matching degree with the most relevant feature of the tool and serves as the second similarity score.

[0020] All CAX tools are ranked based on the first similarity score or a weighted sum of the first and second similarity scores. When geometric elements exist, the weighted sum of the first and second similarity scores is used, with weights empirically set to 0.7 and 0.3 to balance semantics and geometry. If no geometric elements exist, only the first similarity score is used. A predetermined number of CAX tools ranked at the top of the ranking are selected to determine the candidate toolset. This means selecting the top N CAX tools (N being a predetermined number, such as 5) to determine the candidate toolset required for this task, for pre-validation in subsequent steps. By dynamically weighting and merging semantic matching (first similarity score) and geometric feature matching (second similarity score) and ranking them comprehensively, multi-granularity intelligent filtering is achieved. First, it ensures that the found tools are correct in terms of task intent (semantic level), and then ensures that the tool can efficiently and directly handle the specific geometric objects that the user cares about (geometric level). This retrieval mechanism significantly reduces the risk of selecting unsuitable or inefficient tools for complex CAX tasks from the outset, reduces the chain reaction of subsequent simulation failures and manufacturing infeasibility caused by improper tool selection, and improves the first-time success rate and overall efficiency of the entire intelligent collaborative process.

[0021] In traditional CAX automation processes or intelligent agent systems, the invocation of external tools or plugins often adopts a passive strategy of direct invocation and failure handling. That is, within a planned task sequence, the agent only attempts to load and execute a tool in the shared system environment when it needs it. This approach has significant risks and efficiency bottlenecks. First, complex CAX software (such as CAD kernels and CAE solvers) is extremely sensitive to operating system environments, library dependency versions, and license authorization status. In a shared environment, conflicts or inconsistencies can easily lead to invocation failures, and these failures usually only surface midway through task execution, causing process interruptions and wasted computational resources. Second, even environment-compatible tools have strict requirements on the format and range of input parameters. Parameter mismatches can lead to internal tool errors or meaningless output. These semantic-level errors are difficult to distinguish from simple environmental faults afterward, increasing the complexity of diagnosis and recovery. This technical solution introduces a lightweight sandbox pre-verification, moving tool reliability verification from runtime to before scheduling. The candidate toolset is pre-verified in a lightweight sandbox to screen executable tools, specifically including: For each CAX tool in the candidate toolset, create a container instance, for example, using containerization technologies such as Docker to create an isolated container instance, to determine the corresponding lightweight sandbox environment. The container image is based on a pre-prepared, streamlined operating system base image (such as Alpine Linux) with unnecessary components removed, and only includes the lowest-level runtime dependencies declared by the CAX tool, such as a specific version of the Java Runtime, Python interpreter, or a lightweight runtime engine for CAD / CAE software. At creation time, configure the instance's resource limits (such as the number of CPU cores and memory limits) and isolated network namespaces through the container engine's application programming interface (API) to ensure that execution processes do not interfere with each other and resources are controllable.

[0022] Obtain the structured description file of the CAX tool and load it into the container instance to simulate a minimal tool invocation scenario. The structured description file of a CAX tool is typically in JSON format. Besides containing capability vectors and feature enumeration lists for retrieval, the file also specifically defines validation script fragment fields and input parameter pattern fields. Load this description file into the file system of the container instance created for the tool via mounting a container volume or direct injection to simulate a minimal tool invocation scenario. This means preparing only the most basic environment and invocation definitions required for the tool to run, rather than deploying its complete graphical interface or all functional modules.

[0023] Based on the key design parameters in the natural language design requirements, test parameters conforming to the input parameter pattern of the CAX tool are generated. Based on the key design parameters parsed from the natural language design requirements, and combined with the parameter names, types, formats, and legal value ranges defined in the input parameter pattern field of the structured description file (for example, the parameter pattern of a rounded corner tool might be {"edge_list":[array],"radius":{"type":"float","min": 0.1}}), test parameters conforming to this pattern are dynamically generated. The generation strategy can be to use the pattern definition of the parameter pattern to generate default values, such as taking a median value within the legal range for the radius parameter, or to extract specific values ​​from the user requirements, such as a thickness of 10mm explicitly specified by the user.

[0024] Within the container instance, the verification script snippet is executed, passing the test parameters as input. The execution process of the container instance is monitored, capturing the corresponding standard output stream, standard error stream, and final exit code. Inside the container instance, the verification script snippet defined in the description file is executed. This snippet is script code used to verify the availability of the tool's core functionality, such as a Python script that calls the command-line interface or API function provided by the CAX tool, passing in a set of predefined simple geometric data for a minimal operation. The previously generated test parameters are passed as input to this script. During execution, the execution process of the container instance is monitored through the container runtime interface, capturing in real time the generated standard output stream (stdout), standard error stream (stderr), and the final exit code (exit code) after process completion. Finally, these three captured results are analyzed according to predefined verification success rules. According to predefined successful verification rules, the standard output stream, standard error stream, and final exit code are analyzed. These rules require the final exit code to be 0 (indicating normal exit); the standard error stream to be empty or contain only ignorable warning messages (determined through predefined regular expression pattern matching); and the standard output stream to contain the expected successful completion flag string or a valid result data fragment that can be parsed. If the analysis results meet the successful verification rules, the CAX tool passes pre-verification and is added to the executable tool set. If all analysis results meet the successful verification rules, the CAX tool passes pre-verification in the current sandbox environment, and its runtime dependencies, licenses, and core API connectivity are confirmed to be normal, thus adding it to the final executable tool set and allowing it to enter the subsequent formal task sequence execution phase. If any rule is not met, it means the tool has configuration or compatibility issues in the current context, will be flagged and excluded, and this event will be logged for system maintenance and user notification.

[0025] A lightweight sandbox container was constructed that is logically consistent with the final production environment, but highly constrained in terms of resource consumption and lifecycle. Each candidate tool, before being approved for entry into the formal collaborative workflow, must undergo a complete closed-loop functional trial run using parameters derived from real user needs. This not only verifies the existence and loading capability of the tool's binary file (traditional heartbeat detection can only do this much), but more importantly, it verifies the unobstructed flow of the complete data path from parameter input to result output under specific parameters. The sandbox's isolation ensures that this test does not pollute the shared environment or interfere with other tasks. In the face of a logically complex multi-agent collaborative network, it pre-filters and isolates the risk of systemic failure due to abnormal tool states. In subsequent multi-agent collaborative planning and conflict resolution, the planning algorithm can be confident that the executors (i.e., the tools in the executable tool set) assigning tasks are currently available. This provides a solid foundation for the feasibility of task decomposition, sequence generation, and conflict negotiation schemes based on these tool capabilities, greatly improving the first-time success rate of the entire intelligent collaborative process and avoiding the fragile problem of upper-level intelligent decision-making failing entirely due to the unavailability of underlying tools.

[0026] Step S102: Based on the natural language design requirements, identify potential multi-domain constraint conflicts in the preset unified industrial semantic network, and automatically resolve conflicts among multiple professional intelligent agents through the A2A protocol based on predefined negotiation rules to generate an executable task sequence.

[0027] In one embodiment of this specification, a unified industrial semantic network is constructed by first acquiring multi-source heterogeneous CAX data from CAD model files, CAE simulation configuration files, CAM process databases, and design specification documents. Specifically, data from multiple sources is acquired through file system interfaces or network APIs, including CAD model files stored in STEP or specific CAD software native formats (such as SLDPRT, IPT); CAE simulation configuration files existing in text formats (such as ANSYS APDL command streams, Abaqus INP files) or structured data (such as XML); CAM process databases stored in relational databases (such as MySQL, PostgreSQL) or time-series databases, whose table structures typically contain information such as machine tools, cutting tools, and material libraries; and design specification documents existing in PDF, DOCX, or structured Wiki formats. This data is collectively referred to as multi-source heterogeneous CAX data.

[0028] Subsequently, the CAD model file is parsed to extract parametric features, geometric entities, and assembly constraints between these entities. A first-class node is created for each parametric feature and / or geometric entity, and relational edges between nodes are created based on these assembly constraints. Specifically, an integrated geometry kernel (such as Open CASCADE) or a lightweight read API of the CAD software is invoked to parse the CAD model file. The parsing process traverses the model's feature tree, extracting defined parametric features (such as Extrusion-1 and Hole-2, including their driving dimensions and position sketches), geometric entities (such as Face-001 and Edge-002 represented by B-Rep), and assembly constraints (such as coincidence, coaxiality, and distance) existing in the assembly file that describe the relative positions and movements between parts. When constructing the semantic network, a first-class node is created for each parametric feature (such as Extrusion-1) and / or geometric entity (such as Face-001). The node's attributes store its name, unique identifier, geometry type, and parameter information. At the same time, based on the extracted assembly constraint relationship, a relationship edge connecting the relevant first-type nodes is created. This edge has a constraint type attribute, such as coincidence.

[0029] Next, the CAE simulation configuration file is parsed to extract physical material properties, load cases, boundary conditions, and physical field types. A second type of node is created for each physical material property and / or physical material property, and the first type of nodes associated with this second type of node are connected via relational edges of a preset type, including applied and constrained types. Specifically, a dedicated parser is used to parse the CAE simulation configuration file, extracting the defined physical material properties (such as elastic modulus, density), load cases (such as force, pressure, torque), boundary conditions (such as fixed constraints, displacement constraints), and physical field types (such as statics, thermodynamics, fluid dynamics) through syntax analysis and pattern matching. For each unique material property (such as Material:Steel_A) and each load / boundary condition (such as Load:Bearing_Force), a second type of node is created, with its physical quantity value and unit recorded in the node attributes. The parser identifies the geometric entities referenced in the configuration file; for example, a load is applied to a surface named face-001, and accordingly connects the first type of nodes associated with the second type of node via relational edges of a preset type. The preset types here mainly include Apply to (used to connect load nodes and geometric entity nodes) and Constrain to (used to connect boundary condition nodes and geometric entity nodes), thereby establishing a clear association between physical conditions and geometric carriers.

[0030] Subsequently, the CAM process database is parsed to extract manufacturing resources and machining constraints. Each manufacturing resource and / or machining constraint is created as a third-class node. The manufacturing resource includes machine tool capabilities, tool parameters, machining accuracy limits, and machinable feature types. The CAM process database is parsed via a database query interface, executing SQL queries or calling APIs to extract the defined manufacturing resources (e.g., maximum stroke and spindle speed range for a specific machine tool (MachineCenter:MC-5AX); diameter and cutting edge length for a specific tool (Tool: BallNose_10mm)) and machining constraints (e.g., maximum recommended cutting speed and minimum machinable fillet radius for aluminum alloys). Each manufacturing resource and / or machining constraint is then created as a third-class node, and its attributes are populated.

[0031] Finally, based on a predefined conflict rule template, multiple conflict relationship edges are created between the first type of node, the second type of node, and the third type of node. Each conflict relationship edge is associated with a conflict type and an initial third-order weight. The conflict types include geometric conflict, physical conflict, and process conflict, and the third-order weights include design-level weights, process-level weights, and manufacturing-level weights. All nodes and relationship edges are stored in a graph database to form this unified industrial semantic network. It should be noted that the conflict types here are the design, process, and manufacturing third-order constraint conflict types unique to the CAX domain, which solves the problem of repeated modifications caused by the disconnect between design, process, and manufacturing in traditional CAX systems. Geometric conflicts are conflicts between geometric features in CAD design and machinable feature types in CAM process. For example, a small curved surface in the design conflicts with the minimum radius of curvature that cannot be machined by CAM equipment. When the geometric entity in the first type of node does not match the machinable feature type in the third type of node, it is identified as a geometric conflict. For example, a small curved surface in the design (radius less than 0.5 mm) conflicts with the minimum radius of curvature that cannot be machined in CAM process (e.g., ≥1.0 mm). The conflict type is identified as a geometric conflict. In the initial three-level weights under geometric conflict, the design layer weight is 45%, the process layer weight is 35%, and the manufacturing layer weight is 20%. Physical conflict refers to the conflict between the physical properties required in CAE simulation and the processing stress that can be withstood in CAM process. When the physical properties required by CAE simulation in the second type of node do not match the CAM process constraints in the third type of node, a physical conflict is identified. For example, the material strength required by CAE simulation (≥500MPa) conflicts with the maximum processing stress that can be withstood in CAM process (≤450MPa). The conflict type is identified as physical conflict, and the initial three-level weights are 30% for the design layer, 40% for the process layer, and 30% for the manufacturing layer. Process conflict refers to the conflict between the machining accuracy requirements in CAM process and the allowable deformation in CAE simulation. When the allowable deformation in CAE simulation in the second type of node does not match the CAM process accuracy requirements in the third type of node, a process conflict is identified. For example, the allowable deformation in CAE simulation (≤0.05mm) conflicts with the accuracy required by CAM process (≤0.03mm). The conflict type is identified as process conflict, and the initial three-level weights are 25% for the design layer, 30% for the process layer, and 45% for the manufacturing layer. It should be noted that the above-mentioned third-order weights are based on statistical analysis results from actual engineering experience in the CAX domain. Based on the CAX domain's unique third-order conflict rule templates for design, process, and manufacturing, multiple conflict relationship edges are created between the first, second, and third types of nodes. The conflict rule templates can be if-then logical expressions, predefined by domain experts.For example, a geometric conflict rule template might be defined as: "If (the first type of node feature type = 'small surface', and the minimum radius of curvature of that surface < (the third type of node machine tool type can machine the minimum radius of curvature)), then create a conflict relationship edge between these two nodes, conflict type = geometric conflict." Similarly, a physical conflict rule template checks whether the material yield strength in the second type of node is lower than the estimated machining stress in the CAM process node; a process conflict rule template compares the machining accuracy of CAM with the deformation allowed by CAE. Finally, using a client library of a graph database (such as Neo4j, JanusGraph), all nodes and relationship edges (including ordinary edges representing associations and conflict relationship edges representing conflicts) are stored in the graph database, thus forming an interconnected, queryable, unified industrial semantic network.

[0032] In the CAX field, the disconnect between design, process, and manufacturing is the core problem leading to repeated design modifications. In traditional CAX systems, CAD design, CAE simulation, and CAM process operate independently, lacking a unified conflict identification mechanism. This specification's embodiments introduce three conflict types unique to the CAX field, enabling accurate identification of conflicts between design, process, and manufacturing, thus solving the problem of inaccurate conflict identification in existing technologies.

[0033] Based on the natural language design requirements, potential multi-domain constraint conflicts are identified in the pre-defined unified industrial semantic network, specifically through the following methods: The key design parameters and constraints in the natural language design requirements are mapped to one or more entity nodes in the unified industrial semantic network, forming the first set of entity nodes. The structured objects parsed in the previous steps, such as the key parameter "support thickness = 10mm" and the constraint "material = aluminum alloy, yield strength > 250MPa," are matched with nodes stored in the graph database. The matching algorithm is based on node attributes. For example, if a geometric feature node exists in the network with the feature type attribute "plate structure" and the thickness attribute close to 10mm, then that node is mapped. Simultaneously, the graph database is queried for material attribute nodes, looking for nodes whose material name is "aluminum alloy" and whose yield strength attribute value is greater than 250MPa. All network nodes found through this attribute similarity calculation or exact matching constitute the first set of entity nodes.

[0034] Subsequently, a network exploration is initiated with this set as the root. Each entity node in the first entity node set is used as a starting point, and a traversal search is performed along the relational edges within the unified industrial semantic network. The depth of this traversal search is limited to a predetermined number of hops. The breadth-first search (BFS) algorithm is used to ensure that closely related conflicts directly associated with the starting point are discovered first. Limiting the traversal search depth to a predetermined number of hops (e.g., 3 hops) is beneficial because in engineering semantic networks, the correlation between nodes beyond a certain distance typically weakens sharply. Limiting the depth balances computational efficiency and search completeness, avoiding infinite loops or irrelevant traversals.

[0035] First, initialize the queue of nodes to be visited and the set of visited nodes. For the current starting node, add it to both the queue and the set. Then, iterate through the following steps: Take any node from the queue of nodes to be visited as the current node, and traverse each adjacency edge of that current node. For each adjacency edge, determine if it is a conflict edge. Conflict edges include geometric conflicts, physical conflicts, and technological conflicts; that is, whether the relationship type attribute is one of these three types of conflicts. If so, record the adjacency edge in the set of conflict edges. Regardless of whether it is a conflict edge, the algorithm considers the node at the other end of the edge. For each adjacency node connected to the current node by a non-conflict edge (i.e., a normal relationship edge, such as "applied to" or "belongs to"), if the adjacency node is not recorded in the set of visited nodes and the current traversal depth has not exceeded the predetermined number of hops, add it to the queue of nodes to be visited and the set of visited nodes to ensure subsequent visits. This loop continues until the queue of nodes to be visited is empty, meaning that all reachable nodes within the depth limit have been visited from the current starting point. After completing the breadth-first traversal with all entity nodes in the first entity node set as the starting node, merge all conflicting edges recorded during the traversal process, remove duplicate records that may be generated due to different starting points visiting the same edge, and determine the set of conflicting edges.

[0036] During the traversal, at least one conflicting edge is identified, and the two entity nodes connected to each conflicting edge are obtained. It is then determined whether the two entity nodes belong to different CAX domains. If so, the two entity nodes are identified as a multi-domain constraint conflict pair to aggregate at least one such multi-domain constraint conflict pair and generate a conflict list. Specifically, when accessing each edge, its predefined relationship type attribute is checked. If the attribute value is one of geometric conflict, physical conflict, or process conflict, the edge is determined to be a conflicting edge. The two entity nodes connected to each conflicting edge are obtained by reading the start and end node identifiers of the edge. Next, it is determined whether the two entity nodes belong to different CAX domains. Each node is assigned a domain attribute upon creation, such as CAD, CAE, or CAM. For example, if one node's domain is CAD (representing design features) and another node's domain is CAM (representing manufacturing constraints), and the edge connecting them is a geometric conflict type, then they clearly belong to different domains. If so, the two entity nodes are identified as a multi-domain constraint conflict pair. This judgment ensures that the focus is on conflicts that truly require cross-domain coordination, while ignoring issues within the same domain that may have already been handled by specialized tools. The traversal process is performed independently for each starting point in the first entity node set. After summarizing at least one multi-domain constraint conflict pair, a conflict list is generated. Each entry in this list contains the IDs of the two nodes in the conflict pair, the type and weight of the conflict relation edge connecting them. The entire process is closely integrated with the three-order scenarios of design, process, and manufacturing in the CAX domain. For example, the traversal may find a geometric conflict edge connecting a small radius of curvature surface in CAD design (design) and the minimum machinable radius of curvature of a CAM machine tool (manufacturing), which is a typical cross-order conflict between design and manufacturing.

[0037] Compared to conventional CAX processes that rely on expert experience for phased reviews or employ isolated rule checkers, this technical solution encodes the entire CAX knowledge system as an interconnected graph and utilizes graph traversal algorithms to simulate context-based influence chain tracing and risk detection. When a user submits design requirements, the breadth-first traversal algorithm starts from the newly input requirement node and explores outward along various pre-established relational edges (such as those imposed on, constrained by, and manufacturable). Essentially, this behavior actively queries CAE conditions related to the new design, such as finding loads through the imposed edge, identifying material requirements through node attributes, and determining whether the currently planned manufacturing resources can meet the manufacturability of this material (by searching through manufacturable relationships or conflict edges). The entire traversal process takes place within a unified semantic space containing entities and relationships from multiple domains, thus breaking down data barriers between domains. Depth constraints ensure the feasibility of the search, avoiding blind wandering in massive networks. The step of determining whether nodes belong to different CAX domains enhances the targeting and value of early warnings, eliminating issues that may already have mature solutions or be considered specialized details within the same domain, and precisely focusing on systemic conflicts that must be resolved through cross-domain negotiation. The conflict list generated by this scheme allows subsequent agent negotiation to be conducted on a mutually understood and semantically complete basis, thereby greatly improving the efficiency of automatic negotiation and the likelihood of reaching a feasible solution, and fundamentally reducing the risk of later modifications due to inconsistencies in cross-domain constraints.

[0038] Based on predefined negotiation rules, automatic conflict resolution is performed among multiple specialized intelligent agents via an A2A protocol to generate an executable task sequence, specifically implemented in the following ways: First, from the multi-domain constraint conflict pairs in the conflict list, the current conflict pair to be negotiated is identified. By querying the domain and responsible agent attributes of the two entity nodes constituting the conflict pair in the Unified Industrial Semantic Network, at least two relevant professional agents related to the current conflict pair to be negotiated are identified. For example, a geometric conflict pair may involve a CAD design feature node (whose responsible agent is a design agent) and a CAM machining constraint node (whose responsible agent is a manufacturing agent). The network communication addresses (such as IP addresses and ports) or message queue topics of these agents are found through the agent registry. Through the negotiation initiating agent, a tender message containing a conflict description is generated according to the type of the current conflict pair to be negotiated, and the tender message is sent to the relevant professional agent through the A2A protocol. The negotiation initiating agent encapsulates the identified conflict type, conflict description, and dynamically calculated third-order weights (such as 45%, 35%, and 20% for geometric constraint conflicts) into a tender message, and sends it to the relevant professional agent through the A2A protocol. The tender message explicitly includes the third-order weight allocation ratio to ensure that the agent follows the weight rules specific to the CAX domain when generating bidding proposals. It should be noted that when multiple conflict types exist, such as simultaneous geometric constraint conflicts and process constraint conflicts, the comprehensive weight is calculated as follows to determine the three-level weight allocation ratio: Weighted average weight = (Conflict type 1 weight × Number of conflicts) + (Conflict type 2 weight × Number of conflicts) / Total number of conflicts. For example, if there is one geometric constraint conflict (45%, 35%, 20%) and one process constraint conflict (25%, 30%, 45%), then the corresponding design layer weight = (45% + 25%) / 2 = 35%, the process layer weight = (35% + 30%) / 2 = 32.5%, and the manufacturing layer weight = (20% + 45%) / 2 = 32.5%.

[0039] The relevant specialized intelligent agent obtains historical negotiation data related to the current conflict pair from the unified industrial semantic network. Based on the relevant specialized intelligent agent's internal objective function and historical negotiation data, it generates a bidding message and sends it back to the negotiation initiating intelligent agent via the A2A protocol. The A2A protocol is specifically implemented here as a point-to-point message delivery based on HTTP RESTful API calls or lightweight message middleware (such as ZeroMQ or RabbitMQ) to ensure reliable message delivery. After waiting for a preset timeout, the negotiation initiating intelligent agent collects all returned bidding messages. According to preset decision rules, the negotiation initiating intelligent agent sorts at least one solution proposal in the bidding message and selects the solution proposal that meets preset requirements to determine the negotiation consensus. The negotiation initiating intelligent agent sorts the comprehensive evaluation scores of the bidding messages from high to low according to the preset decision rules. The sorting does not directly use third-order weights; instead, it is based on the comprehensive evaluation score with pre-incorporated weights, selecting the solution with the highest comprehensive evaluation score to determine the negotiation consensus.

[0040] Based on the consensus reached, design parameters, simulation settings, and / or process planning related to the current conflict to be negotiated are adjusted or confirmed for automatic conflict resolution. This is achieved by executing modification instructions in the consensus scheme, updating the attribute values ​​of relevant nodes in the unified industrial semantic network, and potentially generating temporary design change nodes to record the adjustment. Subsequently, the conflict list is checked for any other unresolved conflicts; if so, the above process is repeated. It is important to note that resolving one conflict may introduce new conflicts or change the state of other conflicts; therefore, multiple iterations or re-evaluation of the conflict list are necessary in practice. Once all critical conflicts are resolved or the iteration limit is reached, the final executable task sequence is orchestrated according to the logical dependencies between each CAX operation. Logical dependencies are derived from temporal or causal edges in the unified industrial semantic network; for example, modeling must precede simulation, and process planning must precede CNC code generation. These dependencies are transformed into a directed acyclic graph and topologically sorted, outputting an ordered list of task steps. Each step is associated with a specific CAX tool and a precise set of parameters, which can be directly scheduled by the subsequent execution engine.

[0041] In the above steps, a bidding message is generated based on the internal objective function and historical negotiation data of the relevant professional intelligent agent. The specific implementation process is as follows: First, based on the conflict type in the tender message, at least one predefined solution proposal related to that conflict type is retrieved from the Unified Industrial Semantic Network (UIN) to obtain modification instructions for the CAX parameter set corresponding to each solution proposal. This is achieved by initiating a query to the graph database. The agent retrieves nodes and their attributes, based on its own ID and the conflict pair node IDs, of the type historical negotiation records. These attributes record the solutions proposed or accepted by the agent in similar past conflict scenarios and their final results (success / failure). Based on this information, the agent retrieves at least one predefined solution proposal related to that conflict type from the UIN according to the conflict type in the tender message. These solution proposals are stored in the UIN as conflict resolution template nodes. Each template node contains applicable conflict type attributes and modification instructions for a set of CAX parameter sets. The modification instructions can be mathematical expressions for parameter adjustments (e.g., radius = max(current radius, minimum equipment radius)) or descriptions of tool calls. Based on the modification instruction, the change in the internal objective function of the relevant professional intelligent agent is simulated to determine the first evaluation factor. The internal objective function is a mathematical quantification of the core optimization objective of each professional intelligent agent. For example, the objective function of a design intelligent agent might be structural quality, while the objective function of a manufacturing intelligent agent might be processing cost. The simulation calculates the change in the objective function value based on the current design state and the modification instruction, such as how much the quality increases or how much the cost decreases, and normalizes this change into a standardized score. The historical negotiation records connected to the nodes of the current conflicting pair in the unified industrial semantic network are queried to obtain the success rate of historically adopting the same solution proposal, and a second evaluation factor is determined. The success rate is the proportion of the number of times the proposal was adopted historically, reached a consensus, and was successfully verified out of the total number of adoptions. The first evaluation factor and the second evaluation factor are fused and calculated according to preset weights, such as using a weighted summation formula. The weights are preset by domain experts to balance current interests and historical experience, and a comprehensive evaluation score for the solution proposal is determined. The solution proposal and the corresponding comprehensive evaluation score are encapsulated to determine the bidding message.

[0042] The following is a specific implementation example. For instance, retrieving predefined solutions related to conflict types from the Unified Industrial Semantic Network, such as optimization schemes for small surfaces corresponding to geometric constraint conflicts, with the CAX parameter modification instruction for each solution being to adjust the surface radius from 0.4 mm to 1.0 mm. First, using the change in the internal objective function, the first evaluation factor is calculated: First evaluation factor = 1 - (Δdesign × design layer weight + Δprocess × process layer weight + Δmanufacturing × manufacturing layer weight), where Δdesign = |current design parameter - target design parameter| / target design parameter, Δprocess = |current process parameter - target process parameter| / target process parameter, and Δmanufacturing = |current manufacturing parameter - target manufacturing parameter| / target manufacturing parameter.

[0043] For example, in the case of a geometric constraint conflict, with the design layer at 45%, the process layer at 35%, and the manufacturing layer at 20%, if the design parameter is adjusted from 0.4mm to 1.0mm, then Δdesign = |0.4-1.0| / 1.0 = 0.6. If the process parameter adjustment does not change, then Δprocess = 0. If the manufacturing parameter adjustment does not change, then Δmanufacturing = 0. The corresponding first evaluation factor = 1-(0.6×0.45+0 × 0.35+0 × 0.20)=1-0.27=0.73. Next, the second evaluation factor, historical success rate, is calculated. Historical negotiation records related to the current conflict type are queried in the unified industrial semantic network to obtain the historical success rate of using the same solution. For example, in geometric constraint conflicts, the historical success rate of the small surface optimization solution is 85%. The second evaluation factor = historical success rate (percentage, e.g., 85%), and the corresponding comprehensive evaluation score = (first evaluation factor × 0.7) + (second evaluation factor × 0.3). With a first evaluation factor of 0.73 and a second evaluation factor of 85%, the comprehensive evaluation score = (0.73 × 0.7) + (85% × 0.3) = 0.511 + 0.255 = 0.766. The negotiation initiating agent sorts the comprehensive evaluation scores in the bidding messages (from high to low) according to preset decision rules. The sorting does not directly use third-order weights; instead, it is based on the comprehensive evaluation scores with pre-incorporated weights, selecting the solution with the highest comprehensive evaluation score to determine the negotiation consensus. For example, if solution A has a comprehensive score of 0.766 and solution B has a comprehensive score of 0.682, solution A is selected as the negotiation consensus.

[0044] In traditional CAX systems, CAD design, CAE simulation, and CAM process operate independently, lacking a unified conflict identification and resolution mechanism. This technical solution introduces a third-order collaborative rule specific to the CAX domain, transforming the unique technical problems of CAX into computable weight allocation rules. This achieves a unique technical solution for the CAX domain, addressing the issues of inaccurate conflict identification and low resolution efficiency in existing technologies. The third-order collaborative rule integrates the weight allocation of the design, process, and manufacturing layers into the conflict resolution process, effectively reducing the number of design changes. The release of the tender notice precisely defines the problem requiring optimization. The generation of the tender notice represents a local optimization and solution evaluation of the problem by each agent based on its own professional model and past experience. The final consensus reached based on the decision rules is a global comparison and selection of solutions. Because each tender proposal undergoes pre-evaluation by the proposing agent based on its internal professional objective function and references historical success rates, the final submitted proposal set possesses high professional rationality and historical feasibility, avoiding the subjectivity and bias of centralized decision-making. The entire negotiation process is conducted automatically between intelligent agents via the A2A protocol, enabling the design, simulation, and manufacturing cycles to operate at high speed in the digital space. This allows for the exploration of a broader design space and the earlier discovery and resolution of deep-seated conflicts.

[0045] Step S103: Through multiple specialized intelligent agents, executable tools are invoked to perform corresponding CAX operations according to the executable task sequence, thereby achieving intelligent collaboration.

[0046] The generated executable task sequence is a conflict-free set of automated work instructions obtained through natural language parsing, intelligent tool retrieval and verification, and multi-agent negotiation and resolution based on a unified industrial semantic network. This sequence exists in a structured data format (such as JSON or XML), explicitly containing a series of CAX operations that need to be executed sequentially to achieve the user's design goals. Each operation is associated with a specific executable tool (encapsulated by the MCP Server), precise input parameters, and the expected output type.

[0047] Multiple specialized intelligent agents are used to invoke executable tools to perform corresponding CAX operations based on a sequence of executable tasks. The specific implementation process is as follows: First, the task sequence is distributed and parsed. The coordinating agent (or the supervisor agent in a centralized structure) acting as the system's coordination center receives this executable task sequence. Based on the domain attributes (such as CAD geometry construction, CAE mechanical simulation, CAM toolpath generation) and logical dependencies of each CAX operation in the sequence, this agent dynamically assigns different sub-tasks to the corresponding specialized agents via an A2A communication protocol. For example, modeling instructions are sent to the design agent, simulation instructions to the simulation agent, and machining planning instructions to the manufacturing agent. Each specialized agent, upon receiving its assigned sub-task, parses it, extracting key execution elements, including the unique identifier of the target tool to be invoked, all input parameters required to invoke the tool (these parameters have been determined and optimized in the preceding negotiation and resolution phase), and the execution context of the operation, such as the location of the result data from previous operations.

[0048] Next, each specialized agent prepares and executes tool calls. Through the A2A communication protocol, specialized agents distributed across different modules or nodes are coordinated to collaboratively execute tasks. Based on the task requirements, the agent first confirms that the required tools are located in the executable tool set (this set has been pre-verified in a sandbox to ensure availability). Then, the agent constructs a standardized tool call request according to the MCP protocol specifications. This request is not simply a forwarding of parameters; rather, the agent, based on its understanding of the professional domain, transforms structured input parameters into a precise instruction format that the target tool can recognize. For example, when a design agent calls an extrusion feature modeling tool, it encapsulates the required sketch outline, extrusion depth, direction, and other parameters into script code or command streams that conform to the specific API requirements of the CAD software. Then, the agent sends this request to the MCP Server hosted in the corresponding CAX software environment via the MCP protocol client. The MCP Server acts as a bridge, receiving requests, parsing the tool identifiers and parameters, and executing corresponding functions in its local or remote CAX software (such as SOLIDWORKS, ANSYS, and CNC programming systems). For example, it can create 3D features in CAD software, start solving calculations in CAE software, or generate machining code in CAM systems.

[0049] During execution, end-to-end collaboration and monitoring are achieved. On one hand, the execution between agents follows the logical order defined by the task sequence, forming an automated workflow. After the preceding agent (such as the design agent) completes its tool call and generates output (such as a STEP format geometric model file), this output is automatically provided to subsequent agents (such as the simulation agent) as key input parameters through system shared storage or message passing mechanisms, thereby achieving seamless automatic transfer of design-simulation-manufacturing data. On the other hand, the real-time monitoring agent continuously monitors the execution status of all tool calls. It receives execution status information (such as in progress, successful completion, error) and raw result data returned from each MCP Server. The monitoring agent not only determines whether the call is successful at the syntactic level (such as normal process exit), but also performs preliminary semantic verification of the results based on domain knowledge. For example, for the result file returned by the simulation tool, the monitoring agent will analyze its key indicators (such as maximum stress, displacement) and compare them with the constraints defined in the unified industrial semantic network to ensure that the results are physically reasonable and meet the requirements.

[0050] It's important to note that the A2A communication protocol is used not only for task distribution but also to establish execution feedback pathways across CAX stages. After the design agent completes CAD parametric modeling, its output is automatically transmitted to the simulation agent via the A2A protocol. The simulation agent, based on the physical model, calculates performance deviations or risk indicators and then sends them back to the design agent via the A2A protocol to trigger local parameter reconstruction or structural adjustments. Simultaneously, the manufacturing agent performs manufacturability verification on the design results based on manufacturing constraints. Its feedback is injected as constraint information into subsequent tool retrieval and task decomposition processes, thus avoiding decisions based solely on a single stage's results. Through this approach, a closed-loop collaborative mechanism centered on industrial constraints and simulation feedback is formed among the agents, rather than a simple sequential task forwarding.

[0051] Finally, the results are integrated and the loop is closed. Once all CAX operations in the task sequence have been successfully executed and monitored, each specialized agent submits its final output (such as the final 3D model, simulation report, and CNC program) to the coordinating agent. The coordinating agent, or a dedicated report-generating agent, integrates all results to generate a structured design analysis and manufacturing comprehensive report, which, along with all generated design and manufacturing data files, is returned to the user. The entire process is autonomously driven by multiple agents, flexibly calling heterogeneous CAX tools through the MCP protocol, and ensuring the consistency and intelligence of decision-making at each stage through the A2A protocol and a unified industrial semantic network. This significantly reduces the complexity and frequency of human intervention, achieving true intelligent and automated execution of the CAX process.

[0052] The above-described at least one technical solution adopted in the embodiments of this specification can achieve the following beneficial effects: By constructing and utilizing a unified industrial semantic network, the problem of machine-understandable and computable representation of cross-domain knowledge is solved. The unified industrial semantic network abstracts heterogeneous data scattered across design specifications, geometric models, simulation configurations, and process databases into nodes with rich attributes and their relational edges. This transforms multi-domain relational constraints, which traditionally rely on engineers' experience for interpretation, into explicit digital objects that can be directly traversed, retrieved, and reasoned about by algorithms. Based on the unified industrial semantic network, the network enables the proactive identification of multi-domain constraint conflicts and autonomous resolution based on multi-agent negotiation. Using a restricted graph traversal algorithm, starting from newly introduced design requirement nodes, it actively probes the predefined conflict relationships between these nodes and existing simulation condition nodes and manufacturing resource nodes in the network. This transforms the traditional passive error detection in the later stages into an early proactive risk warning. Each professional agent, representing the interests of its domain, generates and quantifies conflict resolution solutions based on its internal objective function and historical experience data. The negotiation process comprehensively considers the technical preferences of each domain and the effectiveness of historical solutions, ultimately reaching a consensus through predetermined decision-making rules. By integrating semantic and geometric features in multimodal retrieval, the system ensures that the candidate tools selected from the vast tool library are highly matched in terms of functional intent. The subsequent introduction of a lightweight sandbox pre-validation step allows for functional verification of the tools in an isolated and controlled environment using parameters derived from real-world requirements before they are formally scheduled. This effectively eliminates runtime failure risks caused by environmental dependencies, license expiration, or parameter incompatibility, enabling the executable task sequences planned by the intelligent agent to be deterministically and uninterruptedly transformed into actual computer-aided software operations, thus achieving intelligent collaboration within CAX.

[0053] This specification also provides an embodiment of a CAX-based intelligent collaborative device, such as... Figure 2 As shown, the device includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the above-described method.

[0054] This specification also provides a non-volatile computer storage medium storing computer-executable instructions configured to perform the above-described method.

[0055] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the embodiments of apparatus, devices, and non-volatile computer storage media are basically similar to the method embodiments, so the descriptions are relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0056] The above description is merely one or more embodiments of this specification and is not intended to limit this specification. Various modifications and variations can be made to the one or more embodiments of this specification by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principle of one or more embodiments of this specification should be included within the scope of the claims of this specification.

Claims

1. A CAX-based intelligent collaboration method, characterized in that, The method includes: The system receives natural language design requirements input by the user, performs multimodal retrieval on the natural language design requirements in a preset CAX tool library, determines a candidate toolset, and pre-validates the candidate toolset in a lightweight sandbox to screen executable tools. Based on the natural language design requirements, potential multi-domain constraint conflicts are identified in the preset unified industrial semantic network. Based on predefined negotiation rules, automatic conflict resolution is carried out among multiple professional intelligent agents through the A2A protocol to generate an executable task sequence. Through the aforementioned multiple specialized intelligent agents, the executable tools are invoked to perform corresponding CAX operations according to the executable task sequence, thereby achieving intelligent collaboration.

2. The intelligent collaboration method based on CAX according to claim 1, characterized in that, In a pre-defined CAX toolkit, a multimodal search is performed on the natural language design requirements to determine a candidate toolset, specifically including: Semantic parsing is performed on the natural language design requirements to extract key design parameters and at least one constraint, so as to generate a first query vector based on the text description in the key design parameters and the constraint, wherein the constraint includes geometric constraints, physical constraints or process constraints. Determine whether there are any user-specified geometric elements associated with the natural language design requirements. If so, encode the type and size information of the geometric elements to determine the second query vector. Read the pre-generated structured description file of each CAX tool in the preset CAX tool library, wherein the structured description file includes at least a capability vector obtained by encoding the tool function description text, and an enumeration list of geometric feature types supported by the CAX tool; Calculate a first similarity score between the first query vector and the capability vector of each CAX tool; If the second query vector exists, then calculate the second similarity score between the second query vector and the feature vector corresponding to the geometric feature type enumeration list of each CAX tool; All CAX tools are sorted according to the first similarity score or the weighted sum of the first similarity score and the second similarity score, and a predetermined number of CAX tools ranked at the top of the sorting results are selected to determine the candidate toolset.

3. The intelligent collaboration method based on CAX according to claim 1, characterized in that, The candidate toolset is pre-validated in a lightweight sandbox to screen executable tools, specifically including: For each CAX tool in the candidate toolset, a container instance is created to determine the corresponding lightweight sandbox environment; Obtain the structured description file of the CAX tool to load it in the container instance, simulating a minimized tool invocation scenario; Based on the key design parameters in the natural language design requirements, generate test parameters that conform to the input parameter pattern of the CAX tool; In the container instance, the verification script fragment in the structured description file is executed, and the test parameters are passed to the verification script fragment as input. The execution process of the container instance is monitored, and the corresponding standard output stream, standard error stream and final exit code are captured. According to the predefined verification success rules, the standard output stream, the standard error stream, and the final exit code are analyzed. If the analysis result meets the verification success rules, the CAX tool is determined to have passed the pre-verification and can be added to the executable tool set. The verification success rules include a final exit code of 0, an empty standard error stream or only containing negligible warning information, and a standard output stream containing an expected successful completion identifier string or a valid result data fragment that can be parsed.

4. The intelligent collaboration method based on CAX according to claim 1, characterized in that, Before identifying potential multi-domain constraint conflicts in a pre-defined unified industrial semantic network, the method further includes: Acquire multi-source heterogeneous CAX data from CAD model files, CAE simulation configuration files, CAM process databases, and design specification documents; The CAD model file is parsed to extract parametric features, geometric entities, and assembly constraints between the geometric entities. A first type of node is created for each parametric feature and / or geometric entity, and relationship edges between nodes are created based on the assembly constraints. The CAE simulation configuration file is parsed to extract physical material properties, load conditions, boundary conditions and physical field types. A second type of node is created for each of the physical material properties and / or physical material properties. The first type of nodes related to the second type of node are connected by relation edges of a preset type, wherein the preset type includes applied type and constrained type. The CAM process database is parsed to extract manufacturing resources and processing constraints. Each type of manufacturing resource and / or processing constraint is created as a third type of node. The manufacturing resources include machine tool capabilities, tool parameters, processing accuracy constraints, and machinable feature types. Based on a predefined conflict rule template, multiple conflict relationship edges are created between the first type of node, the second type of node, and the third type of node. Each conflict relationship edge is associated with a conflict type and an initial third-order weight. The conflict types include geometric conflict, physical conflict, and process conflict. The third-order weights include design layer weights, process layer weights, and manufacturing layer weights. The nodes and relation edges are stored in a graph database to form the unified industrial semantic network.

5. The intelligent collaboration method based on CAX according to claim 1, characterized in that, Based on the aforementioned natural language design requirements, potential multi-domain constraint conflicts are identified within a pre-defined unified industrial semantic network, specifically including: The key design parameters and constraints in the natural language design requirements are mapped to one or more entity nodes in the unified industrial semantic network to form the first entity node set. Starting from each entity node in the first entity node set, a traversal search is performed along the relation edges in the unified industrial semantic network, wherein the depth of the traversal search is limited to a predetermined number of hops. During the traversal, at least one conflicting edge is identified, and the two entity nodes connected to each conflicting edge are obtained; Determine whether the two entity nodes belong to different CAX domains. If so, identify the two entity nodes as a multi-domain constraint conflict pair, and summarize at least one multi-domain constraint conflict pair to generate a conflict list.

6. The intelligent collaboration method based on CAX according to claim 5, characterized in that, The traversal search along the relation edges in the unified industrial semantic network specifically includes: Initialize the queue of nodes to be visited and the set of visited nodes, and add the current starting node to the queue of nodes to be visited and the set of visited nodes; Take any node from the queue of nodes to be visited as the current node, and traverse each adjacency edge of the current node to determine whether the adjacency edge is a conflict edge. The conflict edge includes geometric conflict, physical conflict and process conflict. If so, then record the adjacent edges in the conflict edge set; For each neighboring node connected to the current node by a non-conflict relationship edge, if the neighboring node is not recorded in the visited node set, it is added to the unvisited node queue and the visited node set until the unvisited node queue is empty. After completing a breadth-first traversal of all entity nodes in the first entity node set as starting nodes, merge all conflicting edges recorded during the traversal process to determine the conflicting edge set.

7. The intelligent collaboration method based on CAX according to claim 1, characterized in that, Based on predefined negotiation rules, automatic conflict resolution is performed among multiple specialized intelligent agents via an A2A protocol to generate an executable task sequence, specifically including: From the multi-domain constraint conflict pairs in the conflict list, determine the current conflict pair to be negotiated, and determine at least two relevant professional intelligent agents related to the current conflict pair to be negotiated; The negotiation initiating agent generates a tender message containing a conflict description based on the type of the current conflict pair to be negotiated, and sends the tender message to the relevant professional agent through the A2A protocol; Historical negotiation data related to the relevant professional intelligent agent and the current conflict pair to be negotiated are obtained from the unified industrial semantic network. Based on the internal objective function of the relevant professional intelligent agent and the historical negotiation data, a bidding message is generated and sent back to the negotiation initiating intelligent agent through the A2A protocol. The negotiation initiating agent sorts the solution proposals in at least one of the bidding messages according to preset decision rules, and selects the solution proposals that meet the preset requirements to determine the negotiation consensus. Based on the consensus reached, design parameters, simulation settings, and / or process planning related to the current conflict to be negotiated are adjusted or confirmed to automatically resolve the conflict. The executable task sequence is then arranged and generated according to the logical dependencies between each CAX operation, wherein the logical dependencies are derived from the temporal or causal edges in the unified industrial semantic network.

8. The intelligent collaboration method based on CAX according to claim 7, characterized in that, Based on the internal objective function and historical negotiation data of the relevant professional intelligent agent, a bidding message is generated, specifically including: Based on the conflict type in the bidding message, at least one predefined solution proposal related to the conflict type is retrieved from the unified industrial semantic network to obtain modification instructions for the CAX parameter set corresponding to each solution proposal; Based on the modification instructions, the change in the internal objective function of the relevant professional intelligent agent is simulated and calculated to determine the first evaluation factor; Query the historical negotiation records connected to the current conflicting node in the unified industrial semantic network to obtain the success rate of historical proposals using the same solution, and determine the second evaluation factor. The first evaluation factor and the second evaluation factor are fused together according to preset weights to determine the comprehensive evaluation score of the proposed solution. The proposed solution and its corresponding comprehensive evaluation score are encapsulated to determine the bidding message.

9. A CAX-based intelligent collaborative device, characterized in that, The device includes: At least one processor; and, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform the method as described in any one of claims 1-8.

10. A non-volatile computer storage medium storing computer-executable instructions, characterized in that, The computer-executable instructions are configured to perform the method as described in any one of claims 1-8.

Images