An automatic modeling agent system based on MCP protocol and large model

Abstract

The present invention relates to an automatic modeling agent system based on the MCP protocol and a large model. The system comprises: a multimodal input interface module for receiving, parsing, and standardizing modeling instructions or intention descriptions input by users through different media to form structured feature representations; a semantic understanding hub module for using a pre-trained large language model to perform semantic analysis on the structured feature representations and output the user's modeling intentions; an MCP instruction compiler module for converting the user's modeling intentions into MCP instruction sequences that comply with the MCP protocol; and a modeling execution engine module for parsing and automatically executing the MCP instruction sequences to complete the modeling of the target three-dimensional model. This system allows users to complete three-dimensional modeling without having to understand specialized modeling terminology and concepts, significantly improving the level of modeling automation and intelligence.

Description

Technical Field

[0001] The present invention relates to the technical field of three-dimensional modeling, and in particular to an automatic modeling intelligent agent system based on an MCP protocol and a large model. Background Art

[0002] Traditional 3D modeling tools, such as Blender and 3ds Max, rely primarily on manual operation to create and edit models. While this approach can provide highly customized results, it is relatively inefficient and requires high operator skills. Furthermore, most existing AI-based 3D modeling tools can only generate simple models based on fixed templates, making it difficult to handle complex semantic requirements or achieve high-degree-of-freedom designs.

[0003] In recent years, the development of large-scale language models (such as GPT-4) has significantly improved the ability of multimodal semantic understanding. However, these advanced models still have shortcomings in deeply integrating with professional fields (such as 3D modeling), especially in how to translate high-level semantic understanding into specific modeling instructions.

[0004] The Model Context Protocol (MCP) defines how contextual information is exchanged between applications and AI models. This enables developers to connect various data sources, tools, and functions to AI models in a consistent manner. MCP's goal is to create a common standard that makes the development and integration of AI applications simpler and more unified. MCP enables more efficient data exchange and model control, providing a more flexible foundation for automated modeling.

[0005] The closest existing technology is parametric modeling based on deep learning, whose technical architecture consists of three core components. The semantic parsing module uses a convolutional neural network (CNN) to extract features from the input text, capturing local semantic features through convolution operations. The extracted semantic features are then matched and mapped with a preset template library. When the feature matching degree exceeds a threshold, the corresponding modeling parameter template is called. If the match fails, an algorithm is used to generate approximate parameters. Analysis revealed that this solution has several technical limitations: a template dependency bottleneck, combining standard parameters from a preset template library, resulting in a lack of innovation in the generated model and a heavy reliance on the existing template library content; a lack of interactive control, which means the modeling process lacks a dynamic intervention mechanism, preventing users from making real-time parameter corrections during the generation process; and a lack of process traceability, which means the system processes modeling instructions using an unstructured binary stream, resulting in a black box generation process. Summary of the Invention

[0006] To solve the above problems, an embodiment of the present invention aims to provide an automatic modeling intelligent agent system based on the MCP protocol and a large model.

[0007] An automatic modeling intelligent agent system based on the MCP protocol and a large model, comprising:

[0008] The multimodal input interface module is used to receive, parse, and standardize modeling instructions or intention descriptions input by users through different media to form structured feature representations;

[0009] The semantic understanding hub module uses a pre-trained large language model to perform semantic analysis on structured feature representations and output user modeling intent.

[0010] The MCP instruction compiler module is used to convert the user's modeling intention into an MCP instruction sequence that complies with the MCP protocol;

[0011] The modeling execution engine module is used to parse and automatically execute the MCP instruction sequence to complete the modeling of the target three-dimensional model.

[0012] Preferably, the multimodal input interface module includes:

[0013] An input channel manager, configured to identify the type of user input data and input the data into a corresponding preprocessor; the types of input data include text, image, and sketch;

[0014] A text preprocessor is used to preprocess text data to obtain structured text information;

[0015] An image preprocessor, used to preprocess image data to obtain structured image information;

[0016] Sketch preprocessor, used to preprocess image data to obtain output structured sketch representation;

[0017] The standardized fusion unit is used to fuse structured text information, structured image information and structured sketch representation to form a structured feature representation.

[0018] Preferably, the semantic understanding hub module includes:

[0019] Multimodal fusion parser, used to enhance the structured feature representation to form a comprehensive semantic representation vector or graph structure;

[0020] The large model processing unit is used to use a pre-trained large language model to perform semantic analysis on the comprehensive semantic representation vector or graph structure to output the user modeling intention.

[0021] Preferably, the MCP instruction compiler module includes:

[0022] Semantics to instruction mapper, used to map user modeling intentions into corresponding MCP atomic instructions to form an MCP atomic instruction sequence;

[0023] The instruction serializer and optimizer is used to use the MCP instruction sequence intelligent optimization algorithm to sort the generated MCP atomic instruction sequence according to the logical dependency relationship to form an ordered instruction sequence.

[0024] Preferably, the instruction serializer and optimizer includes:

[0025] Calculate the dependency between two instructions to form a dependency graph;

[0026] Traverse the nodes in the dependency graph, identify consecutive, mergeable instruction types, and for mergeable instruction groups, calculate the total cost of executing each instruction individually and the execution cost of the merged instructions.

[0027] The merge decision function is used to merge and execute the instructions that meet the conditions, and replace the original multiple nodes with a new merged node;

[0028] Based on the dependencies between instructions, the non-interdependent instructions are divided into groups that can be executed in parallel. For each group of instructions that can be executed in parallel, the serial execution cost and parallel execution cost of all instructions in the group are calculated.

[0029] When the cost of parallel execution is lower than the cost of serial execution, the group of instructions is kept for parallel execution; otherwise, the group of instructions is sorted in descending order according to the execution cost and executed serially.

[0030] Preferably, the calculation formula for the degree of dependency between two instructions is:

[0031]

[0032] in, For instructions i The output object collection, For instructions j A collection of input objects, is the dependency type adjustment factor, Indicates instructions i and instructions j The degree of dependence between them.

[0033] Preferably, the execution cost calculation formula of the instruction is:

[0034]

[0035] in: For execution costs, For the i The weight of the instruction, For the i The basic cost of an instruction, is the parallel penalty factor, For the j The additional overhead of a parallel group.

[0036] Preferably, the merge decision function is:

[0037]

[0038] in: is the cost of executing the first instruction alone, is the cost of executing the second instruction alone, is the execution cost after the merger, is the merge threshold; when the value of the merge decision function is 1, the instructions are merged and executed, and the original multiple nodes are replaced by a merged new node.

[0039] Preferably, the modeling execution engine module includes:

[0040] The MCP instruction parser is used to read and parse the MCP instruction sequence one by one, verify the legitimacy of the instruction, and use the verified instructions as the parsed MCP instructions;

[0041] The core modeling library interface is used to convert the parsed MCP instructions into calls to functions in the underlying modeling library of the modeling engine;

[0042] The scene state manager is used to display the status information of the 3D scene currently being constructed in real time;

[0043] Geometric calculation and constraint solver, used to optimize the initially constructed 3D model using a modeling accuracy optimization algorithm based on constraint propagation;

[0044] Real-time feedback interface, used to send intermediate results or final model data during the modeling process to the user interface for real-time preview.

[0045] Preferably, the geometric calculation and constraint solver include:

[0046] Obtaining an initially constructed three-dimensional model and a list of geometric constraints; the geometric constraints include: parallelism constraints, perpendicularity constraints, distance constraints, and symmetry constraints;

[0047] Calculate the priority of each constraint in the geometric constraint list; the constraint priority calculation formula is:

[0048]

[0049] in, is the weight of the i-th constraint feature, is the i-th constraint characteristic function, is the relevance weight, To constrain the association, Indicates the priority of constraint C in the entire modeling process;

[0050] The initially constructed three-dimensional model is continuously optimized according to the priority of each constraint until the termination condition is met.

[0051] According to the specific embodiments provided by the present invention, the present invention discloses the following technical effects:

[0052] The present invention relates to an automatic modeling intelligent agent system based on the MCP protocol and large models. Compared with the existing technology, the present invention can complete three-dimensional modeling without the user having to understand professional modeling terms and concepts, greatly improving the level of modeling automation and intelligence.

[0053] In order to make the above-mentioned objects, features and advantages of the present invention more obvious and easy to understand, preferred embodiments are given below and described in detail with reference to the accompanying drawings. BRIEF DESCRIPTION OF THE DRAWINGS

[0054] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0055] Figure 1 A schematic diagram of an automatic modeling agent system based on the MCP protocol and a large model provided by the present invention;

[0056] Figure 2 Schematic diagram of the multimodal input interface module provided by the present invention;

[0057] Figure 3 Schematic diagram of the semantic understanding hub module provided by the present invention;

[0058] Figure 4 The schematic diagram of the MCP instruction compilation module provided by the present invention;

[0059] Figure 5 Schematic diagram of the modeling execution engine module provided by the present invention;

[0060] Figure 6 This is a schematic diagram of the three-dimensional model output module provided by the present invention. DETAILED DESCRIPTION

[0061] In the description of the present invention, it should be understood that the terms "center", "longitudinal", "lateral", "length", "width", "thickness", "up", "down", "front", "back", "left", "right", "vertical", "horizontal", "top", "bottom", "inside", "outside", "clockwise", "counterclockwise" and the like to indicate orientations or positional relationships based on the orientations or positional relationships shown in the accompanying drawings, and are only for the convenience of describing the present invention and simplifying the description, rather than indicating or implying that the device or element referred to must have a specific orientation, be constructed and operated in a specific orientation, and therefore should not be understood as limiting the present invention.

[0062] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of the technical features being referred to. Thus, a feature identified as "first" or "second" may explicitly or implicitly include one or more of the features. In the description of the present invention, "plurality" means two or more, unless otherwise specifically defined.

[0063] In the present invention, unless otherwise expressly specified or limited, the terms "mounted," "connected," "connect," "fixed," etc. should be understood broadly. For example, they may refer to fixed, detachable, or integral connections; mechanical or electrical connections; direct or indirect connections through an intermediary; or internal communication between two components. Those skilled in the art will understand the specific meanings of the above terms in the present invention based on specific circumstances.

[0064] See also Figure 1 , an automatic modeling intelligent agent system based on the MCP protocol and large models, including:

[0065] The multimodal input interface module is used to receive, parse, and standardize modeling instructions or intention descriptions input by users through different media to form structured feature representations;

[0066] See also Figure 2 The multimodal input interface module is the system's perception front end, responsible for receiving, parsing, and standardizing modeling instructions or intent descriptions input by users through various media (text, images, sketches). Its core goal is to transform heterogeneous, unstructured user input into a unified, structured feature representation containing preliminary semantic information for processing by downstream semantic understanding centers. The multimodal input interface module includes:

[0067] Input Channel Manager: Identifies the type of input data (such as .txt, .jpg, .png, real-time streaming from a drawing tablet, etc.) and routes the data to the corresponding preprocessor.

[0068] Text preprocessor: Receives natural language text input and performs sentence segmentation, word segmentation, part-of-speech tagging, named entity recognition (identifying object nouns, attribute words, spatial relationship words, etc.), and dependency parsing (preliminarily identifying the modification and dominance relationships between words). Output is structured text information with annotated word sequences and preliminary semantic primitives.

[0069] Image Preprocessor: Receives a reference image or photo in bitmap format. It performs image denoising, color correction, and size normalization on the input image. It uses an object detection model to identify key objects and their bounding boxes. It uses an image segmentation model to extract object outlines or masks. It also uses a feature extraction network to extract global and local visual features. It outputs a list of objects (including category, location, and mask) and a set of visual feature vectors.

[0070] Sketch preprocessor: accepts hand-drawn sketches in vector format (such as SVG) or bitmap format.

[0071] The input bitmap sketch undergoes denoising, binarization, and skeleton extraction. A stroke segmentation algorithm is used to split continuous lines into meaningful stroke segments. A geometric primitive recognition algorithm is used to identify lines and circles, or more complex learning-based methods are used to identify curves, abstracting strokes into geometric primitives. The connectivity and topological structure between primitives are analyzed. The resulting output is a structured sketch representation consisting of a stroke sequence, a list of geometric primitives, and their connectivity.

[0072] The standardized fusion unit receives structured information from each preprocessor. It maps information from different modalities into a shared feature space, generating a unified internal data structure. For example, a composite feature object containing text semantic primitives, a list of visual objects, and sketch geometry must be included. This object must also include metadata such as timestamps and input sources.

[0073] Through diverse preprocessors and standardized processes, the requirements for user input format and professionalism are reduced, laying the foundation for subsequent accurate understanding of user intent.

[0074] The semantic understanding hub module uses a pre-trained large language model to perform semantic analysis on structured feature representations and output user modeling intent.

[0075] See also Figure 3 The semantic understanding central module serves as the cognitive core of the system. This module is responsible for performing in-depth semantic analysis and reasoning on the standardized multimodal features provided by the input interface module, accurately and completely understanding the user's modeling intentions, and parsing them into a series of clear, high-level semantic instructions or parameterized descriptions oriented to modeling tasks.

[0076] Furthermore, the semantic understanding core module includes:

[0077] Multimodal Fusion Parser: This receives standardized composite feature objects and uses a cross-attention mechanism, such as that found in the Transformer architecture, to deeply fuse text, image, and sketch features, capturing cross-modal associations (e.g., the association between the text description "red cube" and the red area in the image and the square outline in the sketch). A Graph Neural Network (GNN) is used to jointly model the semantic primitives of the text and the topological structure of the sketch.

[0078] Output: A highly fused, context-rich, and comprehensive semantic representation vector or graph structure.

[0079] Large model processing unit: Receives the fused semantic representation. The large model is a large language model (LLM) or visual language model (VLM) that has been fine-tuned by instruction following in the modeling domain.

[0080] Intent recognition: Determine whether the user's core instruction is to create a new object, modify an existing object, combine objects, or query status, etc.

[0081] Entity and attribute extraction: Accurately identify the objects to be operated (such as "table", "chair"), the attributes of the objects (such as "size length, width and height", "color is brown", "material is wood"), the spatial relationship between objects (such as "above...", "immediately adjacent", "aligned"), and the quantity (such as "three"), etc.

[0082] Constraint parsing: Understand and process the constraints in the user description (such as "height no more than 1 meter", "stay parallel to the wall").

[0083] Ambiguity resolution and information completion: When user input is ambiguous or insufficient, the knowledge and reasoning capabilities of the large model are used to clarify (which may require interaction with the user and feedback through the input interface module) or to provide reasonable completion based on common sense (e.g., if the number of chair legs is not specified, the default is 4).

[0084] The final output is a structured high-level semantic description, such as a JSON object containing a list of objects, a dictionary of attributes for each object, a relationship graph between objects, global constraints, or similar data structures.

[0085] The MCP instruction compiler module is used to convert the user's modeling intention into an MCP instruction sequence that complies with the MCP protocol;

[0086] See also Figure 4The MCP instruction compiler module serves as a bridge between semantic understanding and specific execution. This module is responsible for accurately translating the abstract, high-level semantic description output by the semantic understanding center into a series of low-level, executable atomic instruction sequences that follow the predefined modeling control protocol.

[0087] Semantic to Instruction Mapper: Maintains a mapping rule base to map high-level semantic concepts (such as "create a cuboid" with attributes: length = 10, width = 5, height = 2) to one or more MCP atomic instructions:

[0088] CREATE_PRIMITIVE(type=CUBOID, size=[10,5,2], id=obj1))

[0089] Decomposition of complex operations, such as "place cylinder A directly above the center of cube B", is broken down into the following multiple instructions:

[0090] GET_BOUNDING_BOX(id=B)

[0091] CALCULATE_CENTER(box=...)

[0092] GET_BOUNDING_BOX(id=A)

[0093] CALCULATE_BOTTOM_CENTER(box=...)

[0094] MCP instruction set definition library: defines all atomic operations of the MCP protocol, including but not limited to:

[0095] Geometry creation: CREATE_PRIMITIVE (parameters: type, size, ID), CREATE_FROM_CURVE (parameters: curve data, ID)

[0096] Transformation operations: TRANSLATE, ROTATE, SCALE (parameters: object ID, transformation parameters)

[0097] Boolean operations: BOOLEAN_UNION, BOOLEAN_DIFFERENCE, BOOLEAN_INTERSECT (parameter: object ID list)

[0098] Apply modifier: APPLY_MODIFIER (parameters: object ID, modifier type, parameters)

[0099] Materials and Appearance: ASSIGN_MATERIAL (parameters: object ID, material ID / parameters), SET_COLOR (parameters: object ID, color value)

[0100] Scene management: GROUP_OBJECTS, SET_PARENT (parameters: object ID list / parent-child ID)

[0101] Each instruction has strict parameter definitions and expected behavior.

[0102] Furthermore, the MCP instruction compiler module includes:

[0103] Material Database API: Based on the material information in the semantic description (e.g., "wood" or "brushed metal"), query the pre-set material database (which contains material names, PBR parameters, texture map paths, etc.). Obtain the matching material ID or detailed parameters and fill them into the ASSIGN_MATERIAL and other related commands.

[0104] Instruction Serialization and Optimizer: Leveraging an intelligent MCP instruction sequence optimization algorithm, the generated atomic instructions are sorted according to logical dependencies (e.g., objects must be created before transformations can be performed), forming an ordered instruction sequence. This module merges consecutive identical transformations, eliminates redundant operations, and adjusts the instruction sequence based on the execution engine's characteristics to improve efficiency. This module outputs the final, optimized MCP instruction stream (e.g., a JSON array, where each element is an MCP instruction and its parameters). This module addresses the lack of standardization in the modeling process, ensures accurate communication from modeling intent to execution, and lays the foundation for automated execution.

[0105] The MCP instruction sequence intelligent optimization algorithm can optimize the execution efficiency of the instruction sequence, ensure the correctness of the instruction sequence, reduce redundant operations, and improve the efficiency of parallel execution of instructions.

[0106] The formula for calculating instruction cost is:

[0107]

[0108] in: is the total cost, is the weight of the i-th instruction, is the basic cost of the ith instruction, is the parallel penalty factor, is the additional overhead of the j-th parallel group.

[0109] This formula is used to assign weights to each node when building the graph and is used to evaluate the cost of serial and parallel execution strategies during the final optimization.

[0110] (2) Instruction dependency calculation

[0111] The degree of dependency between two instructions:

[0112]

[0113] in: is the output object set of instruction i, is the input object set of instruction j, Adjustment factor for dependency type.

[0114] This formula is used to obtain the closeness of the association between instructions and establish the dependency relationship between instructions.

[0115] (3) Instruction merging evaluation function

[0116] Merge decision function:

[0117]

[0118] in: 、 is the cost of executing the two instructions separately, is the execution cost after the merger, is the merging threshold.

[0119] This formula is used to determine whether it is worthwhile to combine multiple simple operations (such as continuous transforms) into a more complex but potentially more efficient operation to reduce the number of instructions and potential overhead.

[0120] (4) Parallelism optimization formula

[0121] Optimal parallelism calculation:

[0122]

[0123] in: is the serial execution time, is the execution time of a single instruction, is the parallel overhead factor, The maximum parallelism supported by the hardware

[0124] The formula is used to identify groups of instructions that can be executed simultaneously based on dependencies, and decides whether to execute the instruction groups in parallel or serially and the optimal number of instructions to execute in parallel based on the cost model and hardware limitations.

[0125] The algorithm flow is as follows:

[0126] 1. Start: Enter the original MCP instruction sequence instruction_sequence.

[0127] 2. Build dependency graph:

[0128] Iterate over the input instruction_sequence.

[0129] Calculate node cost: For each instruction inst, calculate its execution cost cost using the predefined instruction cost calculation formula (1) according to its type, such as CREATE_PRIMITIVE, TRANSFORM, and create an InstructionNode.

[0130] Establishing instruction dependencies: Using the instruction's input_objects and output_objects, use formula (2) to calculate object overlap information to determine dependency strength and form a dependency graph.

[0131] 3. Merge mergeable instructions:

[0132] Traverse the nodes in the build dependency graph and identify consecutive, mergeable instruction types (such as consecutive TRANSFORM operations).

[0133] Evaluate the benefits of merging: For each group of instructions that can be merged, calculate the total cost of executing each instruction individually and the cost of the merged instructions. Use the logic of formula (3) to make a decision: if the cost reduction exceeds the threshold, perform the merge and replace the original multiple nodes with a new merged node.

[0134] 4. Analyze parallel possibilities:

[0135] Based on the dependencies between instructions, instructions that do not depend on each other are divided into groups that can be executed in parallel.

[0136] 5. Calculate the execution cost of each group:

[0137] For each instruction group that can be executed in parallel, the total serial cost and the estimated parallel execution cost of all instructions in the group are calculated again using formula (1).

[0138] 6. Optimize sequence based on cost and parallel strategy

[0139] Compare serial cost and parallel cost. Apply formula (4) to perform decision analysis: if the cost of parallel execution is lower than the serial cost, keep the group of instructions in parallel execution; otherwise, you may need to sort the group of instructions in descending order of cost for serial execution, or limit the degree of parallelism.

[0140] The final instruction execution order is determined based on the optimization decision (maintain parallelism, serialize, limit parallelism).

[0141] 7. End: Output the optimized MCP instruction sequence.

[0142] This algorithm introduces graph-based dependency analysis to ensure that instruction optimization does not disrupt execution order. It also uses a cost model for quantitative analysis to achieve the optimal execution strategy. It supports instruction merging and parallel optimization, taking into account hardware characteristics and dynamically adjusting the degree of parallelism of instruction execution.

[0143] See also Figure 5 , the modeling execution engine module is used to parse and automatically execute the MCP instruction sequence to complete the modeling of the target three-dimensional model.

[0144] The modeling execution engine module serves as the execution core of the system. This module is responsible for receiving and accurately parsing the MCP instruction sequence, calling the underlying geometric modeling library functions, gradually building or modifying the model in the virtual three-dimensional space, and maintaining the scene status.

[0145] MCP Instruction Parser: Reads the MCP instruction stream line by line. Verifies the legitimacy of the instruction (whether the instruction name exists, and whether the parameter types and number are correct). Parses the instruction parameters to extract the operation type and specific value.

[0146] Core Modeling Library Interface: This is an adaptation layer that converts parsed MCP instructions into function calls to specific underlying modeling libraries. This core modeling library interface connects to the underlying modeling libraries of various modeling engines on the market (such as the Blender Python API, Open CASCADE Technology, Unity Engine API, or self-developed geometry libraries).

[0147] For example, CREATE_PRIMITIVE(type=CUBOID, size=[10,5,2], id=obj1) might be translated into bpy.ops.mesh.primitive_cube_add(size=1, scale=(10,5,2)) and the returned object would be named obj1.

[0148] The Scene State Manager maintains an internal data structure (e.g., the Scene Graph) that represents the current state of the 3D scene in real time, including the position, pose, geometry, material, and hierarchical relationships of all objects. When executing commands, it updates the corresponding nodes and attributes in the scene graph. It also provides a query interface for the command compiler or semantic understanding module to obtain current scene information (for constraint checking or relative operations).

[0149] Geometric Calculation and Constraint Solver: Leveraging a modeling accuracy optimization algorithm based on constraint propagation, this system provides low-level geometric operation support (such as bounding box calculations, distances, and intersections). It also handles complex constraints involved in MCP instructions (such as alignment and isometrics).

[0150] The modeling accuracy optimization algorithm based on constraint propagation can improve modeling accuracy, maintain geometric constraints of the model, optimize the model topology structure, and ensure modeling stability.

[0151] (1) Constraint priority calculation

[0152] Constraint Priority Scoring

[0153]

[0154] in: are the weights of different constraint features, is the constraint characteristic function, is the relevance weight, To constrain the association degree.

[0155] This formula is used to guide the order and focus of optimization, ensuring that key constraints are prioritized.

[0156] (2) Calculation of geometric constraint error

[0157] Parallelism constraint error

[0158]

[0159] Verticality constraint error

[0160]

[0161] in: is the first vector, representing a direction vector in the model, is the second vector, indicating another direction vector in the model. is the dot product of two vectors, is a vector The modulus (length), is a vector The modulus (length), is the parallelism error. The smaller the value, the more parallel the two vectors are. The smaller the value, the more perpendicular the two vectors are.

[0162] Distance constraint error

[0163]

[0164] in: is the coordinate vector of the first point, is the coordinate vector of the second point, is the target distance value, is the actual distance between the two points, The smaller the value, the closer the actual distance is to the target distance.

[0165] Symmetry constraint error

[0166]

[0167] in: is the coordinate vector of the original point, is the coordinate vector of the mapping point p on the symmetry plane, are the parameters of the symmetry plane (normal vector and distance), for point The distance to the plane, for point The distance to the plane, It is the symmetry error, the smaller the value, the better the symmetry.

[0168] The geometric error formula is the core calculation of each iteration, quantifying how much the current model deviates from each constraint.

[0169] (3) Constraint propagation weight calculation

[0170] Propagation weight matrix:

[0171]

[0172] in: To constrain the topological distance between i and j, is the propagation attenuation factor

[0173] This formula expresses the mutual influence between constraints, so that the adjustment of one constraint can be intelligently propagated to related parts.

[0174] (4) Model optimization objective function

[0175]

[0176] in: is the error of the i-th constraint, is the regularization term, is the smoothness measure, 、 、 is the weight coefficient.

[0177] This formula defines the final goal of the algorithm and is a comprehensive reflection of all constraint error satisfaction, model regularization and smoothness.

[0178] (5) Topology optimization quality metrics

[0179] Patch quality assessment:

[0180]

[0181] in: is the patch area, is the edge length of the patch.

[0182] Edge sharpness metrics:

[0183]

[0184] in: is the current dihedral angle, is the target dihedral angle.

[0185] Topology optimization quality metric formulas are used to further improve model quality after iterative optimization to ensure there are no cracks, bad faces, or unnatural sharp edges.

[0186] (6) Convergence judgment criteria:

[0187] Iteration termination condition

[0188]

[0189] in: is the error of the i-th constraint in the t-th iteration, is the convergence threshold, is the maximum number of iterations.

[0190] This formula is used to determine whether the iterative process has achieved a good enough result and stop the iteration.

[0191] The algorithm flow is as follows:

[0192] 1. Start: Input the initial 3D model model and a list of geometric constraints constraints.

[0193] 2. Constraint layering:

[0194] Iterate over the constraints list.

[0195] For each constraint, its priority Priority(C) is calculated using formula (1), which takes into account factors such as constraint type, complexity of objects involved, and correlation with other constraints.

[0196] Constraints are divided into different levels constraint_layers according to the calculated priority. Constraints with higher priority will be satisfied first in subsequent optimization and have greater influence.

[0197] 3. Build a constraint network:

[0198] Based on the hierarchical results, an internal constraint network data structure is constructed. This data contains the constraints themselves and the association information between constraints.

[0199] 4. Initialize iteration: Set the iteration counter t = 0 and initialize the model state.

[0200] 5. Enter the iterative optimization loop: Start the main optimization loop, provided that the number of iterations t has not reached the maximum value and the model has not converged.

[0201] 6. Traverse the constraint network: In each iteration, traverse the constraints in the constraint network. The traversal order is affected by the priority.

[0202] 7. Apply a single constraint:

[0203] Use formulas (2), (3), (4), and (5) to calculate the constraint error under the current constraints. Adjusting a constraint may affect other constraints or model parts associated with it. The intensity of the impact can be calculated using weights similar to this formula to guide the direction and magnitude of the model update.

[0204] 8. Record the maximum error: Record the maximum error calculated by all constraints in this iteration.

[0205] 9. Check convergence:

[0206] After completing a round of constraint traversal or reaching a predetermined evaluation point, use formula (10) to determine whether the convergence condition is met: compare whether the maximum error or error change of the current iteration is less than the threshold.

[0207] 10. Update model status:

[0208] If convergence has not yet occurred, the model parameters (e.g., vertex coordinates) are updated based on all constraint errors calculated in this iteration (and any propagation effects). This update aims to minimize the overall optimization objective function, Equation (7), which is typically a weighted sum of all constraint errors, including regularization and smoothness terms. The model is updated and the number of iterations, t = t + 1, is increased. Return to step 1 and continue with the next iteration.

[0209] 11. Perform topology optimization:

[0210] When the iteration cycle ends (convergence or reaching the maximum number of iterations), the topology optimization phase begins. A series of operations are performed to improve the mesh quality and structure of the model, such as boundary repair, singular point processing, patch optimization using formula (8), and edge sharpening using formula (9).

[0211] 12. End: Output the final optimized 3D model that meets the constraints and has a good topological structure.

[0212] The algorithm ensures that important constraints are met first through multi-level and hierarchical processing, introduces a constraint propagation mechanism to achieve global optimization, integrates topology optimization, improves model quality, and ensures algorithm convergence through an adaptive iterative strategy.

[0213] Error handling and rollback mechanisms: If an error occurs while executing an instruction (e.g., a Boolean operation failure, invalid parameters), the error is logged and an attempt is made to recover or skip the instruction. Transaction processing is supported, allowing rollback to the previous stable state if a critical step fails.

[0214] Real-time Feedback Interface: This module provides an API that allows intermediate results or final model data to be sent to the user interface for real-time preview. This module addresses inefficient modeling by automating the execution of standard commands and solves the problem of unstable model quality, as the results of standard commands are more controllable.

[0215] See also Figure 6 ,3D model output module, as the delivery end of the system, this module is responsible for exporting the internal scene data structure finally built by the modeling execution engine into one or more standard 3D file formats according to user needs, and can perform necessary optimization and post-processing.

[0216] Format exporter collection: Contains dedicated exporters for multiple target formats (such as obj, fbx, gltf / glb, stl, step, etc.). Each exporter is responsible for converting internal scene graph data (vertices, faces, normals, UV coordinates, materials, skeletal animation, etc.) into the data structure specified by the target format.

[0217] Model Data Converter: Handles coordinate system conversion (e.g., from left-handed to right-handed), unit conversion (e.g., from internal units of meters to centimeters), and conversion and packaging of material and texture information (e.g., generating bin and png files for glTF).

[0218] Post-processing and optimization unit, providing optional post-processing functions:

[0219] Mesh optimization: Decimation, triangulation, redundant vertex removal, normal calculation and smoothing group processing, UV unwrapping and optimization, and texture baking. User-configurable optimization parameters (such as target face count and whether to preserve detail).

[0220] Output Configuration and File Writer: Receives user-specified output format, file path, and export options (e.g., whether to export animations or embed textures). It then calls the exporter and optimization unit for the corresponding format. It then writes the final data to the file system.

[0221] A standardized output interface is provided to facilitate users to use the model in different platforms and software; optimization options help improve the performance and quality of the final model.

[0222] The present invention integrates text descriptions, design drawings, and hand-drawn sketches as diverse inputs, and uses the understanding capabilities of pre-trained large models to perform in-depth semantic analysis on the fused information to output the user's modeling intention. The MCP instruction compiler translates the modeling intention information into a standardized, executable atomic instruction sequence that complies with the MCP protocol. The modeling execution engine parses and automatically executes the MCP instruction sequence, calling the underlying modeling functions to complete the three-dimensional model construction. This eliminates the need for users to understand a large amount of professional modeling terms and concepts, greatly improving the level of modeling automation and standardization.

[0223] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any technical solution that can be easily conceived by a person skilled in the art within the technical scope disclosed in the present invention should be included in the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be based on the scope of protection of the claims.

Claims

1. An automatic modeling agent system based on the MCP protocol and a large model, characterized by: include: The multimodal input interface module is used to receive, parse, and standardize modeling instructions or intention descriptions input by users through different media to form structured feature representations; The semantic understanding hub module uses a pre-trained large language model to perform semantic analysis on structured feature representations and output user modeling intent. The MCP instruction compiler module is used to convert the user's modeling intention into an MCP instruction sequence that complies with the MCP protocol; Modeling execution engine module, used to parse and automatically execute MCP instruction sequences to complete the modeling of the target 3D model; The MCP instruction compiler module includes: Semantics to instruction mapper, used to map user modeling intentions into corresponding MCP atomic instructions to form an MCP atomic instruction sequence; Instruction serialization and optimizer, which uses the MCP instruction sequence intelligent optimization algorithm to sort the generated MCP atomic instruction sequence according to logical dependencies to form an ordered instruction sequence; In the instruction serializer and optimizer, this includes: Calculate the dependency between two instructions to form a dependency graph; Traverse the nodes in the dependency graph, identify consecutive, mergeable instruction types, and for mergeable instruction groups, calculate the total cost of executing each instruction individually and the execution cost of the merged instructions. The merge decision function is used to merge and execute the instructions that meet the conditions, and replace the original multiple nodes with a new merged node; Based on the dependencies between instructions, the non-interdependent instructions are divided into groups that can be executed in parallel. For each group of instructions that can be executed in parallel, the serial execution cost and parallel execution cost of all instructions in the group are calculated. When the cost of parallel execution is lower than the cost of serial execution, the group of instructions is kept for parallel execution; otherwise, the group of instructions is sorted in descending order according to the execution cost and executed serially.

2. The automatic modeling agent system based on the MCP protocol and the large model according to claim 1, characterized in that: The multimodal input interface module includes: An input channel manager, configured to identify the type of user input data and input the data into a corresponding preprocessor; the types of input data include text, image, and sketch; A text preprocessor is used to preprocess text data to obtain structured text information; An image preprocessor, used to preprocess image data to obtain structured image information; Sketch preprocessor, used to preprocess image data to obtain output structured sketch representation; The standardized fusion unit is used to fuse structured text information, structured image information and structured sketch representation to form a structured feature representation.

3. The automatic modeling agent system based on the MCP protocol and the large model according to claim 2, characterized in that: The semantic understanding central module includes: Multimodal fusion parser, used to enhance the structured feature representation to form a comprehensive semantic representation vector or graph structure; The large model processing unit is used to use a pre-trained large language model to perform semantic analysis on the comprehensive semantic representation vector or graph structure to output the user modeling intention.

4. The automatic modeling agent system based on the MCP protocol and large model according to claim 3, characterized in that: The calculation formula for the degree of dependency between two instructions is: Among them, O i is the output object set of instruction i, I j is the set of input objects of instruction j, γ is the dependency type adjustment factor, D(I i ,I j ) represents the degree of dependency between instruction i and instruction j.

5. The automatic modeling agent system based on the MCP protocol and the large model according to claim 4, characterized in that: The execution cost of an instruction is calculated as follows: Where: C total is the execution cost, w i is the weight of the ith instruction, c i is the basic cost of the i-th instruction, α is the parallel penalty factor, p j is the additional overhead of the j-th parallel group.

6. The automatic modeling agent system based on the MCP protocol and the large model according to claim 5, characterized in that: The merge decision function is: Where: C(I1) is the cost of executing the first instruction alone, C(I2) is the cost of executing the second instruction alone, and C(I merged ) is the execution cost after merging, and β is the merging threshold; when the value of the merging decision function is 1, the instructions are merged and executed, and the original multiple nodes are replaced by a new merged node.

7. The automatic modeling agent system based on the MCP protocol and the large model according to claim 6, characterized in that: Modeling execution engine module, including: The MCP instruction parser is used to read and parse the MCP instruction sequence one by one, verify the legitimacy of the instruction, and use the verified instructions as the parsed MCP instructions; The core modeling library interface is used to convert the parsed MCP instructions into calls to functions in the underlying modeling library of the modeling engine; The scene state manager is used to display the status information of the 3D scene currently being constructed in real time; Geometric calculation and constraint solver, used to optimize the initially constructed 3D model using a modeling accuracy optimization algorithm based on constraint propagation; Real-time feedback interface, used to send intermediate results or final model data during the modeling process to the user interface for real-time preview.

8. The automatic modeling agent system based on the MCP protocol and the large model according to claim 7, characterized in that: In the geometry calculation and constraint solver, including: Obtaining an initially constructed three-dimensional model and a list of geometric constraints; the geometric constraints include: parallelism constraints, perpendicularity constraints, distance constraints, and symmetry constraints; Calculate the priority of each constraint in the geometric constraint list; the constraint priority calculation formula is: Among them, ω i is the weight of the i-th constraint feature, f i (C) is the i-th constraint characteristic function, θ is the relevance weight, R(C) is the constraint relevance, and Priority(C) indicates the priority of constraint C in the entire modeling process; The initially constructed three-dimensional model is continuously optimized according to the priority of each constraint until the termination condition is met.

Images